dbagile 0.0.1

data/lib/dbagile/core/schema/composite.rb

@@ -0,0 +1,239 @@
+module DbAgile
+  module Core
+    module Schema
+      class Composite < SchemaObject
+      
+        # Creates a composite instance with parts
+        def initialize(composite_parts = _default_parts)
+          unless composite_parts.kind_of?(Hash)
+            raise ArgumentError, "Composite parts must be a hash, got #{composite_parts.inspect}" 
+          end
+          _install_parts(composite_parts)
+          @insert_order = nil
+        end
+      
+        ############################################################################
+        ### Private interface
+        ############################################################################
+        attr_reader :composite_parts
+        protected   :composite_parts
+        private
+      
+        # Creates defaut parts hash
+        def _default_parts
+          {}
+        end
+      
+        # Returns prefered keys order
+        def _prefered_order
+          @insert_order || []
+        end
+        
+        def _prefered_order=(order)
+          @insert_order = order
+        end
+        
+        # Make installation of parts
+        def _install_parts(parts)
+          meth = _install_eigenclass_methods?
+          parts.each_pair{|k, v|
+            v.send(:parent=, self)
+            if meth
+              eigenclazz = (class << self; self; end)
+              eigenclazz.send(:define_method, k){ @composite_parts[k] }
+            end
+          }
+          @composite_parts = parts
+        end
+      
+        # Installs eigenclass methods on parts provided at construction
+        def _install_eigenclass_methods?
+          false
+        end
+        
+        # Duplicates parts
+        def _dup_parts
+          dup_parts = {}
+          @composite_parts.each_pair{|name, part| dup_parts[name] = part.dup}
+          dup_parts
+        end
+        
+        protected
+        
+        # Removes empty objects from parts
+        def _strip!
+          to_remove = part_keys.select{|k| 
+            self[k].composite? and self[k].empty?
+          }
+          @composite_parts.delete_if{|k, v| 
+            to_remove.include?(k)
+          }
+          if @insert_order
+            @insert_order -= to_remove 
+          end
+          _sanity_check(schema)
+          self
+        end
+        
+        # Makes a sanity check on the composite
+        def _sanity_check(schema)
+          if @insert_order
+            too_much = @insert_order - @composite_parts.keys
+            missing = @composite_parts.keys - @insert_order
+            unless too_much.empty? and missing.empty?
+              raise SchemaInternalError, "Key divergence" 
+            end
+          end
+          parts.each{|p| 
+            raise SchemaInternalError, "Invalid parent on #{self}" unless p.parent == self
+            raise SchemaInternalError, "Invalid schema on on #{self}" unless p.schema == schema
+            p._sanity_check(schema) 
+          }
+        rescue StandardError => ex
+          raise SchemaInternalError, "Something goes wrong on #{self}: #{ex.message}", ex.backtrace
+        end
+      
+        # Checks this composite's semantics and collect errors
+        def _semantics_check(clazz, buffer)
+          parts.collect{|p| p._semantics_check(clazz, buffer)}
+        end
+        
+        ############################################################################
+        ### Public interface
+        ############################################################################
+        public
+      
+        # Returns an array with part dependencies
+        def dependencies(include_parent = false)
+          deps = parts.collect{|p| p.dependencies(include_parent)}.flatten.uniq
+          deps += [ parent ] if include_parent and not(parent.nil?)
+          deps
+        end
+        
+        # Yields the block with each part in turn
+        def each_part(&block)
+          parts.each(&block)
+        end
+        
+        # @see DbAgile::Core::Schema
+        def visit(&block)
+          block.call(self, parent)
+          parts.each{|p| p.visit(&block)}
+        end
+        
+        ############################################################################
+        ### SchemaObject
+        ############################################################################
+      
+        # @see DbAgile::Core::SchemaObject
+        def empty?(recurse = true)
+          if recurse
+            parts.all?{|p| p.composite? && p.empty?(recurse)}
+          else
+            @composite_parts.empty?
+          end
+        end
+        
+        # Returns number of parts
+        def size
+          @composite_parts.size
+        end
+      
+        # @see DbAgile::Core::SchemaObject
+        def part_keys(sort = false)
+          if sort
+            @composite_parts.keys.sort{|k1,k2| k1.to_s <=> k2.to_s}
+          else
+            (_prefered_order + @composite_parts.keys).uniq
+          end
+        end
+      
+        # @see DbAgile::Core::SchemaObject
+        def parts
+          part_keys(false).collect{|k| self[k]}
+        end
+      
+        # @see DbAgile::Core::SchemaObject
+        def [](name)
+          @composite_parts[name]
+        end
+      
+        # @see DbAgile::Core::SchemaObject
+        def []=(name, part, status = nil)
+          if @composite_parts.key?(name)
+            raise SchemaConflictError.new(self[name], part, name)
+          end
+          @composite_parts[name] = part
+          (@insert_order ||= []) << name
+          part.send(:parent=, self)
+          unless status.nil?
+            part.visit{|p, parent| p.status = status}
+          end
+          part
+        end
+      
+        ############################################################################
+        ### About IO
+        ############################################################################
+      
+        # @see DbAgile::Core::SchemaObject
+        def to_yaml(opts = {})
+          YAML::quick_emit(self, opts){|out|
+            out.map("tag:yaml.org,2002:map") do |map|
+              part_keys.each{|k|
+                map.add(k.to_s, self[k])
+              }
+            end
+          }
+        end
+        
+        # Returns a yaml string
+        def yaml_display(env, 
+                         options = {}, 
+                         colors = DbAgile::Core::Schema::STATUS_TO_COLOR, 
+                         indent = 0)
+          part_keys.each{|k|
+            part = self[k]
+            status = part.status.to_s.ljust(25)
+            show_it = !(part.status == Schema::NO_CHANGE and options[:skip_unchanged])
+            if show_it
+              mine = "  "*indent + k.to_s + ":"
+              if part.composite?
+                env.display(mine, colors[part.status])
+                part.yaml_display(env, options, colors, indent+1)
+              else
+                part_str = part.to_yaml
+                part_str =~ /---\s*(.*)$/
+                part_str = $1
+                env.display(mine + " " + part_str, colors[part.status])
+              end
+            end
+          }
+        end
+      
+        ############################################################################
+        ### Equality and hash code
+        ############################################################################
+      
+        # @see DbAgile::Core::SchemaObject
+        def look_same_as?(other)
+          return nil unless other.kind_of?(self.class)
+          my_parts = part_keys(true)
+          return false unless (my_parts == other.part_keys(true))
+          my_parts.all?{|k| self[k].look_same_as?(other[k])}
+        end
+      
+        # @see DbAgile::Core::SchemaObject
+        def dup
+          self.class.new(_dup_parts)
+        end
+      
+        # Returns a string representation
+        def to_s
+          "#{DbAgile::RubyTools::unqualified_class_name(self.class)}"
+        end
+        
+      end # class Composite
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/computations/filter.rb

