dbagile 0.0.1

data/lib/dbagile/core/schema/physical/index.rb

@@ -0,0 +1,64 @@
+module DbAgile
+  module Core
+    module Schema
+      class Physical < Schema::Composite
+        class Index < Schema::Part
+
+          # Relation variable targettet by this index
+          def indexed_relvar
+            schema.logical.relation_variable(definition[:relvar])
+          end
+          
+          # Returns indexed attributes
+          def indexed_attributes
+            definition[:attributes].collect{|k| indexed_relvar.heading[k]}
+          end
+      
+          ############################################################################
+          ### Dependency control
+          ############################################################################
+          
+          # @see DbAgile::Core::Schema::SchemaObject
+          def dependencies(include_parent = false)
+            deps = indexed_attributes
+            deps += [ parent ] if include_parent
+            deps
+          end
+          
+          ############################################################################
+          ### Check interface
+          ############################################################################
+          
+          # @see DbAgile::Core::Schema::SchemaObject
+          def _semantics_check(clazz, errors)
+            if (trv = indexed_relvar).nil?
+              code = clazz::InvalidIndex | clazz::NoSuchRelvar
+              errors.add_error(self, code, :relvar_name => definition[:relvar])
+            elsif !trv.heading.has_attributes?(definition[:attributes])
+              code = clazz::InvalidIndex | clazz::NoSuchRelvarAttributes
+              errors.add_error(self, code, :relvar_name => trv.name,
+                                           :attributes  => definition[:attributes])
+            end
+          end
+      
+          ############################################################################
+          ### About IO
+          ############################################################################
+      
+          # Delegation pattern on YAML flushing
+          def to_yaml(opts = {})
+            YAML::quick_emit(self, opts){|out|
+              defn = definition
+              attrs = Schema::Builder::Coercion::unsymbolize_array(definition[:attributes])
+              out.map("tag:yaml.org,2002:map", :inline ) do |map|
+                map.add('relvar', definition[:relvar].to_s)
+                map.add('attributes', attrs)
+              end
+            }
+          end
+        
+        end # class Index
+      end # module Physical
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/physical/indexes.rb

@@ -0,0 +1,12 @@
+require 'dbagile/core/schema/physical/indexes'
+require 'dbagile/core/schema/physical/index'
+module DbAgile
+  module Core
+    module Schema
+      class Physical 
+        class Indexes < Schema::Composite
+        end # class Indexes
+      end # class Logical
+    end # module Schema
+  end # module Core
+end # module DbAgile

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

@@ -0,0 +1,26 @@
+module DbAgile
+  module Core
+    module Schema
+      class Physical < Schema::Composite
+        
+        # @see DbAgile::Core::Schema::Composite#_default_parts
+        def _default_parts
+          {:indexes => Physical::Indexes.new}
+        end
+                
+        # @see DbAgile::Core::Schema::Composite#_install_eigenclass_methods?
+        def _install_eigenclass_methods?
+          true
+        end
+        
+        # Returns an array with part dependencies
+        def dependencies(include_parent = false)
+          []
+        end
+        
+      end # class Logical
+    end # module Schema
+  end # module Core
+end # module DbAgile
+require 'dbagile/core/schema/physical/indexes'
+require 'dbagile/core/schema/physical/index'

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

@@ -0,0 +1,39 @@
+module DbAgile
+  module Core
+    module Schema
+      module Robustness
+        
+        #
+        # Asserts that _arg_ is a Schema::DatabaseSchema or raises an ArgumentError
+        #
+        def schema!(arg, arg_name = :schema, cal = caller)
+          unless arg.kind_of?(Schema::DatabaseSchema)
+            raise ArgumentError, "Schema expected for #{arg_name}, got #{arg.class}", cal
+          end
+          arg
+        end
+        
+        #
+        # Asserts that _arg_ is a Schema::Builder or raises an ArgumentError
+        #
+        def builder!(arg, arg_name = :builder, cal = caller)
+          unless arg.kind_of?(Schema::Builder)
+            raise ArgumentError, "Builder expected for #{arg_name}, got #{arg.class}", cal
+          end
+          arg
+        end
+        
+        #
+        # Asserts that _arg_ is a Hash or raises an ArgumentError
+        #
+        def hash!(arg, arg_name = :options, cal = caller)
+          unless arg.kind_of?(Hash)
+            raise ArgumentError, "Hash expected for #{arg_name}, got #{arg.class}", cal
+          end
+          arg
+        end
+        
+      end # module Robustness
+    end # module Schema
+  end # module Core
+end # module DbAgile

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

