xmigra 1.0.1 → 1.1.0

data/lib/xmigra/function.rb

@@ -0,0 +1,17 @@
+
+require 'xmigra/access_artifact'
+
+module XMigra
+  class Function < AccessArtifact
+    OBJECT_TYPE = "FUNCTION"
+    
+    # Construct with a hash (as if loaded from a function YAML file)
+    def initialize(func_info)
+      @name = func_info["name"].dup.freeze
+      @depends_on = func_info.fetch("referencing", []).dup.freeze
+      @definition = func_info["sql"].dup.freeze
+    end
+    
+    attr_reader :name, :depends_on
+  end
+end

data/lib/xmigra/index.rb

@@ -0,0 +1,21 @@
+
+module XMigra
+  class Index
+    def initialize(index_info)
+      @name = index_info['name'].dup.freeze
+      @definition = index_info['sql'].dup.freeze
+    end
+    
+    attr_reader :name
+    
+    attr_accessor :file_path
+    
+    def id
+      XMigra.secure_digest(@definition)
+    end
+    
+    def definition_sql
+      @definition
+    end
+  end
+end

data/lib/xmigra/index_collection.rb

@@ -0,0 +1,38 @@
+
+require 'xmigra/index'
+
+module XMigra
+  class IndexCollection
+    def initialize(path, options={})
+      @items = Hash.new
+      db_specifics = options[:db_specifics]
+      Dir.glob(File.join(path, '*.yaml')).each do |fpath|
+        info = YAML.load_file(fpath)
+        info['name'] = File.basename(fpath, '.yaml')
+        index = Index.new(info)
+        index.extend(db_specifics) if db_specifics
+        index.file_path = File.expand_path(fpath)
+        @items[index.name] = index
+      end
+    end
+    
+    def [](name)
+      @items[name]
+    end
+    
+    def names
+      @items.keys
+    end
+    
+    def each(&block); @items.each_value(&block); end
+    include Enumerable
+    
+    def each_definition_sql
+      each {|i| yield i.definition_sql}
+    end
+    
+    def empty?
+      @items.empty?
+    end
+  end
+end

data/lib/xmigra/migration.rb

@@ -0,0 +1,27 @@
+
+module XMigra
+  class Migration
+    EMPTY_DB = 'empty database'
+    FOLLOWS = 'starting from'
+    CHANGES = 'changes'
+    
+    def initialize(info)
+      @id = info['id'].dup.freeze
+      _follows = info[FOLLOWS]
+      @follows = (_follows.dup.freeze unless _follows == EMPTY_DB)
+      @sql = info["sql"].dup.freeze
+      @description = info["description"].dup.freeze
+      @changes = (info[CHANGES] || []).dup.freeze
+      @changes.each {|c| c.freeze}
+    end
+    
+    attr_reader :id, :follows, :sql, :description, :changes
+    attr_accessor :file_path
+    
+    class << self
+      def id_from_filename(fname)
+        XMigra.secure_digest(fname.upcase) # Base64 encoded digest
+      end
+    end
+  end
+end

data/lib/xmigra/migration_chain.rb

@@ -0,0 +1,63 @@
+
+require 'xmigra/migration'
+
+module XMigra
+  class MigrationChain < Array
+    HEAD_FILE = 'head.yaml'
+    LATEST_CHANGE = 'latest change'
+    MIGRATION_FILE_PATTERN = /^\d{4}-\d\d-\d\d.*\.yaml$/i
+    
+    def initialize(path, options={})
+      super()
+      
+      db_specifics = options[:db_specifics]
+      vcs_specifics = options[:vcs_specifics]
+      
+      head_info = YAML.load_file(File.join(path, HEAD_FILE))
+      file = head_info[LATEST_CHANGE]
+      prev_file = HEAD_FILE
+      files_loaded = []
+      
+      until file.nil?
+        file = XMigra.yaml_path(file)
+        fpath = File.join(path, file)
+        break unless File.file?(fpath)
+        begin
+          mig_info = YAML.load_file(fpath)
+        rescue
+          raise XMigra::Error, "Error loading/parsing #{fpath}"
+        end
+        files_loaded << file
+        mig_info["id"] = Migration::id_from_filename(file)
+        migration = Migration.new(mig_info)
+        migration.file_path = File.expand_path(fpath)
+        migration.extend(db_specifics) if db_specifics
+        migration.extend(vcs_specifics) if vcs_specifics
+        unshift(migration)
+        prev_file = file
+        file = migration.follows
+        unless file.nil? || MIGRATION_FILE_PATTERN.match(XMigra.yaml_path(file))
+          raise XMigra::Error, "Invalid migration file \"#{file}\" referenced from \"#{prev_file}\""
+        end
+      end
+      
+      @other_migrations = []
+      Dir.foreach(path) do |fname|
+        if MIGRATION_FILE_PATTERN.match(fname) && !files_loaded.include?(fname)
+          @other_migrations << fname.freeze
+        end
+      end
+      @other_migrations.freeze
+    end
+    
+    # Test if the chain reaches back to the empty database
+    def complete?
+      length > 0 && self[0].follows.nil?
+    end
+    
+    # Test if the chain encompasses all migration-like filenames in the path
+    def includes_all?
+      @other_migrations.empty?
+    end
+  end
+end

