dbagile 0.0.1

data/lib/dbagile/core/repository.rb

@@ -0,0 +1,211 @@
+require 'dbagile/core/repository/yaml_methods'
+require 'dbagile/core/repository/builder'
+module DbAgile
+  module Core
+    class Repository
+      include Enumerable
+      extend Repository::YAMLClassMethods
+      include Repository::YAMLInstanceMethods
+    
+      # Index file name
+      REPOSITORY_INDEX_FILE_NAME = "dbagile.idx"
+    
+      # Path to the root path of the repository
+      attr_reader :root_path
+    
+      # Repository version
+      attr_accessor :version
+      private :version=
+    
+      # Databases as an array of Database instances
+      attr_reader :databases
+    
+      # Current database (its name, i.e. a Symbol)
+      attr_accessor :current_db_name
+    
+      #############################################################################################
+      ### Initialization and parsing
+      #############################################################################################
+    
+      # Creates a repository instance
+      def initialize(root_path, version = DbAgile::VERSION)
+        DbAgile::Robustness::valid_rw_directory!(root_path)
+        DbAgile::Robustness::valid_rw_file!(File.join(root_path, REPOSITORY_INDEX_FILE_NAME))
+        @root_path = root_path
+        @version = version
+        @databases = []
+      end
+      
+      #############################################################################################
+      ### File management
+      #############################################################################################
+      
+      # Returns a friendly path to be printed to user
+      def friendly_path
+        DbAgile::FileSystemTools::friendly_path!(root_path)
+      end
+      
+      # Returns the path to the index file
+      def index_file
+        File.join(root_path, REPOSITORY_INDEX_FILE_NAME)
+      end
+    
+      # Returns a file resolver Proc instance
+      def file_resolver
+        @file_resolver ||= lambda{|f| 
+          if f[0, 1] == '/'
+            f
+          else
+            File.join(File.expand_path(self.root_path), f) 
+          end
+        }
+      end
+      
+      # Resolves a file which could be relative to repository root path
+      def resolve_file(f)
+        file_resolve.call(f)
+      end
+    
+      #############################################################################################
+      ### About databases
+      #############################################################################################
+    
+      # Checks if at least one database exists
+      def empty?
+        databases.empty?
+      end
+    
+      # Checks if a database exists
+      def has_database?(name)
+        !database(name).nil?
+      end
+    
+      # Checks if a name/database is the current one
+      def current?(name_or_db)
+        case name_or_db
+          when Symbol
+            return nil unless has_database?(name_or_db)
+            self.current_db_name == name_or_db
+          when Core::Database
+            self.current_db_name == name_or_db.name
+          else
+            raise ArgumentError, "Symbol or Database expected, #{name_or_db.inspect} found."
+        end
+      end
+    
+      # Yields the block with each database in turn
+      def each(*args, &block)
+        databases.each(*args, &block)
+      end
+    
+      # Returns a database by match. Returns nil if no such database
+      def database(match)
+        return match if match.kind_of?(::DbAgile::Core::Database)
+        databases.find{|c| 
+          case match
+            when Symbol
+              c.name == match
+            when String
+              c.uri == match
+            when Regexp
+              match =~ c.uri
+          end
+        }
+      end
+    
+      # Returns the current database
+      def current_database
+        database(current_db_name)
+      end
+    
+      #############################################################################################
+      ### Updates
+      #############################################################################################
+    
+      # Adds a database instance
+      def <<(db)
+        db.file_resolver = file_resolver
+        self.databases << db
+      end
+    
+      # Removes a database from this repository
+      def remove(db)
+        db = self.database(db)
+        db.nil? ? nil : databases.delete(db)
+      end
+    
+      #############################################################################################
+      ### Input/output
+      #############################################################################################
+      
+      #
+      # Loads a repository from a root path
+      #
+      # @param [String] root_path path to a repository folder
+      # @raise IOError if required repository files do not exists or access is denied 
+      # @raise DbAgile::CorruptedRepositoryError if anything goes wrong
+      #
+      def self.load(root_path)
+        # some checks first
+        DbAgile::Robustness::valid_rw_directory!(root_path)
+        index_file = File.join(root_path, REPOSITORY_INDEX_FILE_NAME)
+        msg = "Not a dbagile repository, missing or access denied on #{index_file}"
+        DbAgile::Robustness::valid_rw_file!(index_file, msg)
+        
+        # loading
+        begin
+          from_yaml_file(index_file, root_path) 
+        rescue StandardError => ex
+          msg = "Repository corruped: #{ex.message}"
+          raise DbAgile::CorruptedRepositoryError, msg, ex.backtrace
+        end
+      end
+      
+      # 
+      # Creates a fresh new repository somewhere
+      #
+      # @param [String] root_path path to an unexisting repository folder
+      # @return [Repository] the created repository instance
+      # @raise IOError is the repository already exists or cannot be created.
+      #
+      def self.create!(root_path)
+        DbAgile::Robustness::unexisting_directory!(root_path)
+        index_file = File.join(root_path, REPOSITORY_INDEX_FILE_NAME)
+        FileUtils.mkdir_p(root_path)
+        FileUtils.touch(index_file)
+        repo = Repository.new(root_path, DbAgile::VERSION)
+        repo.save!
+      end
+    
+      #
+      # Saves the repository
+      #
+      # @return [Repository] the repository itself
+      # @raise IOError if something goes wrong when saving the repository
+      #
+      def save!
+        DbAgile::Robustness::valid_rw_file!(self.index_file)
+        flush(self.index_file)
+        self
+      end
+    
+      # 
+      # Flushes the repository into a given file or IO
+      #
+      # This method is not robust to dir/file errors and should be protected
+      # upstream.
+      #
+      def flush(output_file)
+        if output_file.kind_of?(::IO)
+          output_file << to_yaml
+        else
+          ::File.open(output_file, 'w'){|io| flush(io)}
+        end
+        self
+      end
+    
+      private :flush
+      private_class_method :from_yaml_file, :from_yaml
+    end # class Repository
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/builder/coercion.rb