@@ -0,0 +1,94 @@
+module DbAgile
+  module Core
+    module Schema
+      class SchemaObject
+      
+        # Parent object
+        attr_accessor :parent
+        
+        # Object status
+        attr_accessor :status
+        
+        ############################################################################
+        ### Schema typing
+        ############################################################################
+        
+        # Returns true if this schema object is composite, false
+        # otherwise
+        def composite?
+          self.kind_of?(Schema::Composite)
+        end
+      
+        # Convenient method for !composite?
+        def part?
+          !composite?
+        end
+        alias :terminal? :part?
+        
+        ############################################################################
+        ### Schema hierarchy
+        ############################################################################
+        
+        # Returns the main schema instance
+        def schema
+          @schema ||= (parent && parent.schema)
+        end
+        
+        # Returns object's ancestors
+        def ancestors
+          parent.nil? ? [] : [ parent ] + parent.ancestors
+        end
+        
+        # Returns outside dependencies only
+        def outside_dependencies
+          deps = dependencies
+          deps.delete_if{|d| d.ancestors.include?(self)}
+        end
+        
+        # Returns objects depending on this
+        def outside_dependents
+          selected = []
+          schema.visit{|part, parent|
+            if part.part? and not(part.ancestors.include?(self))
+              deps = part.outside_dependencies
+              deps = deps.collect{|d| d.ancestors}.flatten.uniq
+              selected << part if deps.include?(self)
+            end
+          }
+          selected
+        end
+        
+        # Returns relation variable of this object, if any
+        def relation_variable
+          if self.kind_of?(DbAgile::Core::Schema::Logical::Relvar)
+            self
+          elsif parent
+            parent.relation_variable
+          else
+            raise NoMethodError, "undefined method relation_variable for #{self.class}"
+          end
+        end
+        
+        ############################################################################
+        ### Package internal methods
+        ############################################################################
+        
+        # Returns the builder handler for this object
+        def builder_handler
+          unqualified = DbAgile::RubyTools::class_unqualified_name(self.class).to_s
+          unqualified.gsub(/[A-Z]/){|x| "_#{x.downcase}"}[1..-1]
+        end
+        
+        # Returns the arguments to pass to builder handler
+        def builder_args
+          []
+        end
+        
+        private :parent=
+      end # class SchemaObject
+    end # module Schema
+  end # module Core
+end # module DbAgile
+require 'dbagile/core/schema/part'
+require 'dbagile/core/schema/composite'
+require 'dbagile/core/schema/database_schema'

data/lib/dbagile/core/schema.rb