data/lib/xmigra/migration_conflict.rb

@@ -0,0 +1,68 @@
+
+module XMigra
+  class MigrationConflict
+    def initialize(path, branch_point, heads)
+      @path = Pathname.new(path)
+      @branch_point = branch_point
+      @heads = heads
+      @branch_use = :undefined
+      @scope = :repository
+      @after_fix = nil
+    end
+    
+    attr_accessor :branch_use, :scope, :after_fix
+    
+    def resolvable?
+      head_0 = @heads[0]
+      @heads[1].each_pair do |k, v|
+        next unless head_0.has_key?(k)
+        next if k == MigrationChain::LATEST_CHANGE
+        return false unless head_0[k] == v
+      end
+      
+      return true
+    end
+    
+    def migration_tweak
+      unless defined? @migration_to_fix and defined? @fixed_migration_contents
+        # Walk the chain from @head[1][MigrationChain::LATEST_CHANGE] and find
+        # the first migration after @branch_point
+        branch_file = XMigra.yaml_path(@branch_point)
+        cur_mig = XMigra.yaml_path(@heads[1][MigrationChain::LATEST_CHANGE])
+        until cur_mig.nil?
+          mig_info = YAML.load_file(@path.join(cur_mig))
+          prev_mig = XMigra.yaml_path(mig_info[Migration::FOLLOWS])
+          break if prev_mig == branch_file
+          cur_mig = prev_mig
+        end
+        
+        mig_info[Migration::FOLLOWS] = @heads[0][MigrationChain::LATEST_CHANGE]
+        @migration_to_fix = cur_mig
+        @fixed_migration_contents = mig_info
+      end
+      
+      return @migration_to_fix, @fixed_migration_contents
+    end
+    
+    def fix_conflict!
+      raise(VersionControlError, "Unresolvable conflict") unless resolvable?
+      
+      file_to_fix, fixed_contents = migration_tweak
+      
+      # Rewrite the head file
+      head_info = @heads[0].merge(@heads[1]) # This means @heads[1]'s LATEST_CHANGE wins
+      File.open(@path.join(MigrationChain::HEAD_FILE), 'w') do |f|
+        $xmigra_yamler.dump(head_info, f)
+      end
+      
+      # Rewrite the first migration (on the current branch) after @branch_point
+      File.open(@path.join(file_to_fix), 'w') do |f|
+        $xmigra_yamler.dump(fixed_contents, f)
+      end
+      
+      if @after_fix
+        @after_fix.call
+      end
+    end
+  end
+end

data/lib/xmigra/new_file.rb

@@ -0,0 +1,4 @@
+
+module XMigra
+  
+end

data/lib/xmigra/new_migration_adder.rb