@@ -0,0 +1,40 @@
+module DbAgile
+  module Core
+    module Schema
+      module Computations
+        module Filter
+          
+          # Default filtering options
+          DEFAULT_OPTIONS = {}
+          
+          # Computes set difference between schemas.
+          def filter(object, options, builder, &block)
+            unless object.composite?
+              raise ArgumentError, "Filter called on a part object!"
+            end
+            
+            # Make a deep filtered copy 
+            keys = object.part_keys
+            copied = builder.send(object.builder_handler, *object.builder_args){|builder_object|
+              keys.each{|key|
+                sub_object = object[key]
+                if sub_object.composite?
+                  filter(sub_object, options, builder, &block)
+                else
+                  if block.call(sub_object)
+                    builder_object.[]=(key, sub_object.dup)
+                  end
+                end
+              }
+              builder_object
+            }
+            
+            copied
+          end
+          
+        end # module Filter
+        extend(Filter)
+      end # module Computations
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/computations/merge.rb

@@ -0,0 +1,55 @@
+module DbAgile
+  module Core
+    module Schema
+      module Computations
+        module Merge
+          
+          # Computes set difference between schemas.
+          def merge(left, right, builder, &block)
+            unless left.class == right.class
+              raise ArgumentError, "#{left.class} != #{right.class}"
+            end
+            unless left.composite?
+              raise ArgumentError, "Diff called on a part object!"
+            end
+            
+            # Computes key differences
+            left_keys, right_keys = left.part_keys(true), right.part_keys(true)
+            left_only  = left_keys - right_keys
+            right_only = right_keys - left_keys
+            commons    = left_keys & right_keys 
+            
+            mine = Schema::NO_CHANGE
+            builder.send(left.builder_handler, *left.builder_args){|builder_object|
+              left_only.each {|key| 
+                mine = Schema::TO_ALTER
+                builder_object.[]=(key, left[key].dup, Schema::TO_DROP)
+              }
+              right_only.each{|key| 
+                mine = Schema::TO_ALTER
+                builder_object.[]=(key, right[key].dup, Schema::TO_CREATE)
+              }
+              commons.each{|key|
+                on_left, on_right = left[key], right[key]
+                if on_left.composite?
+                  recursed = merge(on_left, on_right, builder, &block).status
+                  mine = Schema::TO_ALTER if recursed != Schema::NO_CHANGE
+                elsif on_left.look_same_as?(on_right)
+                  builder_object.[]=(key, left[key].dup, Schema::NO_CHANGE)
+                elsif block
+                  resolved = block.call(on_left, on_right)
+                  if resolved
+                    builder_object.[]=(key, resolved, Schema::TO_ALTER)
+                  end
+                end
+              }
+              builder_object.status = mine
+            }
+          end
+          
+        end # module Merge
+        extend(Merge)
+      end # module Computations
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/computations/minus.rb