@@ -0,0 +1,254 @@
+require 'dbagile/core/schema/errors'
+require 'dbagile/core/schema/robustness'
+require 'dbagile/core/schema/schema_object'
+require 'dbagile/core/schema/builder'
+require 'dbagile/core/schema/computations'
+require 'dbagile/core/schema/migrate'
+module DbAgile
+  module Core
+    module Schema
+      extend(Schema::Robustness)
+
+      # An empty schema
+      EMPTY_SCHEMA = Schema::DatabaseSchema.new
+
+      # Status of objects that need to be created (on left)
+      TO_CREATE = :to_create
+
+      # Status of objects that need to be dropped (on left)
+      TO_DROP   = :to_drop
+
+      # Status of objects that need to be altered (on left)
+      TO_ALTER  = :to_alter
+
+      # Status of objects that need not being altered in any way
+      NO_CHANGE = :no_change
+      
+      # Status of objects that have been created
+      CREATED   = :created
+
+      # Status of objects that have been dropped
+      DROPPED   = :dropped
+
+      # Status of objects that have been altered
+      ALTERED   = :altered
+
+      # Status of objects whose migrayion is currently pending
+      PENDING   = :pending
+
+      # Status of objects whose migration has been defered
+      DEFERED   = :defered
+      
+      STATUS_TO_COLOR = {
+        TO_CREATE => :green,
+        TO_DROP   => :red,
+        TO_ALTER  => :cyan,
+        NO_CHANGE => :black,
+        #
+        CREATED   => :green,
+        DROPPED   => :green,
+        ALTERED   => :green,
+        PENDING   => :red,
+        DEFERED   => :red
+      }
+
+      #
+      # Creates a DatabaseSchema instance.
+      #
+      # Intent of this method is to hide implementation details of this package.
+      # It should ALWAYS be used for creating schema instances (no direct accesses
+      # to the DatabaseSchema should be made!).
+      #
+      # @param [Object] optional tracability identifier
+      # @return [DatabaseSchema] a database schema
+      #
+      def new(schema_identifier = nil)
+        Schema::DatabaseSchema.new(schema_identifier)
+      end
+      module_function :new
+
+
+      ##############################################################################
+      ### About schema building 
+      ##############################################################################
+      
+      # 
+      # Creates a builder instance
+      #
+      def builder(schema = nil)
+        DbAgile::Core::Schema::Builder.new(schema)
+      end
+      module_function :builder
+
+      #      
+      # Factors a Builder instance ready for loading a yaml schema file
+      #
+      def yaml_builder(schema = Schema.new)
+        DbAgile::Core::Schema::Builder.new(schema)
+      end
+      module_function :yaml_builder
+
+
+      ##############################################################################
+      ### About Schema and YAML 
+      ##############################################################################
+      
+      #
+      # Loads a database schema from a YAML string
+      #
+      # @param [String] str a YAML schema source
+      # @param [DbAgile::Core::Schema::Builder] a builder instance to use to
+      #        populate the schema
+      # @returns [DbAgile::Core:Schema::DatabaseSchema] the loaded database 
+      #          schema
+      #
+      def yaml_load(str, builder = yaml_builder)
+        YAML::each_document(str){|doc|
+          builder._natural(doc)
+        }
+        builder._dump
+      rescue SByC::TypeSystem::CoercionError => ex
+        raise DbAgile::SchemaSyntaxError, "Syntax error in schema: #{ex.message}"
+      end
+      module_function :yaml_load
+    
+      #
+      # Loads a schema from a YAML file
+      #
+      # @param [String|IO] a path name or an IO instance
+      # @param [DbAgile::Core::Schema::Builder] a builder instance to use to
+      #        populate the schema
+      # @returns [DbAgile::Core:Schema::DatabaseSchema] the loaded database 
+      #          schema
+      #
+      def yaml_file_load(path_or_io, builder = yaml_builder)
+        case path_or_io
+          when String
+            File.open(path_or_io, 'r'){|io| yaml_load(io, builder) }
+          when IO, File, Tempfile
+            yaml_load(path_or_io, builder)
+          else 
+            raise ArgumentError, "Unable to load schema from #{path_or_io}"
+        end
+      end
+      module_function :yaml_file_load
+        
+
+      ##############################################################################
+      ### About Schema computations
+      ##############################################################################
+      
+      # Resolver block that raises a SchemaConflictError
+      DEFAULT_CONFLICT_RESOLVER_BLOCK = lambda{|left,right|
+        raise SchemaConflictError.new(left, right)
+      }
+      
+      #
+      # Computes a new schema by difference.
+      #
+      # @param [DbAgile::Core::Schema::DatabaseSchema] left reference schema
+      # @param [DbAgile::Core::Schema::DatabaseSchema] right retrieval schema
+      # @param [DbAgile::Core::Schema::Builder] builder to use for the operation
+      #
+      def minus(left, right, 
+                builder = DbAgile::Core::Schema::builder)
+        schema!(left, :left, caller)
+        schema!(right, :right, caller)
+        builder!(builder, :builder, caller)
+        Computations::minus(left, right, builder)
+      end
+      module_function :minus
+      
+      #
+      # Computes a new schema by merging two other schemas.
+      #
+      # @param [DbAgile::Core::Schema::DatabaseSchema] left schema one
+      # @param [DbAgile::Core::Schema::DatabaseSchema] right schema two
+      # @param [DbAgile::Core::Schema::Builder] builder to use for merging
+      # @param [Proc] conflict_resolver a optional block that resolves merging 
+      #               conflicts
+      #
+      def merge(left, right, 
+                builder = DbAgile::Core::Schema::builder, 
+                &conflict_resolver)
+        schema!(left, :left, caller)
+        schema!(right, :right, caller)
+        builder!(builder, :builder, caller)
+        if conflict_resolver.nil?
+          conflict_resolver = DEFAULT_CONFLICT_RESOLVER_BLOCK
+        end
+        Computations::merge(left, right, builder, &conflict_resolver)
+      end
+      module_function :merge
+      
+      #
+      # Filters a schema according to a block
+      #
+      def filter(schema, options = {}, 
+                 builder = DbAgile::Core::Schema::builder, 
+                 &filter_block)
+        schema!(schema, :schema, caller)
+        hash!(options, :options, caller)
+        builder!(builder, :builder, caller)
+        options = Computations::Filter::DEFAULT_OPTIONS.merge(options)
+        filtered = Schema::Computations::filter(schema, options, builder, &filter_block)._strip!
+        if options[:identifier]
+          filtered.schema_identifier = options[:identifier]
+        end
+        filtered
+      end
+      module_function :filter
+        
+      #
+      # Splits a schema according to a block
+      #
+      def split(schema, options = {}, &filter_block)
+        schema!(schema, :schema, caller)
+        hash!(options, :options, caller)
+        options = Computations::Split::DEFAULT_OPTIONS.merge(options)
+        Schema::Computations::split(schema, options, &filter_block)
+      end
+      module_function :split
+      
+      ##############################################################################
+      ### About Schema scripts
+      ##############################################################################
+      
+      #
+      # Computes and returns a list of abstract operations to perform on a database
+      # given a annotated schema (typically, the result of a merge operation)
+      #
+      # @param [DbAgile::Core::Schema::DatabaseSchema] schema an annotated schema
+      # @param [Hash] options staging options
+      # @return [Migrate::AbstractScript] a list of abstract operations
+      #
+      def stage_script(schema, options = Migrate::Stager::DEFAULT_OPTIONS)
+        Migrate::Stager.new.run(schema, options)
+      end
+      module_function :stage_script
+      
+      # 
+      # Computes a create abstract script for a given schema.
+      #
+      # @param [DbAgile::Core::Schema::DatabaseSchema] any valid schema
+      # @return [Migrate::AbstractScript] a list of abstract operations
+      #
+      def create_script(schema)
+        stage_script(EMPTY_SCHEMA + schema)
+      end
+      module_function :create_script
+      
+      # 
+      # Computes a drop abstract script for a given schema.
+      #
+      # @param [DbAgile::Core::Schema::DatabaseSchema] any valid schema
+      # @return [Migrate::AbstractScript] a list of abstract operations
+      #
+      def drop_script(schema)
+        stage_script(schema + EMPTY_SCHEMA)
+      end
+      module_function :drop_script
+      
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/transaction.rb

