schema-evolution-manager 0.9.24

data/lib/schema-evolution-manager/migration_file.rb

@@ -0,0 +1,93 @@
+module SchemaEvolutionManager
+
+  # Represents a single file to make a schema migration, typically
+  # stored in the scripts subdirectory.
+  class MigrationFile
+
+    class Attribute
+
+      attr_reader :name, :valid_values
+
+      def initialize(name, valid_values)
+        @name = Preconditions.check_not_blank(name, "name cannot be blank")
+        @valid_values = Preconditions.assert_class(valid_values, Array)
+      end
+
+      unless defined?(ATTRIBUTES)
+        ATTRIBUTES = [Attribute.new("transaction", ["single", "none"])]
+      end
+
+    end
+
+    class AttributeValue
+
+      attr_reader :attribute, :value
+
+      def initialize(attribute_name, value)
+        Preconditions.assert_class(attribute_name, String)
+        @value = Preconditions.assert_class(value, String)
+
+        @attribute = Attribute::ATTRIBUTES.find { |a| a.name == attribute_name }
+        Preconditions.check_not_null(@attribute,
+                                     "Attribute with name[%s] not found. Must be one of: %s" %
+                                     [attribute_name, 
+                                      Attribute::ATTRIBUTES.map { |a| a.name }.join(" ")])
+
+        Preconditions.check_state(@attribute.valid_values.include?(@value),
+                                  "Attribute[%s] - Invalid value[%s]. Must be one of: %s" %
+                                  [@attribute.name, @value, @attribute.valid_values.join(" ")])
+      end
+
+    end
+
+    unless defined?(DEFAULTS)
+      DEFAULTS = [AttributeValue.new("transaction", "single")]
+    end
+
+    attr_reader :path, :attribute_values
+
+    def initialize(path)
+      @path = path
+      Preconditions.check_state(File.exists?(@path), "File[#{@path}] does not exist")
+      @attribute_values = parse_attribute_values
+    end
+
+    private
+
+    # Returns a list of AttributeValues from the file itself,
+    # including all defaults set by SEM. AttributeValues are defined
+    # in comments in the file.
+    def parse_attribute_values
+      values = []
+      each_property do |name, value|
+        values << AttributeValue.new(name, value)
+      end
+
+      DEFAULTS.each do |default|
+        if values.find { |v| v.attribute.name == default.attribute.name }.nil?
+          values << default
+        end
+      end
+
+      values
+    end
+
+    # Parse properties from the comments. Looks for this pattern:
+    #
+    # -- sem.attribute.name = value
+    #
+    # and yields each matching row with |name, value|
+    def each_property
+      IO.readlines(path).each do |l|
+        stripped = l.strip
+        if stripped.match(/^\-\-\s+sem\.attribute\./)
+          stripped.sub!(/^\-\-\s+sem\.attribute\./, '')
+          name, value = stripped.split(/\=/, 2).map(&:strip)
+          yield name, value
+        end
+      end
+    end
+
+  end
+
+end

data/lib/schema-evolution-manager/preconditions.rb