@@ -0,0 +1,210 @@
+module DbAgile
+  module Core
+    module Schema
+      class Builder
+        module Coercion
+        
+          ###############################################################################
+          ### Tools
+          ###############################################################################
+          def unsymbolize_hash(h)
+            unsymbolized = {}
+            h.each_pair{|k,v| unsymbolized[k.to_s] = v}
+            unsymbolized
+          end
+          module_function :unsymbolize_hash
+        
+          # Unsymbolizes an array of names
+          def unsymbolize_array(array)
+            array.collect{|c| c.to_s}
+          end
+          module_function :unsymbolize_array
+        
+          ###############################################################################
+          ### Validity
+          ###############################################################################
+        
+          # Raises a DbAgile::SchemaSyntaxError
+          def invalid!(msg)
+            raise DbAgile::SchemaSyntaxError, msg, caller
+          end
+        
+          # Raises a coercion error
+          def coercion_error!(msg = "")
+            raise ::SByC::TypeSystem::CoercionError, msg, caller
+          end
+        
+          # Asserts that all args are not nil
+          def not_nil!(*args)
+            if args.any?{|arg| arg.nil?}
+              coercion_error!
+            end
+            args
+          end
+          
+          # Asserts that all args are not empty
+          def not_empty!(*args)
+            if args.any?{|arg| arg.nil? or arg.to_s.empty?}
+              coercion_error!
+            end
+            args
+          end
+        
+          # Asserts that a hash is not nil and a hash
+          def not_nil_hash!(hash)
+            not_nil!(hash)
+            unless hash.kind_of?(Hash)
+              coercion_error!("Hash expected, #{hash.class} received")
+            end
+            hash
+          end
+          
+          def has_exactly_hash_keys!(hash, *keys)
+            not_nil!(hash)
+            unless keys.all?{|k| hash.key?(k)}
+              coercion_error!("Expected #{keys.inspect}, found #{hash.keys.inspect}")
+            end
+            hash
+          end
+        
+          # Asserts that a name is valid
+          def valid_name!(name)
+            not_empty!(name)
+            unless [String, Symbol].include?(name.class)
+              coercion_error!
+            end
+            name
+          end
+        
+          ###############################################################################
+          ### Data types (coercion error)
+          ###############################################################################
+        
+          # Coerces an array
+          def coerce_array(array, non_empty)
+            unless array.kind_of?(Array)
+              coercion_error!
+            end
+            if non_empty and array.empty?
+              coercion_error!
+            end
+            array
+          end
+        
+          # Coerces a symbolized hash
+          def coerce_symbolized_hash(hash, recursive = false)
+            hash = not_nil_hash!(hash)
+            symbolized = {}
+            hash.each_pair{|k,v| 
+              if recursive and v.kind_of?(Hash)
+                v = coerce_symbolized_hash(v)
+              end
+              symbolized[coerce_name(k)] = v
+            }
+            symbolized
+          end
+        
+          ###############################################################################
+          ### Sub-concepts (coercion error)
+          ###############################################################################
+        
+          # Coerces a name
+          def coerce_name(name)
+            valid_name!(name)
+            name.to_s.to_sym
+          end
+          alias :coerce_relvar_name :coerce_name
+          alias :coerce_attribute_name :coerce_name
+          alias :coerce_constraint_name :coerce_name
+          alias :coerce_index_name :coerce_name
+        
+          # Coerces a default value
+          def coerce_default_value(value, domain)
+            not_nil!(value, domain)
+            if value.kind_of?(Symbol)
+              case value 
+                when :autonumber
+                  :autonumber
+                else
+                  invalid!("unknown default value handler #{value}") 
+              end
+            else
+              SByC::TypeSystem::Ruby::coerce(value, domain)
+            end
+          end
+        
+          # Coerces a domain
+          def coerce_domain(domain)
+            not_nil!(domain)
+            domain = SByC::TypeSystem::Ruby::coerce(domain, Module)
+            unless DbAgile::RECOGNIZED_DOMAINS.include?(domain)
+              invalid!("unable to use #{domain} for attribute domain")
+            end
+            domain
+          end
+        
+          # Coerces a mandatory value
+          def coerce_mandatory(mandatory)
+            mandatory.nil? ? true : SByC::TypeSystem::Ruby::coerce(mandatory, SByC::TypeSystem::Ruby::Boolean)
+          end
+        
+          # Coerces attributes names
+          def coerce_attribute_names(defn, non_empty = true)
+            defn = coerce_array(defn, non_empty)
+            defn.collect{|c| coerce_name(c)}
+          end
+
+          ###############################################################################
+          ### Concepts (coercion error)
+          ###############################################################################
+        
+          # Coerces an attribute definition
+          def coerce_attribute_definition(defn)
+            defn = coerce_symbolized_hash(defn)
+            defn[:domain] = coerce_domain(defn[:domain])
+            if defn.key?(:default)
+              defn[:default] = coerce_default_value(defn[:default], defn[:domain])
+            end
+            defn[:mandatory] = coerce_mandatory(defn[:mandatory])
+            defn
+          end
+        
+          # Coerces a constraint definition
+          def coerce_constraint_definition(defn)
+            defn = coerce_symbolized_hash(defn)
+            defn[:type] = coerce_name(defn[:type])
+            
+            case type = defn[:type]
+              when :primary_key, :candidate_key
+                has_exactly_hash_keys!(defn, :type, :attributes)
+                defn[:attributes] = coerce_attribute_names(defn[:attributes], true)
+              when :foreign_key
+                if defn.key?(:key)
+                  has_exactly_hash_keys!(defn, :type, :attributes, :references, :key)
+                  defn[:attributes] = coerce_attribute_names(defn[:attributes], true)
+                  defn[:references] = coerce_name(defn[:references])
+                  defn[:key]        = coerce_name(defn[:key])
+                else
+                  has_exactly_hash_keys!(defn, :type, :attributes, :references)
+                  defn[:attributes] = coerce_attribute_names(defn[:attributes], true)
+                  defn[:references] = coerce_name(defn[:references])
+                end
+              else
+                invalid!("unknown constraint type #{type}")
+            end
+            defn
+          end
+
+          # Coerces an index definition
+          def coerce_index_definition(defn)
+            defn = coerce_symbolized_hash(defn)
+            defn[:relvar] = coerce_name(defn[:relvar])
+            defn[:attributes] = coerce_attribute_names(defn[:attributes], true)
+            defn
+          end
+         
+        end # module Coercion
+      end # class Builder
+    end # module Schema
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/schema/builder/concept_factory.rb