@@ -0,0 +1,74 @@
+module DbAgile
+  module Core
+    class Transaction
+    
+      ### VARS AND INITIALIZE ######################################################
+    
+      # Underlying connection
+      attr_reader :connection
+    
+      # Creates a Transaction instance
+      def initialize(connection)
+        @connection = connection
+      end
+    
+      ### ABOUT TRANSACTION MANAGEMENT #############################################
+    
+      # Executes a block
+      def execute(&block)
+        raise ArgumentError, "Missing transaction block" unless block
+        connection.chain.transaction do
+          block.call(self)
+        end
+      end
+    
+      # Commits the transaction
+      def commit
+      end
+    
+      # Rollbacks the transaction
+      def rollback
+        raise DbAgile::AbordTransactionError
+      end
+    
+      ### DELEGATE PATTERN #########################################################
+      
+      # Automatically install methods of the Connection and *::TableDriven 
+      # contracts
+      [ DbAgile::Contract::Connection,
+        DbAgile::Contract::Data::TableDriven,
+        DbAgile::Contract::Schema::TableDriven ].each do |mod|
+
+        mod.instance_methods(false).each do |method|
+          self.module_eval <<-EOF
+            def #{method}(*args)
+              connection.chain.#{method}(*args)  
+            end
+          EOF
+        end
+      
+      end # Connection and *::TableDriven
+
+      # Executes the block inside this transaction
+      def transaction(&block)
+        execute(&block)
+      end
+
+      # Automatically install methods of the *::TransactionDriven contract
+      [ DbAgile::Contract::Data::TransactionDriven,
+        DbAgile::Contract::Schema::TransactionDriven ].each do |mod|
+
+        mod.instance_methods(false).each do |method|
+          self.module_eval <<-EOF
+            def #{method}(*args)
+              connection.chain.#{method}(self, *args)  
+            end
+          EOF
+        end
+        
+      end
+
+      private :connection
+    end # class Transaction
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core.rb

