dbagile 0.0.1

data/lib/dbagile/core/database.rb

@@ -0,0 +1,221 @@
+module DbAgile
+  module Core
+    #
+    # Encapsulates a database handler.
+    # 
+    class Database
+      
+      # Database name
+      attr_reader :name
+      
+      # Database uri
+      attr_accessor :uri
+      
+      # Array of files for the announced schema
+      attr_accessor :announced_files
+      alias :announced_schema= :announced_files=
+      
+      # Array of files for the effective schema
+      attr_accessor :effective_files
+      alias :effective_schema= :effective_files=
+      
+      # Resolves relative files
+      attr_accessor :file_resolver
+      
+      # Plugs as arrays of arrays
+      attr_reader :plugs
+      
+      # Creates a database instance
+      def initialize(name, uri = nil, &block)
+        raise ArgumentError, "Database name is mandatory" unless name.kind_of?(Symbol)
+        raise ArgumentError, "Database DSL is deprecated" unless block.nil?
+        @name = name
+        @uri = uri
+        @announced_files = []
+        @effective_files = []
+        @file_resolver = lambda{|f| ::File.expand_path(f) }
+        @chain = ::DbAgile::Core::Chain.new
+      end
+      
+      
+      
+      ##############################################################################
+      ### About connector
+      ##############################################################################
+      
+      # @see Chain#plug
+      def plug(*args)
+        (@plugs ||= []).push(*args)
+        @chain.plug(*args)
+      end
+      
+      # Installs plugins
+      def plugins=(plugins)
+        plugins = plugins.collect{|p| Kernel.eval(p)}
+        plug(*plugins)
+      end
+      
+      
+      ##############################################################################
+      ### About connection
+      ##############################################################################
+      
+      # Checks if the connection pings correctly.
+      def ping?
+        connect.ping?
+      end
+      
+      # Connects and returns a Connection object
+      def connect(options = {})
+        raise ArgumentError, "Options should be a Hash" unless options.kind_of?(Hash)
+        raise DbAgile::Error, "Database has no uri" if uri.nil?
+        if uri =~ /:\/\//
+          adapter = DbAgile::Adapter::factor(uri, options)
+        elsif file_resolver
+          file = file_resolver.call(uri)
+          adapter = DbAgile::Adapter::factor("sqlite://#{file}", options)
+        else
+          raise DbAgile::Error, "A file resolver is required for using #{uri} as database uri"
+        end
+        connector = @chain.connect(adapter)
+        Connection.new(connector)
+      end
+      
+      #
+      # Yields the block with a connection; disconnect after that.
+      #
+      # @raise ArgumentError if no block is provided
+      # @return block execution result
+      #
+      def with_connection(conn_options = {})
+        raise ArgumentError, "Missing block" unless block_given?
+        begin
+          connection = connect(conn_options)
+          result = yield(connection)
+          result
+        ensure
+          connection.disconnect if connection
+        end
+      end
+      
+      ##############################################################################
+      ### About schema
+      ##############################################################################
+      
+      # Does this database has announced schema files?
+      def has_announced_schema?
+        !(@announced_files.nil? or @announced_files.empty?)
+      end
+      
+      # Does this database has effective schema files?
+      def has_effective_schema?
+        !(@effective_files.nil? or @effective_files.empty?)
+      end
+      
+      # Loads a schema from schema files
+      def load_schema_from_files(files)
+        builder = DbAgile::Core::Schema::builder
+        builder.schema(files){
+          files.collect{|f| file_resolver.call(f)}.each{|f|
+            DbAgile::Core::Schema::yaml_file_load(f, builder)
+          }
+        }
+        builder._dump
+      end
+      
+      # Returns the schema of highest level (announced -> effective -> physical).
+      def schema
+        announced_schema(true)
+      end
+      
+      # Returns the announced schema. If no announce schema files are installed
+      # and unstage is true, returns the effective schema. Returns nil otherwise.
+      def announced_schema(unstage = false)
+        if has_announced_schema?
+          load_schema_from_files(announced_files)
+        elsif unstage
+          effective_schema(unstage)
+        else
+          nil
+        end
+      end
+      
+      # Overrides announced schema with a given schema
+      def set_announced_schema(schema)
+        # Set announced files
+        self.announced_files ||= []
+        case announced_files.size
+          when 0
+            FileUtils.mkdir_p(file_resolver.call(name))
+            self.announced_files = [ "#{name}/announced.yaml" ]
+          when 1
+          else 
+            raise "Unable to set announced schema with multiple effective files"
+        end
+        ::File.open(file_resolver.call(announced_files[0]), 'w') do |io|
+          io << schema.to_yaml
+        end
+      end
+      
+      # Returns the effective schema. If no effective files are installed and 
+      # unstage is true, returns the physical schema. Returns nil otherwise.
+      def effective_schema(unstage = false)
+        if has_effective_schema?
+          load_schema_from_files(effective_files)
+        elsif unstage
+          physical_schema
+        else
+          nil
+        end
+      end
+      
+      # Overrides effective schema with a given schema
+      def set_effective_schema(schema)
+        # Set effective files
+        self.effective_files ||= []
+        case effective_files.size
+          when 0
+            FileUtils.mkdir_p(file_resolver.call(name.to_s))
+            self.effective_files = [ "#{name}/effective.yaml" ]
+          when 1
+          else 
+            raise "Unable to set effective schema with multiple effective files"
+        end
+        ::File.open(file_resolver.call(effective_files[0]), 'w') do |io|
+          io << schema.to_yaml
+        end
+      end
+      
+      # Returns the database physical schema
+      def physical_schema
+        with_connection{|c| c.physical_schema}
+      end
+      
+      private :load_schema_from_files
+      
+      ##############################################################################
+      ### About io
+      ##############################################################################
+      
+      # Converts this database to a yaml string
+      def to_yaml(opts = {})
+        YAML::quick_emit(self, opts){|out|
+          out.map("tag:yaml.org,2002:map") do |map|
+            map.add('uri', self.uri)
+            if has_announced_schema?
+              map.add('announced_schema', self.announced_files || [])
+            end
+            if has_effective_schema?
+              map.add('effective_schema', self.effective_files || [])
+            end
+            if plugs and not(plugs.empty?) 
+              ps = plugs.collect{|p| SByC::TypeSystem::Ruby::to_literal(p)}
+              map.add('plugins', ps)
+            end
+          end
+        }
+      end
+      
+    end # class Database
+  end # module Core
+end # module DbAgile 

