dbagile 0.0.1

data/lib/dbagile/contract/robust/optimistic/schema/table_driven.rb

@@ -0,0 +1,53 @@
+module DbAgile
+  module Contract
+    module Robust
+      class Optimistic
+        module Schema
+          module TableDriven
+            
+            # @see DbAgile::Contract::Schema::TableDriven#has_column?
+            def has_column?(*args, &block)
+              delegate.has_column?(*args, &block)
+            rescue
+              has_table!(args[0])
+              raise
+            end
+        
+            # @see DbAgile::Contract::Schema::TableDriven#heading
+            def heading(*args, &block)
+              delegate.heading(*args, &block)
+            rescue
+              has_table!(args[0])
+              raise
+            end
+
+            # @see DbAgile::Contract::Schema::TableDriven#column_names
+            def column_names(*args, &block)
+              delegate.column_names(*args, &block)
+            rescue
+              has_table!(args[0])
+              raise
+            end
+      
+            # @see DbAgile::Contract::Schema::TableDriven#is_key
+            def is_key?(*args, &block)
+              delegate.is_key?(*args, &block)
+            rescue
+              has_table!(args[0])
+              raise
+            end
+      
+            # @see DbAgile::Contract::Schema::TableDriven#keys
+            def keys(*args, &block)
+              delegate.keys(*args, &block)
+            rescue
+              has_table!(args[0])
+              raise
+            end
+
+          end # module Schema
+        end # module Data
+      end # class Optimistic
+    end # module Robust
+  end # module Contract
+end # module DbAgile

data/lib/dbagile/contract/robust/optimistic/schema/transaction_driven.rb

@@ -0,0 +1,45 @@
+module DbAgile
+  module Contract
+    module Robust
+      class Optimistic
+        module Schema
+          module TransactionDriven
+            
+            # @see DbAgile::Contract::Schema::TransactionDriven#create_table
+            def create_table(*args, &block)
+              delegate.create_table(*args, &block)
+            rescue
+              not_has_table!(args[1])
+              raise
+            end
+        
+            # @see DbAgile::Contract::Schema::TransactionDriven#drop_table
+            def drop_table(*args, &block)
+              delegate.drop_table(*args, &block)
+            rescue
+              has_table!(args[1])
+              raise
+            end
+      
+            # @see DbAgile::Contract::Schema::TransactionDriven#add_columns
+            def add_columns(*args, &block)
+              delegate.add_columns(*args, &block)
+            rescue
+              has_table!(args[1])
+              raise
+            end
+      
+            # @see DbAgile::Contract::Schema::TransactionDriven#key!
+            def key!(*args, &block)
+              delegate.key!(*args, &block)
+            rescue
+              has_table!(args[1])
+              raise
+            end
+
+          end # module TransactionDriven
+        end # module Schema
+      end # class Optimistic
+    end # module Robust
+  end # module Contract
+end # module DbAgile

data/lib/dbagile/contract/robust/optimistic.rb

@@ -0,0 +1,18 @@
+require 'dbagile/contract/robust/optimistic/data/table_driven'
+require 'dbagile/contract/robust/optimistic/data/transaction_driven'
+require 'dbagile/contract/robust/optimistic/schema/table_driven'
+require 'dbagile/contract/robust/optimistic/schema/transaction_driven'
+module DbAgile
+  module Contract
+    module Robust
+      class Optimistic
+        include DbAgile::Contract::Utils::Delegate
+        include DbAgile::Contract::Robust::Helpers
+        include DbAgile::Contract::Robust::Optimistic::Data::TableDriven
+        include DbAgile::Contract::Robust::Optimistic::Data::TransactionDriven
+        include DbAgile::Contract::Robust::Optimistic::Schema::TableDriven
+        include DbAgile::Contract::Robust::Optimistic::Schema::TransactionDriven
+      end # class Optimistic
+    end # module Robust
+  end # module Contract
+end # module DbAgile

data/lib/dbagile/contract/robust.rb

@@ -0,0 +1,20 @@
+module DbAgile
+  
+  # All errors related to the contract
+  class ContractError < DbAgile::Error; end 
+  
+  # Raised when a table should not exists but does
+  class TableAlreadyExistsError < ContractError; end
+  
+  # Raised when possible when a table does not exists
+  class NoSuchTableError < ContractError; end
+  
+  # Raised when a key is violated
+  class KeyViolationError < ContractError; end
+
+  # Internal error used when transaction are aborted
+  class AbordTransactionError < ContractError; end
+
+end
+require 'dbagile/contract/robust/helpers'
+require 'dbagile/contract/robust/optimistic'

data/lib/dbagile/contract/schema/table_driven.rb