@@ -0,0 +1,61 @@
+module SchemaEvolutionManager
+  # Modeled after http://docs.guava-libraries.googlecode.com/git/javadoc/com/google/common/base/Preconditions.html
+  class Preconditions
+
+    def Preconditions.check_argument(expression, error_message=nil)
+      if !expression
+        raise error_message || "check_argument failed"
+      end
+      nil
+    end
+
+    def Preconditions.check_state(expression, error_message=nil)
+      if !expression
+        raise error_message || "check_state failed"
+      end
+      nil
+    end
+
+    def Preconditions.check_not_null(reference, error_message=nil)
+      if reference.nil?
+        raise error_message || "argument cannot be nil"
+      end
+      reference
+    end
+
+    def Preconditions.check_not_blank(reference, error_message=nil)
+      if reference.to_s.strip == ""
+        raise error_message || "argument cannot be blank"
+      end
+      reference
+    end
+
+    # Throws an error if opts is not empty. Useful when parsing
+    # arguments to a function
+    def Preconditions.assert_empty_opts(opts)
+      if !opts.empty?
+        raise "Invalid opts: #{opts.keys.inspect}\n#{opts.inspect}"
+      end
+    end
+
+    # Asserts that value is not nill and is_?(klass). Returns
+    # value. Common use is
+    #
+    # amount = Preconditions.assert_class(amount, BigDecimal)
+    def Preconditions.assert_class(value, klass)
+      Preconditions.check_not_null(value, "Value cannot be nil")
+      Preconditions.check_not_null(klass, "Klass cannot be nil")
+      Preconditions.check_state(value.is_a?(klass),
+                                "Value is of type[#{value.class}] - class[#{klass}] is required. value[#{value.inspect.to_s}]")
+      value
+    end
+
+    def Preconditions.assert_class_or_nil(value, klass)
+      if !value.nil?
+        Preconditions.assert_class(value, klass)
+      end
+    end
+
+  end
+
+end

data/lib/schema-evolution-manager/rdoc_usage.rb