data/lib/dbagile/core/io/dsl.rb

@@ -0,0 +1,95 @@
+module DbAgile
+  module Core
+    module IO
+      class DSL
+        include DbAgile::Core::IO::Robustness
+        
+        # The Repository instance passed at construction
+        attr_reader :repository
+        
+        # The current Database instance
+        attr_reader :current_database
+        
+        # Creates a DSL instance
+        def initialize(repository = nil, database = nil, &block)
+          @repository = repository
+          @current_database = database
+          self.instance_eval(&block) unless block.nil?
+        end
+        
+        # Adds a database under a given name
+        def database(name, &block)
+          valid_database_name!(name)
+          created = with_database(Core::Database.new(name)){|cfg|
+            self.instance_eval(&block)
+            cfg
+          }
+          unless repository.nil?
+            repository << created
+          end
+          created
+        end
+        
+        # Sets the uri on the current database
+        def uri(str)
+          dsl_has_database!
+          valid_database_uri!(str)
+          current_database.uri = str
+        end
+        
+        # Sets the announced schema files
+        def announced_schema(*files)
+          dsl_has_database!
+          current_database.announced_files = valid_schema_files!(files)
+        end
+        
+        # Sets the effective schema files
+        def effective_schema(*files)
+          dsl_has_database!
+          current_database.effective_files = valid_schema_files!(files)
+        end
+        
+        # @see DbAgile::Core::Database#plug
+        def plug(*args)
+          dsl_has_database!
+          current_database.plug(*args)
+        end
+        
+        # Sets the current database
+        def current_db(name)
+          dsl_has_repository!
+          repository.current_db_name = name
+        end
+        
+        ###
+        
+        private 
+
+        # Yields the block with a database
+        def with_database(db)
+          if db.kind_of?(DbAgile::Core::Database)
+            @current_database = db
+            result = yield(db)
+            @current_database = nil
+            result
+          elsif db.kind_of?(Symbol) or db.nil?
+            dsl_has_repository!
+            has_database!(repository, cfg)
+            with_database(repository.database(cfg), &block)
+          end
+        end
+        
+        # Asserts that there is a current database
+        def dsl_has_database!
+          raise DbAgile::Error, "Invalid Core::IO::DSL usage, no current database" if current_database.nil?
+        end
+        
+        # Asserts that there is a current repository
+        def dsl_has_repository!
+          raise DbAgile::Error, "Invalid Core::IO::DSL usage, no current repository" if repository.nil?
+        end
+        
+      end # class DSL
+    end # module IO
+  end # module Core
+end # module DbAgile

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