@@ -0,0 +1,89 @@
+module DbAgile
+  module Contract
+    module Schema
+      #
+      # Table-driven adapter read-only methods about schemas.
+      #
+      module TableDriven
+        
+        #
+        # Returns true if a given table exists in the database, false otherwise.
+        # 
+        # @param [Symbol] table_name name of a table
+        # @return true if the table exists, false otherwise
+        #
+        def has_table?(table_name)
+          Kernel.raise NotImplementedError
+        end
+      
+        #
+        # Returns true if a column exists, false otherwise.
+        #
+        # A default implementation is provided that relies on column_names.
+        #
+        # @param [Symbol] table_name the name of a table
+        # @param [Symbol] column_name the name of a column
+        # @return true if the column exists on that table, false otherwise
+        #
+        # @pre [table_name] the table must exist
+        #
+        def has_column?(table_name, column_name)
+          column_names(table_name).include?(column_name)
+        end
+      
+        #
+        # Returns the heading of a given table.
+        #
+        # @param [Symbol] table_name the name of a table
+        # @return [Hash<Symbol => Class>] table heading
+        #
+        # @pre [table_name] the table must exist
+        #
+        def heading(table_name)
+          Kernel.raise NotImplementedError
+        end
+      
+        #
+        # Returns the list of column names for a given table.
+        #
+        # @param [Symbol] table_name the name of a table
+        # @param [Boolean] sort sort column by names?
+        # @return [Array<Symbol>] column names
+        #
+        # @pre [table_name] the table must exist
+        #
+        def column_names(table_name, sort = false)
+          Kernel.raise NotImplementedError
+        end
+      
+        #
+        # Checks if an array of column names for a key for a given table.
+        #
+        # @param [Symbol] table_name the name of a table
+        # @param [Array<Symbol>] columns column names, in any order
+        # @return [Boolean] true if the table contains such a unique key, 
+        #         false otherwise
+        #
+        # @pre [table_name] the table must exist
+        #
+        def is_key?(table_name, columns)
+          keys(table_name).include?(columns)
+        end
+      
+        #
+        # Returns available keys for a given table as an array of column 
+        # names.
+        #
+        # @param [Symbol] table_name the name of a table
+        # @return [Array<Array<Symbol>>] keys of the table
+        #
+        # @pre [table_name] the table must exist
+        #
+        def keys(table_name)
+          Kernel.raise NotImplementedError
+        end
+      
+      end # module TableDriven
+    end # module Schema 
+  end # module Contract
+end # module DbAgile

data/lib/dbagile/contract/schema/transaction_driven.rb

@@ -0,0 +1,68 @@
+module DbAgile
+  module Contract
+    module Schema
+      module TransactionDriven
+
+        #
+        # Creates a table with some columns. 
+        #
+        # @param [DbAgile::Core::Transaction] transaction the current transaction
+        # @param [Symbol] table_name the name of a table
+        # @param [Hash] a table heading
+        # @return [Hash] the actual table heading that has been created
+        #
+        # @pre [table_name] the table must not exist
+        #
+        def create_table(transaction, table_name, columns)
+          Kernel.raise NotImplementedError
+        end
+        
+        #
+        # Drops a table
+        #
+        # @param [DbAgile::Core::Transaction] transaction the current transaction
+        # @param [Symbol] table_name the name of a table
+        # @return [Boolean] true to indicate that everything is fine
+        #
+        # @pre [table_name] the table must not exist
+        #
+        def drop_table(transaction, table_name)
+          Kernel.raise NotImplementedError
+        end
+      
+        #
+        # Adds some columns to a table
+        #
+        # @param [DbAgile::Core::Transaction] transaction the current transaction
+        # @param [Symbol] table_name the name of a table
+        # @param [Hash] columns column definitions
+        # @return [Boolean] true to indicate that everything is fine
+        #
+        # @pre [table_name] the table must not exist
+        # @pre [columns] the table may not contain any of the columns
+        # @post the table has gained the additional columns
+        #
+        def add_columns(transaction, table_name, columns)
+          Kernel.raise NotImplementedError
+        end
+      
+        # 
+        # Make columns be a candidate key for the table.
+        #
+        # @param [DbAgile::Core::Transaction] transaction the current transaction
+        # @param [Symbol] table_name the name of a table
+        # @param [Array<Symbol>] columns column names
+        # @return [Boolean] true to indicate that everything is fine
+        #
+        # @pre [table_name] the table must not exist
+        # @pre [columns] the table must have all columns
+        # @post the table has gained the candidate key
+        #
+        def key!(transaction, table_name, columns)
+          Kernel.raise NotImplementedError
+        end
+      
+      end # module TransactionDriven
+    end # module Schema
+  end # module Contract 
+end # module DbAgile

data/lib/dbagile/contract/schema.rb

@@ -0,0 +1,2 @@
+require 'dbagile/contract/schema/table_driven'
+require 'dbagile/contract/schema/transaction_driven'

data/lib/dbagile/contract/utils/delegate.rb