@@ -0,0 +1,61 @@
+module DbAgile
+  module Core
+    module Schema
+      class Builder
+        module ConceptFactory
+
+          # Builds a logical schema
+          def build_schema(identifier)
+            Schema.new(identifier)
+          end
+          
+          # Builds a logical schema
+          def build_logical
+            Schema::Logical.new
+          end
+          
+          # Builds a relvar
+          def build_relvar(name)
+            Schema::Logical::Relvar.new(name)
+          end
+        
+          # Builds a heading
+          def build_heading
+            Schema::Logical::Heading.new
+          end
+        
+          # Builds an attribute
+          def build_attribute(name, definition)
+            Schema::Logical::Attribute.new(name, definition)
+          end
+        
+          # Builds a constraint collection
+          def build_constraints
+            Schema::Logical::Constraint.new
+          end
+        
+          # Builds a constraint
+          def build_constraint(name, definition)
+            Schema::Logical::Constraint::factor(name, definition)
+          end
+        
+          # Builds a physical schema
+          def build_physical
+            Schema::Physical.new
+          end
+          
+          # Builds an index collection
+          def build_indexes
+            Schema::Physical::Indexes.new
+          end
+        
+          # Builds an index
+          def build_index(name, definition)
+            Schema::Physical::Index.new(name, definition)
+          end
+
+        end # module ConceptFactory
+      end # class Builder
+    end # module Schema
+  end # module Core
+end # module DbAgile

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