@@ -0,0 +1,82 @@
+module DbAgile
+  module Core
+    module IO
+      module Robustness
+        
+        #
+        # Asserts that a database name is valid or raises a InvalidDatabaseName 
+        # error. A valid database name is a Symbol that matches /[a-z][a-z0-9_]*/.
+        #
+        # @returns [Symbol] name
+        # @raise DbAgile::InvalidDatabaseName if assertion fails
+        #
+        def valid_database_name!(name)
+          raise DbAgile::InvalidDatabaseName, "Invalid database name #{name}"\
+            unless name.kind_of?(Symbol) and /[a-z][a-z0-9_]*/ =~ name.to_s
+          name
+        end
+      
+        # 
+        # Asserts that a database uri is valid or raises a InvalidDatabaseUri error.
+        #
+        # A valid database uri is any valid absolute URI (for now, will be restricted 
+        # to known adapters in the future).
+        #
+        # @return [String] uri
+        # @raise DbAgile::InvalidDatabaseUri if assertion fails
+        #
+        def valid_database_uri!(uri)
+          require 'uri'
+          got = URI::parse(uri)
+          if got.scheme or (uri =~ /\.db$/)
+            uri
+          else
+            raise DbAgile::InvalidDatabaseUri, "Invalid database uri: #{uri}"
+          end
+        rescue URI::InvalidURIError
+          raise DbAgile::InvalidDatabaseUri, "Invalid database uri: #{uri}"
+        end
+        
+        #
+        # Asserts that a database exists inside a Repository instance. 
+        # When db_name is nil, asserts that a default database is set.
+        #
+        # @param [DbAgile::Core::Repository] a repository
+        # @return [DbAgile::Core::Database] the database instance when found.
+        # @raise ArgumentError if repository is not a Repository instance
+        # @raise DbAgile::NoSuchDatabaseError if the database cannot be found.
+        # @raise DbAgile::NoDefaultDatabaseError if db_name is nil and no 
+        #        current database is set on the repository.
+        #
+        def has_database!(repository, db_name = nil)
+          raise ArgumentError, "Repository expected, got #{repository}"\
+            unless repository.kind_of?(DbAgile::Core::Repository)
+          db = if db_name.nil?
+            repository.current_database
+          else 
+            repository.database(db_name)
+          end
+          if db.nil?
+            raise DbAgile::NoSuchDatabaseError, "Unknown database #{db_name}" if db_name
+            raise DbAgile::NoDefaultDatabaseError, "No default database set (try 'dba use ...' first)"
+          else
+            db
+          end
+        end
+        
+        # 
+        # Coerces and asserts that schema files arguments are correct. 
+        # Returns normalized version.
+        #
+        def valid_schema_files!(*files)
+          files = files.flatten
+          unless files.all?{|f| f.kind_of?(String)}
+            raise DbAgile::CorruptedRepositoryError, "Invalid schema files #{files.inspect}"
+          end
+          files
+        end
+      
+      end # module Robustness
+    end # module IO
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/io.rb

@@ -0,0 +1,2 @@
+require 'dbagile/core/io/robustness'
+require 'dbagile/core/io/dsl'

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