@@ -0,0 +1,44 @@
+module DbAgile
+  module Core
+    module Schema
+      module Computations
+        module Minus
+          
+          # Computes set difference between schemas.
+          def minus(left, right, builder)
+            unless left.class == right.class
+              raise ArgumentError, "#{left.class} != #{right.class}"
+            end
+            unless left.composite?
+              raise ArgumentError, "Minus called on a part object!"
+            end
+            
+            result = builder.send(left.builder_handler, *left.builder_args){|builder_object|
+              left.part_keys.each{|name|
+                left_sub, right_sub = left[name], right[name]
+                if right_sub.nil?
+                  # missing in right
+                  builder_object[name] = left_sub.dup
+                elsif left_sub.composite?
+                  # present in right, possibly the same
+                  minus(left_sub, right_sub, builder)
+                elsif not(left_sub.look_same_as?(right_sub))
+                  # present in right, conflicting
+                  builder_object[name] = left_sub.dup
+                else
+                  # present in right, same 
+                  # (following line otherwise, not counted by rcov)
+                  1
+                end
+              }
+            }
+            
+            result
+          end
+          
+        end # module Minus
+        extend(Minus)
+      end # module Computations
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/computations/split.rb

@@ -0,0 +1,37 @@
+module DbAgile
+  module Core
+    module Schema
+      module Computations
+        module Split
+          
+          # Default split options
+          DEFAULT_OPTIONS = {}
+          
+          # Computes set difference between schemas.
+          def split(schema, options, &block)
+
+            # Build the split hash
+            split_hash = Hash.new{|h,k| h[k] = []}
+            schema.visit{|object, parent|
+              if object.part?
+                kind = block.call(object)
+                split_hash[kind] << object
+              end
+            }
+            
+            # Rebuild schemas now
+            schemas = {}
+            split_hash.keys.each{|kind|
+              split_proc    = lambda{|obj| split_hash[kind].include?(obj)}
+              split_options = {:identifier => kind}
+              schemas[kind] = Schema::filter(schema, split_options, &split_proc)
+            }
+            schemas
+          end
+          
+        end # module Split
+        extend(Split)
+      end # module Computations
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/computations.rb