@@ -0,0 +1,17 @@
+module DbAgile
+  module Contract
+    module Utils
+      module Delegate
+      
+        DbAgile::Contract::Utils::Full.instance_methods(true).each do |meth|
+          module_eval <<-EOF
+            def #{meth}(*args, &block)
+              delegate.#{meth}(*args, &block)
+            end
+          EOF
+        end
+    
+      end # module Delegate
+    end # module Utils
+  end # module Contract
+end # module DbAgile

data/lib/dbagile/contract/utils/full.rb

@@ -0,0 +1,13 @@
+module DbAgile
+  module Contract
+    module Utils
+      module Full
+        include DbAgile::Contract::Connection
+        include DbAgile::Contract::Data::TableDriven
+        include DbAgile::Contract::Data::TransactionDriven
+        include DbAgile::Contract::Schema::TableDriven
+        include DbAgile::Contract::Schema::TransactionDriven
+      end # module Full
+    end # module Utils
+  end # module Contract
+end # module DbAgile

data/lib/dbagile/contract/utils.rb

@@ -0,0 +1,2 @@
+require 'dbagile/contract/utils/full'
+require 'dbagile/contract/utils/delegate'

data/lib/dbagile/contract.rb

@@ -0,0 +1,5 @@
+require 'dbagile/contract/connection'
+require 'dbagile/contract/data'
+require 'dbagile/contract/schema'
+require 'dbagile/contract/utils'
+require 'dbagile/contract/robust'

data/lib/dbagile/core/chain.rb

@@ -0,0 +1,92 @@
+require 'delegate'
+require 'enumerator'
+module DbAgile
+  module Core
+    class Chain
+      
+      # A participant in the chain
+      module Participant
+        def __getobj__() @__delegate__ end
+        alias :delegate :__getobj__
+      end
+      
+      # Returns the delegator chain
+      attr_reader :delegate_chain
+      
+      # Creates a chain instance. Shortcut for Chain.new(*args)
+      def self.[](*args)
+        Chain.new(*args)
+      end
+      
+      # Creates an empty chain
+      def initialize(*chain)
+        @delegate_chain = []
+        plug(*chain) unless chain.empty?
+        __install_chain__
+      end
+      
+      # Handles the magic of delegation through \_\_getobj\_\_.
+      def method_missing(m, *args, &block)
+        target = self.__getobj__
+        unless target.respond_to?(m)
+          super
+        end
+        target.__send__(m, *args, &block)
+      end
+
+      # Builds some participants
+      def __build_participants__(args)
+        delegates = []
+        until args.empty?
+          case arg = args.shift
+            when Class
+              mod_args = []
+              until args.empty? or args[0].kind_of?(Module)
+                mod_args << args.shift
+              end
+              delegates << arg.new(*mod_args)
+            else
+              delegates << arg
+          end
+        end
+        delegates
+      end
+      
+      # Installs the chain
+      def __install_chain__
+        delegate_chain.each_cons(2) do |part, its_del|
+          part.extend(Participant)
+          part.instance_eval{ @__delegate__ = its_del }
+        end
+      end
+      
+      # Returns the delegation object
+      def __getobj__
+        delegate_chain.first
+      end
+      
+      # Plugs some chain participants
+      def plug(*args)
+        @delegate_chain = __build_participants__(args) + delegate_chain
+        __install_chain__
+        self
+      end
+      
+      # Returns a connected version of self.
+      def connect(last)
+        chain = delegate_chain + [ last ]
+        Chain.new(*chain)
+      end
+      
+      # Inspects this chain
+      def inspect
+        debug = delegate_chain.collect{|c| 
+          c.kind_of?(Chain) ? c.inspect : c.class.name
+        }.join(', ')
+        "[#{debug}]"
+      end
+      
+      protected :__getobj__
+    end # class Chain
+  end # module Core
+end # module DbAgile

data/lib/dbagile/core/connection.rb

@@ -0,0 +1,51 @@
+module DbAgile
+  module Core
+    class Connection
+    
+      attr_reader :chain
+    
+      # About creation ###############################################################
+    
+      # Creates a database instance with an underlying adapter
+      def initialize(chain)
+        @chain = chain
+      end
+    
+      # About delegate chains ########################################################
+      
+      # Hot plug
+      def plug(*args)
+        @chain.plug(*args)
+      end
+    
+      # Delegated to the chain
+      def inspect
+        @chain.inspect
+      end
+    
+      ### DELEGATE PATTERN ON CONNECTION ################################################
+
+      # 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, &block)
+              @chain.#{method}(*args, &block)  
+            end
+          EOF
+        end
+
+      end
+    
+      # Executes the block inside a transaction.
+      def transaction(&block)
+        raise ArgumentError, "Missing transaction block" unless block
+        Transaction.new(self).execute(&block)
+      end
+      
+    end # class Connection
+  end # module Core
+end # module DbAgile