@@ -0,0 +1,67 @@
+module DbAgile
+  module Core
+    class Repository
+      class Builder
+        include DbAgile::Environment::Delegator
+        
+        # Environment to use
+        attr_reader :environment
+        
+        # Creates a builder instance
+        def initialize(env)
+          @environment = env
+        end
+        
+        #
+        # Ensures that the repository exists. If not, ask the user about creating
+        # one in interactive mode; raises an error otherwise. Continues execution
+        # with the provided block if required.
+        #
+        def ensure_repository(&block)
+          env = self.environment
+          if env.repository_exists?
+            block.call if block
+          elsif env.interactive?
+            where = env.friendly_repository_path
+            msg = <<-EOF.gsub(/^\s*\| ?/, '')
+            | DbAgile's repository #{where} does not exist. Maybe it's the first time you
+            | lauch dba. Do you want to create a fresh repository now?
+            EOF
+            confirm(msg, "Have a look at 'dba help repo:create'"){
+              # create it!
+              say("Creating repository #{where}...")
+              DbAgile::Core::Repository::create!(env.repository_path)
+              say("Repository has been successfully created.")
+            
+              # continue?
+              if block
+                msg = "Do you want to continue with previous command execution?"
+                confirm(msg, &block)
+              end
+            }
+          else
+            # to force an error
+            environment.repository
+          end
+        end
+      
+        # Yields the block if the user confirms something and returns block 
+        # execution. Returns nil otherwise
+        #
+        def confirm(msg, on_no_msg = nil)
+          say("\n")
+          say(msg, :magenta)
+          answer = environment.ask(""){|q| q.validate = /^y(es)?|n(o)?|q(uit)?/i}
+          case answer.strip
+            when /^n/i, /^q/i
+              say("\n")
+              say(on_no_msg, :magenta) unless on_no_msg.nil?
+            when /^y/i
+              yield
+          end
+        end
+      
+      end # class Builder
+    end # class Repository
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/repository/yaml_methods.rb

@@ -0,0 +1,82 @@
+module DbAgile
+  module Core
+    class Repository
+      
+      module YAMLInstanceMethods
+
+        # Dumps the repository to YAML
+        def to_yaml(opts = {})
+          YAML::quick_emit(self, opts){|out|
+            dbmap = DbAgile::Tools::OrderedHash.new
+            databases.each{|db| dbmap[db.name.to_s] = db}
+            out.map("tag:yaml.org,2002:map") do |map|
+              map.add('version', self.version)
+              map.add('databases', dbmap)
+              map.add('current', self.current_db_name.to_s)
+            end
+          }
+        end
+      
+      end # module YAMLInstanceMethods
+
+      module YAMLClassMethods
+
+        #
+        # Loads a repository from a YAML file and returns a Core::Repository instance.
+        #
+        # This method is not robust at all and re-raises any error that occurs. It
+        # should be protected upstream.
+        #
+        # @param [String] file path to a repository index (exist, readable)
+        # @param [String] root_path path of the repository itself (exist, readable)
+        # @raise DbAgile::CorruptedRepositoryError if anything goes wrong.
+        #
+        def from_yaml_file(file, root_path)
+          from_yaml(File.read(file), root_path)
+        end
+        
+        #
+        # Loads a repository from a YAML file and returns a Core::Repository instance.
+        #
+        # This method is not robust at all and re-raises any error that occurs. It
+        # should be protected upstream.
+        #
+        # @param [String] str a YAML source
+        # @param [String] root_path root path to set on the repository 
+        #
+        def from_yaml(str, root_path)
+          # Load the hash
+          hash = YAML::load(str)
+        
+          # Load the repository version
+          version = hash['version'].to_s.strip
+          if version.nil? or version.empty?
+            raise "missing version number"
+          end
+        
+          # create the repository instance
+          repo = Repository.new(root_path, version)
+        
+          # load databases
+          hash['databases'].each_pair{|dbname, dbconfig|
+            db = Core::Database.new(dbname.to_s.to_sym)
+            dbconfig.each_pair{|key, value|
+              db.send(:"#{key}=", value)
+            }
+            repo << db
+          }
+        
+          # Set current database
+          current = hash['current'].to_s.strip
+          unless current.empty?
+            repo.current_db_name = current.to_sym
+          end
+        
+          repo
+        end
+      
+      end # module YAMLClassMethods
+      
+    end # class Repository
+  end # module Core
+end # module DbAgile