@@ -0,0 +1,74 @@
+
+require 'xmigra/schema_manipulator'
+
+module XMigra
+  class NewMigrationAdder < SchemaManipulator
+    OBSOLETE_VERINC_FILE = 'version-upgrade-obsolete.yaml'
+    
+    def initialize(path)
+      super(path)
+    end
+    
+    def add_migration(summary, options={})
+      struct_dir = @path.join(STRUCTURE_SUBDIR)
+      FileUtils.mkdir_p(struct_dir) unless struct_dir.exist?
+      
+      # Load the head YAML from the structure subdir if it exists or create
+      # default empty migration chain
+      head_file = struct_dir.join(MigrationChain::HEAD_FILE)
+      head_info = if head_file.exist?
+        YAML.parse_file(head_file).transform
+      else
+        {}
+      end
+      Hash === head_info or raise XMigra::Error, "Invalid #{MigrationChain::HEAD_FILE} format"
+      
+      new_fpath = struct_dir.join(
+        [Date.today.strftime("%Y-%m-%d"), summary].join(' ') + '.yaml'
+      )
+      raise(XMigra::Error, "Migration file\"#{new_fpath.basename}\" already exists") if new_fpath.exist?
+      
+      new_data = {
+        Migration::FOLLOWS=>head_info.fetch(MigrationChain::LATEST_CHANGE, Migration::EMPTY_DB),
+        'sql'=>options.fetch(:sql, "<<<<< INSERT SQL HERE >>>>>\n"),
+        'description'=>options.fetch(:description, "<<<<< DESCRIPTION OF MIGRATION >>>>>").dup.extend(FoldedYamlStyle),
+        Migration::CHANGES=>options.fetch(:changes, ["<<<<< WHAT THIS MIGRATION CHANGES >>>>>"]),
+      }
+      
+      # Write the head file first, in case a lock is required
+      old_head_info = head_info.dup
+      head_info[MigrationChain::LATEST_CHANGE] = new_fpath.basename('.yaml').to_s
+      File.open(head_file, "w") do |f|
+        $xmigra_yamler.dump(head_info, f)
+      end
+      
+      begin
+        File.open(new_fpath, "w") do |f|
+          $xmigra_yamler.dump(new_data, f)
+        end
+      rescue
+        # Revert the head file to it's previous state
+        File.open(head_file, "w") do |f|
+          $xmigra_yamler.dump(old_head_info, f)
+        end
+        
+        raise
+      end
+      
+      # Obsolete any existing branch upgrade file
+      bufp = branch_upgrade_file
+      if bufp.exist?
+        warning("#{bufp.relative_path_from(@path)} is obsolete and will be renamed.") if respond_to? :warning
+        
+        obufp = bufp.dirname.join(OBSOLETE_VERINC_FILE)
+        rm_method = respond_to?(:vcs_remove) ? method(:vcs_remove) : FileUtils.method(:rm)
+        mv_method = respond_to?(:vcs_move) ? method(:vcs_move) : FileUtils.method(:mv)
+        
+        rm_method.call(obufp) if obufp.exist?
+        mv_method.call(bufp, obufp)
+      end
+      
+      return new_fpath
+    end
+  end
+end

data/lib/xmigra/permission_script_writer.rb

@@ -0,0 +1,67 @@
+
+require 'xmigra/schema_manipulator'
+
+module XMigra
+  class PermissionScriptWriter < SchemaManipulator
+    def initialize(path)
+      super(path)
+      
+      @permissions = YAML.load_file(self.path + PERMISSIONS_FILE)
+      raise TypeError, "Expected Hash in #{PERMISSIONS_FILE}" unless Hash === @permissions
+    end
+    
+    def in_ddl_transaction
+      yield
+    end
+    
+    def ddl_block_separator; "\n"; end
+    
+    def permissions_sql
+      intro_comment = @db_info.fetch('script comment', '') + "\n\n"
+      
+      intro_comment + in_ddl_transaction do
+        [
+          # Check for blatantly incorrect application of script, e.g. running
+          # on master or template database.
+          check_execution_environment_sql,
+          
+          # Create table for recording granted permissions if it doesn't exist
+          ensure_permissions_table_sql,
+          
+          # Revoke permissions previously granted through an XMigra permissions
+          # script
+          revoke_previous_permissions_sql,
+          
+          # Grant the permissions indicated in the source file
+          grant_specified_permissions_sql,
+          
+        ].flatten.compact.join(ddl_block_separator)
+      end
+    end
+    
+    def grant_specified_permissions_sql
+      granting_permissions_comment_sql +
+        enum_for(:each_specified_grant).map(&method(:grant_permissions_sql)).join("\n")
+    end
+    
+    def each_specified_grant
+      @permissions.each_pair do |object, grants|
+        grants.each_pair do |principal, permissions|
+          permissions = [permissions] unless permissions.is_a? Enumerable
+          yield permissions, object, principal
+        end
+      end
+    end
+    
+    def line_comment(contents)
+      "-- " + contents + " --\n"
+    end
+    
+    def header(content, size)
+      dashes = size - content.length - 2
+      l_dashes = dashes / 2
+      r_dashes = dashes - l_dashes
+      ('-' * l_dashes) + ' ' + content + ' ' + ('-' * r_dashes)
+    end
+  end
+end