@@ -0,0 +1,4 @@
+require 'dbagile/core/schema/computations/minus'
+require 'dbagile/core/schema/computations/merge'
+require 'dbagile/core/schema/computations/filter'
+require 'dbagile/core/schema/computations/split'

data/lib/dbagile/core/schema/database_schema.rb

@@ -0,0 +1,129 @@
+module DbAgile
+  module Core
+    module Schema
+      class DatabaseSchema < Schema::Composite
+        include Enumerable
+        alias :each :visit
+      
+        # Identifier of this schema
+        attr_accessor :schema_identifier
+      
+        # Creates a schema instance
+        def initialize(schema_identifier = nil, parts = _default_parts)
+          @schema_identifier = schema_identifier
+          super(parts)
+          @insert_order = [:logical, :physical]
+        end
+
+        
+        ############################################################################
+        ### Private interface
+        ############################################################################
+          
+        # @see DbAgile::Core::Schema::Composite#_install_eigenclass_methods?
+        def _install_eigenclass_methods?
+          true
+        end
+      
+        # @see DbAgile::Core::Schema::Composite#_default_parts
+        def _default_parts
+          {:logical  => Schema::Logical.new,
+           :physical => Schema::Physical.new}
+        end
+        
+        # Strips this schema
+        def _strip!
+          logical._strip!
+          self
+        end
+        
+        ############################################################################
+        ### SchemaObject
+        ############################################################################
+        
+        # Returns an array with part dependencies
+        def dependencies(include_parent = false)
+          []
+        end
+          
+        # Overrided to return self.
+        def schema
+          self
+        end
+      
+        # @see DbAgile::Core::Schema::SchemaObject
+        def dup
+          DatabaseSchema.new(schema_identifier, _dup_parts)
+        end
+
+        
+        ############################################################################
+        ### IO
+        ############################################################################
+          
+        # Dumps the schema to YAML
+        def to_yaml(opts = {})
+          YAML::dump_stream({'logical' => logical}, {'physical' => physical})
+        end
+        alias :inspect :to_yaml
+      
+
+        # Returns a yaml string
+        def yaml_display(env, 
+                         options = {}, 
+                         colors = DbAgile::Core::Schema::STATUS_TO_COLOR, 
+                         indent = 0)
+          env.display("---\nlogical:")
+          logical.yaml_display(env, options, colors, indent + 1)
+          env.display("\n---\nphysical:")
+          physical.yaml_display(env, options, colors, indent + 1)
+        end
+        
+        ############################################################################
+        ### Computations
+        ############################################################################
+          
+        # Applies schema checking and raises a SchemaSemanticsError if something is wrong.
+        def check!(raise_on_error = true)
+          errors = SchemaSemanticsError.new(self)
+          _semantics_check(SchemaSemanticsError, errors)
+          if raise_on_error and not(errors.empty?)
+            raise errors
+          else
+            errors
+          end
+        end
+        
+        # Convenient method for <code>schema.check!(false).empty?</code>
+        def looks_valid?
+          check!(false).empty?
+        end
+      
+        # Applies schema minus
+        def minus(other)
+          Schema::minus(self, other)
+        end
+        alias :- :minus
+      
+        # Applies schema merging
+        def merge(other)
+          Schema::merge(self, other)
+        end
+        alias :+ :merge
+        
+        # Applies schema filtering
+        def filter(options = {}, &filter_block)
+          Schema::filter(self, options, &filter_block)
+        end
+        
+        # Applies schema splitting
+        def split(options = {}, &split_block)
+          Schema::split(self, options, &split_block)
+        end
+        
+      end # class DatabaseSchema
+    end # module Schema
+  end # module Core
+end # module DbAgile
+require 'dbagile/core/schema/logical'
+require 'dbagile/core/schema/physical'