@@ -0,0 +1,7 @@
+require 'dbagile/core/chain'
+require 'dbagile/core/io'
+require 'dbagile/core/repository'
+require 'dbagile/core/database'
+require 'dbagile/core/connection'
+require 'dbagile/core/transaction'
+require 'dbagile/core/schema'

data/lib/dbagile/environment/buffering.rb

@@ -0,0 +1,45 @@
+module DbAgile
+  class Environment
+    module Buffering
+      
+      # The output buffer to use for user requests
+      attr_accessor :input_buffer
+    
+      # The output buffer to use for display
+      attr_accessor :output_buffer
+    
+      # 
+      # Flushes something on the output buffer
+      #
+      # Does nothing when no output buffer has been set.
+      #
+      # @param [Object] something to write on environment output
+      # @return [void]
+      #
+      def flush(something, append_new_line = true)
+        unless output_buffer.nil?
+          if something.kind_of?(String)
+            output_buffer << something
+            if append_new_line and not(something =~ /\n$/)
+              output_buffer << "\n"
+            end
+          elsif something.kind_of?(Enumerable)
+            something.each{|v| flush(v, true)}
+          else
+            flush(something.to_s)
+          end
+        end
+        nil
+      end
+    
+      # 
+      # Delegated to the input buffer. Returns nil if no input buffer
+      # has been set
+      #
+      def gets
+        input_buffer.nil? ? nil : input_buffer.gets
+      end
+    
+    end # module Interactions
+  end # class Environment
+end # module DbAgile

data/lib/dbagile/environment/delegator.rb

@@ -0,0 +1,59 @@
+module DbAgile
+  class Environment
+    #
+    # Helper to be an environment delegator
+    #
+    module Delegator
+      
+      [
+        #
+        :interactive?,
+        :interactive!,
+        :interactive=,
+        #
+        :flush,
+        :say,
+        :display,
+        #
+        :console_width,
+        :console_width=,
+        #
+        :repository_path,
+        :repository_path=,
+        :repository,
+        #
+        :input_buffer,
+        :input_buffer=,
+        :output_buffer,
+        :output_buffer=,
+        :asking_buffer,
+        :asking_buffer=,
+        :message_buffer,
+        :message_buffer=,
+        #
+        :with_repository,
+        :with_database,
+        :with_current_database,
+        #
+        :with_connection,
+        :with_current_connection
+      ].each do |method_name|
+        if method_name.to_s =~ /=$/
+          code = <<-EOF
+            def #{method_name}(value)
+              environment.#{method_name} value
+            end
+          EOF
+        else
+          code = <<-EOF
+            def #{method_name}(*args, &block)
+              environment.#{method_name}(*args, &block)
+            end
+          EOF
+        end
+        module_eval(code)
+      end
+    
+    end # module Delegator
+  end # class Environment
+end # module DbAgile