@@ -0,0 +1,187 @@
+require 'dbagile/core/schema/builder/coercion'
+require 'dbagile/core/schema/builder/concept_factory'
+module DbAgile
+  module Core
+    module Schema
+      class Builder
+        include Builder::Coercion
+        include Builder::ConceptFactory
+        
+        # Call stack
+        attr_accessor :stack
+        
+        # Creates a builder instance
+        def initialize(schema = Schema.new)
+          if schema
+            @stack = [ [:schema, schema ] ]
+          else
+            @stack = [ [:root, {}] ]
+          end
+        end
+        
+        ############################################################################
+        ### About result
+        ############################################################################
+        
+        # Dumps as a Schema instance
+        def _dump
+          if stack.last[0] == :schema
+            _peek(:schema)
+          else
+            _peek(:root)[:schema]
+          end
+        end
+        
+        ############################################################################
+        ### About the call stack
+        ############################################################################
+        
+        # Push a hash on the stack
+        def _push(section, object, &block)
+          stack.push([section, object])
+          if block
+            DbAgile::RubyTools::optional_args_block_call(block, [ object ])
+            _pop
+          end
+          object
+        end
+        
+        # Pops a hash from the stack
+        def _pop
+          stack.pop
+        end
+        
+        # Returns top value of the stack
+        def _peek(section = nil)
+          unless section.nil? 
+            if stack.empty? or not(stack.last[0] == section)
+              invalid!("expected to be in #{section}, but was #{stack.last[0]}")
+            end
+          end
+          stack.last[1]
+        end
+        
+        # Applies natural rules according to current section
+        def _natural(hash)
+          case section = stack.last[0]
+            when :schema
+              coerce_symbolized_hash(hash).each_pair{|name, defn|
+                self.send(name, defn)
+              }
+            when :logical
+              coerce_symbolized_hash(hash).each_pair{|relvar_name, relvar_def|
+                relvar(relvar_name, relvar_def)
+              }
+            when :heading
+              coerce_symbolized_hash(hash).each_pair{|attr_name, attr_def|
+                attribute(attr_name, attr_def)
+              }
+            when :constraints
+              coerce_symbolized_hash(hash).each_pair{|c_name, c_def|
+                constraint(c_name, c_def)
+              }
+            when :physical
+              coerce_symbolized_hash(hash).each_pair{|name, defn|
+                self.send(name, defn)
+              }
+            when :indexes
+              coerce_symbolized_hash(hash).each_pair{|index_name, index_def|
+                index(index_name, index_def)
+              }
+            else
+              coerce_symbolized_hash(hash).each_pair{|k, v|
+                invalid!("No such section #{k}") unless self.respond_to?(k)
+                self.send(k, v)
+              }
+          end
+        end
+        
+        ############################################################################
+        ### Logical sections
+        ############################################################################
+        
+        # Starts the logical section and yields
+        def database_schema(identifier = nil, hash = nil, &block)
+          block = lambda{ _natural(hash) } unless block
+          schema = (_peek(:root)[:schema] ||= build_schema(identifier))
+          _push(:schema, schema, &block)
+        end
+        alias :schema :database_schema
+        
+        # Starts the logical section and yields
+        def logical(hash = nil, &block)
+          block = lambda{ _natural(hash) } unless block
+          logical = (_peek(:schema)[:logical] ||= build_logical)
+          _push(:logical, logical, &block)
+        end
+        
+        # Starts a relvar section
+        def relvar(name, hash = nil, &block)
+          block = lambda{ _natural(hash) } unless block
+          name = coerce_relvar_name(name)
+          relvar = (_peek(:logical)[name] ||= build_relvar(name))
+          _push(:relvar, relvar, &block)
+        rescue SByC::TypeSystem::CoercionError => ex
+          invalid!("Invalid relvar definition (#{name}): #{ex.message}")
+        end
+        
+        # Starts a heading section
+        def heading(hash = nil, &block)
+          block = lambda{ _natural(hash) } unless block
+          heading = (_peek(:relvar)[:heading] ||= build_heading)
+          _push(:heading, heading, &block)
+        end
+        
+        # Starts a constraints section
+        def constraints(hash = nil, &block)
+          block = lambda{ _natural(hash) } unless block
+          cs = (_peek(:relvar)[:constraints] ||= build_constraints)
+          _push(:constraints, cs, &block)
+        end
+        
+        ### 
+        
+        # Adds an attribute to current heading
+        def attribute(name, definition)
+          name, defn = coerce_attribute_name(name), coerce_attribute_definition(definition)
+          _peek(:heading)[name] = build_attribute(name, defn)
+        end
+        
+        # Adds a constraint to current relvar
+        def constraint(name, definition)
+          name, defn = coerce_constraint_name(name), coerce_constraint_definition(definition)
+          _peek(:constraints)[name] = build_constraint(name, defn)
+        end
+        
+        ############################################################################
+        ### Physical sections
+        ############################################################################
+        
+        # Starts the physical section and yields
+        def physical(hash = nil, &block)
+          block = lambda{ _natural(hash) } unless block
+          physical = (_peek(:schema)[:physical] ||= build_physical)
+          _push(:physical, physical, &block)
+        end
+        
+        # Starts the indexes section and yields
+        def indexes(hash = nil, &block)
+          block = lambda{ _natural(hash) } unless block
+          indexes = (_peek(:physical)[:indexes] ||= build_indexes)
+          _push(:indexes, indexes, &block)
+        end
+        
+        ### 
+        
+        # Adds an index to indexes
+        def index(name, definition)
+          name, defn = coerce_index_name(name), coerce_index_definition(definition)
+          _peek(:indexes)[name] = build_index(name, defn)
+        rescue SByC::TypeSystem::CoercionError => ex
+          invalid!("Invalid index definition (#{name}, #{definition.inspect}): #{ex.message}")
+        end
+        
+      end # class Builder
+    end # module Schema
+  end # module Core
+end # module DbAgile