updated vendor files and paths

vendor/github.com/rubenv/sql-migrate/sqlparse/README.md

@@ -0,0 +1,28 @@
+# SQL migration parser
+
+Based on the [goose](https://bitbucket.org/liamstask/goose) migration parser.
+
+## License 
+
+    (The MIT License)
+
+    Copyright (C) 2014 by Ruben Vermeersch <ruben@rocketeer.be>
+    Copyright (C) 2012-2014 by Liam Staskawicz
+
+    Permission is hereby granted, free of charge, to any person obtaining a copy
+    of this software and associated documentation files (the "Software"), to deal
+    in the Software without restriction, including without limitation the rights
+    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+    copies of the Software, and to permit persons to whom the Software is
+    furnished to do so, subject to the following conditions:
+
+    The above copyright notice and this permission notice shall be included in
+    all copies or substantial portions of the Software.
+
+    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+    THE SOFTWARE.

vendor/github.com/rubenv/sql-migrate/sqlparse/sqlparse.go

@@ -0,0 +1,128 @@
+package sqlparse
+
+import (
+	"bufio"
+	"bytes"
+	"errors"
+	"io"
+
+	"strings"
+)
+
+const sqlCmdPrefix = "-- +migrate "
+
+// Checks the line to see if the line has a statement-ending semicolon
+// or if the line contains a double-dash comment.
+func endsWithSemicolon(line string) bool {
+
+	prev := ""
+	scanner := bufio.NewScanner(strings.NewReader(line))
+	scanner.Split(bufio.ScanWords)
+
+	for scanner.Scan() {
+		word := scanner.Text()
+		if strings.HasPrefix(word, "--") {
+			break
+		}
+		prev = word
+	}
+
+	return strings.HasSuffix(prev, ";")
+}
+
+// Split the given sql script into individual statements.
+//
+// The base case is to simply split on semicolons, as these
+// naturally terminate a statement.
+//
+// However, more complex cases like pl/pgsql can have semicolons
+// within a statement. For these cases, we provide the explicit annotations
+// 'StatementBegin' and 'StatementEnd' to allow the script to
+// tell us to ignore semicolons.
+func SplitSQLStatements(r io.ReadSeeker, direction bool) ([]string, error) {
+	_, err := r.Seek(0, 0)
+	if err != nil {
+		return nil, err
+	}
+
+	var buf bytes.Buffer
+	scanner := bufio.NewScanner(r)
+
+	// track the count of each section
+	// so we can diagnose scripts with no annotations
+	upSections := 0
+	downSections := 0
+
+	statementEnded := false
+	ignoreSemicolons := false
+	directionIsActive := false
+
+	stmts := make([]string, 0)
+
+	for scanner.Scan() {
+
+		line := scanner.Text()
+
+		// handle any migrate-specific commands
+		if strings.HasPrefix(line, sqlCmdPrefix) {
+			cmd := strings.TrimSpace(line[len(sqlCmdPrefix):])
+			switch cmd {
+			case "Up":
+				directionIsActive = (direction == true)
+				upSections++
+				break
+
+			case "Down":
+				directionIsActive = (direction == false)
+				downSections++
+				break
+
+			case "StatementBegin":
+				if directionIsActive {
+					ignoreSemicolons = true
+				}
+				break
+
+			case "StatementEnd":
+				if directionIsActive {
+					statementEnded = (ignoreSemicolons == true)
+					ignoreSemicolons = false
+				}
+				break
+			}
+		}
+
+		if !directionIsActive {
+			continue
+		}
+
+		if _, err := buf.WriteString(line + "\n"); err != nil {
+			return nil, err
+		}
+
+		// Wrap up the two supported cases: 1) basic with semicolon; 2) psql statement
+		// Lines that end with semicolon that are in a statement block
+		// do not conclude statement.
+		if (!ignoreSemicolons && endsWithSemicolon(line)) || statementEnded {
+			statementEnded = false
+			stmts = append(stmts, buf.String())
+			buf.Reset()
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return nil, err
+	}
+
+	// diagnose likely migration script errors
+	if ignoreSemicolons {
+		return nil, errors.New("ERROR: saw '-- +migrate StatementBegin' with no matching '-- +migrate StatementEnd'")
+	}
+
+	if upSections == 0 && downSections == 0 {
+		return nil, errors.New(`ERROR: no Up/Down annotations found, so no statements were executed.
+			See https://github.com/rubenv/sql-migrate for details.`)
+	}
+
+	return stmts, nil
+}

vendor/github.com/rubenv/sql-migrate/sqlparse/sqlparse_test.go

@@ -0,0 +1,151 @@
+package sqlparse
+
+import (
+	"strings"
+	"testing"
+
+	. "gopkg.in/check.v1"
+)
+
+func Test(t *testing.T) { TestingT(t) }
+
+type SqlParseSuite struct {
+}
+
+var _ = Suite(&SqlParseSuite{})
+
+func (s *SqlParseSuite) TestSemicolons(c *C) {
+	type testData struct {
+		line   string
+		result bool
+	}
+
+	tests := []testData{
+		{
+			line:   "END;",
+			result: true,
+		},
+		{
+			line:   "END; -- comment",
+			result: true,
+		},
+		{
+			line:   "END   ; -- comment",
+			result: true,
+		},
+		{
+			line:   "END -- comment",
+			result: false,
+		},
+		{
+			line:   "END -- comment ;",
+			result: false,
+		},
+		{
+			line:   "END \" ; \" -- comment",
+			result: false,
+		},
+	}
+
+	for _, test := range tests {
+		r := endsWithSemicolon(test.line)
+		c.Assert(r, Equals, test.result)
+	}
+}
+
+func (s *SqlParseSuite) TestSplitStatements(c *C) {
+	type testData struct {
+		sql       string
+		direction bool
+		count     int
+	}
+
+	tests := []testData{
+		{
+			sql:       functxt,
+			direction: true,
+			count:     2,
+		},
+		{
+			sql:       functxt,
+			direction: false,
+			count:     2,
+		},
+		{
+			sql:       multitxt,
+			direction: true,
+			count:     2,
+		},
+		{
+			sql:       multitxt,
+			direction: false,
+			count:     2,
+		},
+	}
+
+	for _, test := range tests {
+		stmts, err := SplitSQLStatements(strings.NewReader(test.sql), test.direction)
+		c.Assert(err, IsNil)
+		c.Assert(stmts, HasLen, test.count)
+	}
+}
+
+var functxt = `-- +migrate Up
+CREATE TABLE IF NOT EXISTS histories (
+  id                BIGSERIAL  PRIMARY KEY,
+  current_value     varchar(2000) NOT NULL,
+  created_at      timestamp with time zone  NOT NULL
+);
+
+-- +migrate StatementBegin
+CREATE OR REPLACE FUNCTION histories_partition_creation( DATE, DATE )
+returns void AS $$
+DECLARE
+  create_query text;
+BEGIN
+  FOR create_query IN SELECT
+      'CREATE TABLE IF NOT EXISTS histories_'
+      || TO_CHAR( d, 'YYYY_MM' )
+      || ' ( CHECK( created_at >= timestamp '''
+      || TO_CHAR( d, 'YYYY-MM-DD 00:00:00' )
+      || ''' AND created_at < timestamp '''
+      || TO_CHAR( d + INTERVAL '1 month', 'YYYY-MM-DD 00:00:00' )
+      || ''' ) ) inherits ( histories );'
+    FROM generate_series( $1, $2, '1 month' ) AS d
+  LOOP
+    EXECUTE create_query;
+  END LOOP;  -- LOOP END
+END;         -- FUNCTION END
+$$
+language plpgsql;
+-- +migrate StatementEnd
+
+-- +migrate Down
+drop function histories_partition_creation(DATE, DATE);
+drop TABLE histories;
+`
+
+// test multiple up/down transitions in a single script
+var multitxt = `-- +migrate Up
+CREATE TABLE post (
+    id int NOT NULL,
+    title text,
+    body text,
+    PRIMARY KEY(id)
+);
+
+-- +migrate Down
+DROP TABLE post;
+
+-- +migrate Up
+CREATE TABLE fancier_post (
+    id int NOT NULL,
+    title text,
+    body text,
+    created_on timestamp without time zone,
+    PRIMARY KEY(id)
+);
+
+-- +migrate Down
+DROP TABLE fancier_post;
+`