@@ -0,0 +1,37 @@
+module SchemaEvolutionManager
+  # Adapter for what we need to remove dependency on RDoc which was removed in ruby 1.9
+  class RdocUsage
+
+    def RdocUsage.message
+      path = Library.normalize_path(RdocUsage.program_name)
+
+      lines = []
+
+      IO.readlines(path).each do |line|
+        if !line.match(/^\#/)
+          break
+        end
+        if line.match(/^\#\!/)
+          next
+        end
+        lines << line.sub(/^\#\s?/, '').sub(/\n$/, '')
+      end
+      lines << ""
+
+      lines.join("\n")
+    end
+
+    def RdocUsage.printAndExit(exit_code=0)
+      puts RdocUsage.message
+      exit(exit_code)
+    end
+
+    private
+    def RdocUsage.program_name
+      $0
+    end
+
+
+  end
+
+end

data/lib/schema-evolution-manager/script_error.rb

@@ -0,0 +1,19 @@
+module SchemaEvolutionManager
+
+  class ScriptError < Exception
+
+    attr_reader :filename
+
+    def initialize(db, filename)
+      @db = Preconditions.assert_class(db, Db)
+      @filename = Preconditions.assert_class(filename, String)
+    end
+
+    def dml
+      sql_command = "insert into %s.%s (filename) values ('%s')" % [Db.schema_name, Scripts::SCRIPTS, filename]
+      "psql --command \"%s\" %s" % [sql_command, @db.url]
+    end
+
+  end
+
+end

data/lib/schema-evolution-manager/scripts.rb

@@ -0,0 +1,95 @@
+module SchemaEvolutionManager
+
+  class Scripts
+
+    if !defined?(SCRIPTS)
+      SCRIPTS = "scripts"
+      BOOTSTRAP_SCRIPTS = "bootstrap_scripts"
+      VALID_TABLE_NAMES = [BOOTSTRAP_SCRIPTS, SCRIPTS]
+    end
+
+    # @param db Instance of Db class
+    # @param table_name Name of the table used to record which scripts
+    # we have processed. Will be one of 'scripts' or 'bootstrap_scripts'
+    def initialize(db, table_name)
+      @db = Preconditions.assert_class(db, Db)
+      @table_name = Preconditions.assert_class(table_name, String)
+      Preconditions.check_state(VALID_TABLE_NAMES.include?(@table_name),
+                                "Invalid table name[%s]. Must be one of: %s" % [@table_name, VALID_TABLE_NAMES.join(", ")])
+    end
+
+    # Returns a sorted list of the full file paths to any sql scripts in
+    # the specified directory
+    def Scripts.all(dir)
+      Preconditions.assert_class(dir, String)
+
+      if File.directory?(dir)
+        Dir.glob("#{dir}/*.sql").sort
+      else
+        []
+      end
+    end
+
+    # For each sql script that needs to be applied to this database,
+    # yields a pair of |filename, fullpath| in proper order
+    #
+    # db = Db.new(host, user, name)
+    # scripts = Scripts.new(db)
+    # scripts.each_pending do |filename, path|
+    #    puts filename
+    # end
+    def each_pending(dir)
+      files = {}
+      Scripts.all(dir).each do |path|
+        name = File.basename(path)
+        files[name] = path
+      end
+
+      scripts_previously_run(files.keys).each do |filename|
+        files.delete(filename)
+      end
+
+      files.keys.sort.each do |filename|
+        ## We have to recheck if this script is still pending. Some
+        ## upgrade scripts may modify the scripts table themselves. This
+        ## is actually useful in cases like when we migrated gilt from
+        ## util_schema => schema_evolution_manager schema
+        if !has_run?(filename)
+          yield filename, files[filename]
+        end
+      end
+    end
+
+    # True if this script has already been applied to the db. False
+    # otherwise.
+    def has_run?(filename)
+      if @db.schema_schema_evolution_manager_exists?
+        query = "select count(*) from %s.%s where filename = '%s'" % [Db.schema_name, @table_name, filename]
+        @db.psql_command(query).to_i > 0
+      else
+        false
+      end
+    end
+
+    # Inserts a record to indiciate that we have loaded the specified file.
+    def record_as_run!(filename)
+      Preconditions.check_state(filename.match(/^\d\d\d\d\d\d+\-\d\d\d\d\d\d\.sql$/),
+                                "Invalid filename[#{filename}]. Must be like: 20120503-173242.sql")
+      command = "insert into %s.%s (filename) select '%s' where not exists (select 1 from %s.%s where filename = '%s')" % [Db.schema_name, @table_name, filename, Db.schema_name, @table_name, filename]
+      @db.psql_command(command)
+    end
+
+    private
+    # Fetch the list of scripts that have already been applied to this
+    # database.
+    def scripts_previously_run(scripts)
+      if scripts.empty? || !@db.schema_schema_evolution_manager_exists?
+        []
+      else
+        sql = "select filename from %s.%s where filename in (%s)" % [Db.schema_name, @table_name, "'" + scripts.join("', '") + "'"]
+        @db.psql_command(sql).strip.split
+      end
+    end
+  end
+
+end

data/lib/schema-evolution-manager/sem_info.rb

@@ -0,0 +1,72 @@
+module SchemaEvolutionManager
+
+  module SemInfo
+
+    def SemInfo.version(args=nil)
+      SchemaEvolutionManager::SemVersion::VERSION.dup
+    end
+
+    def SemInfo.tag(args)
+      valid = ['exists', 'latest', 'next']
+
+      subcommand = args.shift.to_s.strip
+
+      if subcommand == "exists"
+        tag = args.shift.to_s.strip
+        if tag.empty?
+          puts "ERROR: Missing tag."
+          exit(3)
+        elsif ::SchemaEvolutionManager::Library.tag_exists?(tag)
+          puts "true"
+        else
+          puts "false"
+        end
+
+      elsif subcommand == "latest"
+        if latest = ::SchemaEvolutionManager::SemInfo::Tag.latest
+          latest.to_version_string
+        else
+          nil
+        end
+
+      elsif subcommand == "next"
+        ::SchemaEvolutionManager::SemInfo::Tag.next(args).to_version_string
+
+      elsif subcommand.empty?
+        puts "ERROR: Missing tag subcommand. Must be one of: %s" % valid.join(", ")
+        exit(3)
+
+      else
+        puts "ERROR: Invalid tag subcommand[%s]. Must be one of: %s" % [subcommand, valid.join(", ")]
+        exit(4)
+      end
+    end
+
+    module Tag
+
+      def Tag.latest
+        Library.latest_tag || Version.new("0.0.0")
+      end
+
+      # @param component: One of major|minor|micro. Defaults to micro. Currently passed in as an array
+      def Tag.next(args=nil)
+        component = (args || []).first
+        valid = ['micro', 'minor', 'major']
+
+        if component.to_s.empty?
+          component = "micro"
+        end
+
+        if valid.include?(component)
+          latest.send("next_%s" % component)
+        else
+          puts "ERROR: Invalid component[%s]. Must be one of: %s" % [component, valid.join(", ")]
+          exit(4)
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/schema-evolution-manager/sem_version.rb

@@ -0,0 +1,9 @@
+module SchemaEvolutionManager
+
+  module SemVersion
+
+    VERSION = '0.9.24' # Automatically updated by util/create-release.rb
+
+  end
+
+end

data/lib/schema-evolution-manager/template.rb

@@ -0,0 +1,39 @@
+module SchemaEvolutionManager
+
+  # Simple template parsing using regular expressions to substitute values.
+  # See unit test for example usage at test/specs/lib/template_spec.rb
+  class Template
+
+    class Substitution
+
+      attr_reader :pattern, :value
+
+      def initialize(pattern, value)
+        @pattern = Preconditions.check_not_blank(pattern)
+        @value = Preconditions.check_not_blank(value)
+      end
+
+    end
+
+    def initialize
+      @subs = []
+    end
+
+    # add('first', 'Mike')
+    # Will replace all instances of '%%first%%' with value when you call parse
+    def add(pattern, value)
+      @subs << Substitution.new(pattern, value)
+    end
+
+    def parse(contents)
+      Preconditions.check_not_blank(contents)
+      string = contents.dup
+      @subs.each do |sub|
+        string = string.gsub(/%%#{sub.pattern}%%/, sub.value)
+      end
+      string
+    end
+
+  end
+
+end

data/lib/schema-evolution-manager/version.rb

@@ -0,0 +1,71 @@
+module SchemaEvolutionManager
+
+  class Version
+
+    VERSION_FILE = File.join(Library.base_dir, "VERSION") unless defined?(VERSION_FILE)
+
+    attr_reader :major, :minor, :micro
+
+    def initialize(version_string)
+      Preconditions.check_not_blank(version_string, "version_string cannot be blank")
+      Library.assert_valid_tag(version_string)
+      pieces = version_string.split(".", 3)
+      @major = pieces[0].to_i
+      @minor = pieces[1].to_i
+      @micro = pieces[2].to_i
+    end
+
+    def to_version_string
+      "%s.%s.%s" % [major, minor, micro]
+    end
+
+    # Returns the next major version
+    def next_major
+      Version.new("%s.%s.%s" % [major+1, 0, 0])
+    end
+
+    # Returns the next minor version
+    def next_minor
+      Version.new("%s.%s.%s" % [major, minor+1, 0])
+    end
+
+    # Returns the next micro version
+    def next_micro
+      Version.new("%s.%s.%s" % [major, minor, micro+1])
+    end
+
+    def <=>(other)
+      Preconditions.assert_class(other, Version)
+      value = major <=> other.major
+      if value == 0
+        value = minor <=> other.minor
+        if value == 0
+          value = micro <=> other.micro
+        end
+      end
+      value
+    end
+
+    # Reads the current version (from the VERSION FILE), returning an
+    # instance of the Version class
+    def Version.read
+      Preconditions.check_state(File.exists?(VERSION_FILE), "Version file at path[%s] not found" % VERSION_FILE)
+      version = IO.read(VERSION_FILE).strip
+      Version.new(version)
+    end
+
+    def Version.write(version)
+      Preconditions.assert_class(version, Version)
+      File.open(VERSION_FILE, "w") do |out|
+        out << "%s\n" % version.to_version_string
+      end
+    end
+
+    def Version.is_valid?(version_string)
+      Preconditions.check_not_blank(version_string, "version_string cannot be blank")
+      version_string.match(/^\d+\.\d+\.\d+$/)
+    end
+
+  end
+
+end