sam-dm-core 0.9.6

data/lib/dm-core/scope.rb

@@ -0,0 +1,58 @@
+module DataMapper
+  module Scope
+    Model.append_extensions self
+
+    # @api private
+    def default_scope(repository_name = nil)
+      repository_name = self.default_repository_name if repository_name == :default || repository_name.nil?
+      @default_scope ||= Hash.new{|h,k| h[k] = {}}
+      @default_scope[repository_name]
+    end
+
+    # @api private
+    def query
+      scope_stack.last
+    end
+
+    protected
+
+    # @api semipublic
+    def with_scope(query, &block)
+      # merge the current scope with the passed in query
+      with_exclusive_scope(self.query ? self.query.merge(query) : query, &block)
+    end
+
+    # @api semipublic
+    def with_exclusive_scope(query, &block)
+      query = DataMapper::Query.new(repository, self, query) if query.kind_of?(Hash)
+
+      scope_stack << query
+
+      begin
+        return yield(query)
+      ensure
+        scope_stack.pop
+      end
+    end
+
+    private
+
+    # @api private
+    def merge_with_default_scope(query)
+      DataMapper::Query.new(query.repository, query.model, default_scope_for_query(query)).update(query)
+    end
+
+    # @api private
+    def scope_stack
+      scope_stack_for = Thread.current[:dm_scope_stack] ||= Hash.new { |h,model| h[model] = [] }
+      scope_stack_for[self]
+    end
+
+    # @api private
+    def default_scope_for_query(query)
+      repository_name = query.repository.name
+      default_repository_name = query.model.default_repository_name
+      self.default_scope(default_repository_name).merge(self.default_scope(repository_name))
+    end
+  end # module Scope
+end # module DataMapper

data/lib/dm-core/support.rb

@@ -0,0 +1,7 @@
+dir = Pathname(__FILE__).dirname.expand_path / 'support'
+
+require dir / 'array'
+require dir / 'assertions'
+require dir / 'errors'
+require dir / 'kernel'
+require dir / 'symbol'

data/lib/dm-core/support/array.rb

@@ -0,0 +1,13 @@
+class Array
+
+  ##
+  # atm it assumes self is an array of [key,value]-arrays
+  # this is just a better way to make hashes than Hash[*array.flatten]
+  # since you cannot flatten only one level in ruby 1.8.6
+  #
+  def to_hash
+    h = {}
+    self.each{ |k,v| h[k] = v }
+    h
+  end
+end # class Symbol

data/lib/dm-core/support/assertions.rb

@@ -0,0 +1,8 @@
+module DataMapper
+  module Assertions
+    def assert_kind_of(name, value, *klasses)
+      klasses.each { |k| return if value.kind_of?(k) }
+      raise ArgumentError, "+#{name}+ should be #{klasses.map { |k| k.name } * ' or '}, but was #{value.class.name}", caller(2)
+    end
+  end
+end # module DataMapper

data/lib/dm-core/support/errors.rb

@@ -0,0 +1,23 @@
+#Some useful errors types
+module DataMapper
+  class ValidationError < StandardError; end
+
+  class ObjectNotFoundError < StandardError; end
+
+  class MaterializationError < StandardError; end
+
+  class RepositoryNotSetupError < StandardError; end
+
+  class IncompleteResourceError < StandardError; end
+
+  class PersistenceError < StandardError; end
+
+  class PluginNotFoundError < StandardError; end
+end # module DataMapper
+
+class StandardError
+  # Displays the specific error message and the backtrace associated with it.
+  def display
+    "#{message}\n\t#{backtrace.join("\n\t")}"
+  end
+end # class StandardError

data/lib/dm-core/support/kernel.rb

@@ -0,0 +1,7 @@
+module Kernel
+  # Delegates to DataMapper::repository.
+  # Will not overwrite if a method of the same name is pre-defined.
+  def repository(*args, &block)
+    DataMapper.repository(*args, &block)
+  end
+end # module Kernel

data/lib/dm-core/support/symbol.rb

@@ -0,0 +1,41 @@
+class Symbol
+  def gt
+    DataMapper::Query::Operator.new(self, :gt)
+  end
+
+  def gte
+    DataMapper::Query::Operator.new(self, :gte)
+  end
+
+  def lt
+    DataMapper::Query::Operator.new(self, :lt)
+  end
+
+  def lte
+    DataMapper::Query::Operator.new(self, :lte)
+  end
+
+  def not
+    DataMapper::Query::Operator.new(self, :not)
+  end
+
+  def eql
+    DataMapper::Query::Operator.new(self, :eql)
+  end
+
+  def like
+    DataMapper::Query::Operator.new(self, :like)
+  end
+
+  def in
+    DataMapper::Query::Operator.new(self, :in)
+  end
+
+  def asc
+    DataMapper::Query::Operator.new(self, :asc)
+  end
+
+  def desc
+    DataMapper::Query::Operator.new(self, :desc)
+  end
+end # class Symbol

data/lib/dm-core/transaction.rb

@@ -0,0 +1,267 @@
+# TODO: move to dm-more/dm-transactions
+
+module DataMapper
+  class Transaction
+
+    attr_reader :transaction_primitives, :adapters, :state
+
+    #
+    # Create a new DataMapper::Transaction
+    #
+    # @see DataMapper::Transaction#link
+    #
+    # In fact, it just calls #link with the given arguments at the end of the
+    # constructor.
+    #
+    def initialize(*things, &block)
+      @transaction_primitives = {}
+      @state = :none
+      @adapters = {}
+      link(*things)
+      commit(&block) if block_given?
+    end
+
+    #
+    # Associate this Transaction with some things.
+    #
+    # @param things<any number of Object>  the things you want this Transaction
+    #   associated with
+    # @details [things a Transaction may be associatied with]
+    #   DataMapper::Adapters::AbstractAdapter subclasses will be added as
+    #     adapters as is.
+    #   Arrays will have their elements added.
+    #   DataMapper::Repositories will have their @adapters added.
+    #   DataMapper::Resource subclasses will have all the repositories of all
+    #     their properties added.
+    #   DataMapper::Resource instances will have all repositories of all their
+    #     properties added.
+    # @param block<Block> a block (taking one argument, the Transaction) to execute
+    #   within this transaction. The transaction will begin and commit around
+    #   the block, and rollback if an exception is raised.
+    #
+    def link(*things, &block)
+      raise "Illegal state for link: #{@state}" unless @state == :none
+      things.each do |thing|
+        if thing.is_a?(Array)
+          link(*thing)
+        elsif thing.is_a?(DataMapper::Adapters::AbstractAdapter)
+          @adapters[thing] = :none
+        elsif thing.is_a?(DataMapper::Repository)
+          link(thing.adapter)
+        elsif thing.is_a?(Class) && thing.ancestors.include?(DataMapper::Resource)
+          link(*thing.repositories)
+        elsif thing.is_a?(DataMapper::Resource)
+          link(thing.model)
+        else
+          raise "Unknown argument to #{self}#link: #{thing.inspect}"
+        end
+      end
+      return commit(&block) if block_given?
+      return self
+    end
+
+    #
+    # Begin the transaction
+    #
+    # Before #begin is called, the transaction is not valid and can not be used.
+    #
+    def begin
+      raise "Illegal state for begin: #{@state}" unless @state == :none
+      each_adapter(:connect_adapter, [:log_fatal_transaction_breakage])
+      each_adapter(:begin_adapter, [:rollback_and_close_adapter_if_begin, :close_adapter_if_none])
+      @state = :begin
+    end
+
+    #
+    # Commit the transaction
+    #
+    # @param block<Block>   a block (taking the one argument, the Transaction) to
+    #   execute within this transaction. The transaction will begin and commit
+    #   around the block, and roll back if an exception is raised.
+    #
+    # @note
+    #   If no block is given, it will simply commit any changes made since the
+    #   Transaction did #begin.
+    #
+    def commit(&block)
+      if block_given?
+        raise "Illegal state for commit with block: #{@state}" unless @state == :none
+        begin
+          self.begin
+          rval = within(&block)
+          self.commit if @state == :begin
+          return rval
+        rescue Exception => e
+          self.rollback if @state == :begin
+          raise e
+        end
+      else
+        raise "Illegal state for commit without block: #{@state}" unless @state == :begin
+        each_adapter(:prepare_adapter, [:rollback_and_close_adapter_if_begin, :rollback_prepared_and_close_adapter_if_prepare])
+        each_adapter(:commit_adapter, [:log_fatal_transaction_breakage])
+        each_adapter(:close_adapter, [:log_fatal_transaction_breakage])
+        @state = :commit
+      end
+    end
+
+    #
+    # Rollback the transaction
+    #
+    # Will undo all changes made during the transaction.
+    #
+    def rollback
+      raise "Illegal state for rollback: #{@state}" unless @state == :begin
+      each_adapter(:rollback_adapter_if_begin, [:rollback_and_close_adapter_if_begin, :close_adapter_if_none])
+      each_adapter(:rollback_prepared_adapter_if_prepare, [:rollback_prepared_and_close_adapter_if_begin, :close_adapter_if_none])
+      each_adapter(:close_adapter_if_open, [:log_fatal_transaction_breakage])
+      @state = :rollback
+    end
+
+    #
+    # Execute a block within this Transaction.
+    #
+    # @param block<Block> the block of code to execute.
+    #
+    # @note
+    #   No #begin, #commit or #rollback is performed in #within, but this
+    #   Transaction will pushed on the per thread stack of transactions for each
+    #   adapter it is associated with, and it will ensures that it will pop the
+    #   Transaction away again after the block is finished.
+    #
+    def within(&block)
+      raise "No block provided" unless block_given?
+      raise "Illegal state for within: #{@state}" unless @state == :begin
+      @adapters.each do |adapter, state|
+        adapter.push_transaction(self)
+      end
+      begin
+        return yield(self)
+      ensure
+        @adapters.each do |adapter, state|
+          adapter.pop_transaction
+        end
+      end
+    end
+
+    def method_missing(meth, *args, &block)
+      if args.size == 1 && args.first.is_a?(DataMapper::Adapters::AbstractAdapter)
+        if (match = meth.to_s.match(/^(.*)_if_(none|begin|prepare|rollback|commit)$/))
+          if self.respond_to?(match[1], true)
+            self.send(match[1], args.first) if state_for(args.first).to_s == match[2]
+          else
+            super
+          end
+        elsif (match = meth.to_s.match(/^(.*)_unless_(none|begin|prepare|rollback|commit)$/))
+          if self.respond_to?(match[1], true)
+            self.send(match[1], args.first) unless state_for(args.first).to_s == match[2]
+          else
+            super
+          end
+        else
+          super
+        end
+      else
+        super
+      end
+    end
+
+    def primitive_for(adapter)
+      raise "Unknown adapter #{adapter}" unless @adapters.include?(adapter)
+      raise "No primitive for #{adapter}" unless @transaction_primitives.include?(adapter)
+      @transaction_primitives[adapter]
+    end
+
+    private
+
+    def validate_primitive(primitive)
+      [:close, :begin, :prepare, :rollback, :rollback_prepared, :commit].each do |meth|
+        raise "Invalid primitive #{primitive}: doesnt respond_to?(#{meth.inspect})" unless primitive.respond_to?(meth)
+      end
+      return primitive
+    end
+
+    def each_adapter(method, on_fail)
+      begin
+        @adapters.each do |adapter, state|
+          self.send(method, adapter)
+        end
+      rescue Exception => e
+        @adapters.each do |adapter, state|
+          on_fail.each do |fail_handler|
+            begin
+              self.send(fail_handler, adapter)
+            rescue Exception => e2
+              DataMapper.logger.fatal("#{self}#each_adapter(#{method.inspect}, #{on_fail.inspect}) failed with #{e.inspect}: #{e.backtrace.join("\n")} - and when sending #{fail_handler} to #{adapter} we failed again with #{e2.inspect}: #{e2.backtrace.join("\n")}")
+            end
+          end
+        end
+        raise e
+      end
+    end
+
+    def state_for(adapter)
+      raise "Unknown adapter #{adapter}" unless @adapters.include?(adapter)
+      @adapters[adapter]
+    end
+
+    def do_adapter(adapter, what, prerequisite)
+      raise "No primitive for #{adapter}" unless @transaction_primitives.include?(adapter)
+      raise "Illegal state for #{what}: #{state_for(adapter)}" unless state_for(adapter) == prerequisite
+      DataMapper.logger.debug("#{adapter.name}: #{what}")
+      @transaction_primitives[adapter].send(what)
+      @adapters[adapter] = what
+    end
+
+    def log_fatal_transaction_breakage(adapter)
+      DataMapper.logger.fatal("#{self} experienced a totally broken transaction execution. Presenting member #{adapter.inspect}.")
+    end
+
+    def connect_adapter(adapter)
+      raise "Already a primitive for adapter #{adapter}" unless @transaction_primitives[adapter].nil?
+      @transaction_primitives[adapter] = validate_primitive(adapter.transaction_primitive)
+    end
+
+    def close_adapter_if_open(adapter)
+      if @transaction_primitives.include?(adapter)
+        close_adapter(adapter)
+      end
+    end
+
+    def close_adapter(adapter)
+      raise "No primitive for adapter" unless @transaction_primitives.include?(adapter)
+      @transaction_primitives[adapter].close
+      @transaction_primitives.delete(adapter)
+    end
+
+    def begin_adapter(adapter)
+      do_adapter(adapter, :begin, :none)
+    end
+
+    def prepare_adapter(adapter)
+      do_adapter(adapter, :prepare, :begin);
+    end
+
+    def commit_adapter(adapter)
+      do_adapter(adapter, :commit, :prepare)
+    end
+
+    def rollback_adapter(adapter)
+      do_adapter(adapter, :rollback, :begin)
+    end
+
+    def rollback_prepared_adapter(adapter)
+      do_adapter(adapter, :rollback_prepared, :prepare)
+    end
+
+    def rollback_prepared_and_close_adapter(adapter)
+      rollback_prepared_adapter(adapter)
+      close_adapter(adapter)
+    end
+
+    def rollback_and_close_adapter(adapter)
+      rollback_adapter(adapter)
+      close_adapter(adapter)
+    end
+
+  end # class Transaction
+end # module DataMapper

data/lib/dm-core/type.rb

@@ -0,0 +1,160 @@
+module DataMapper
+
+  # = Types
+  # Provides means of writing custom types for properties. Each type is based
+  # on a ruby primitive and handles its own serialization and materialization,
+  # and therefore is responsible for providing those methods.
+  #
+  # To see complete list of supported types, see documentation for
+  # DataMapper::Property::TYPES
+  #
+  # == Defining new Types
+  # To define a new type, subclass DataMapper::Type, pick ruby primitive, and
+  # set the options for this type.
+  #
+  #   class MyType < DataMapper::Type
+  #     primitive String
+  #     size 10
+  #   end
+  #
+  # Following this, you will be able to use MyType as a type for any given
+  # property. If special materialization and serialization is required,
+  # override the class methods
+  #
+  #   class MyType < DataMapper::Type
+  #     primitive String
+  #     size 10
+  #
+  #     def self.dump(value, property)
+  #       <work some magic>
+  #     end
+  #
+  #     def self.load(value)
+  #       <work some magic>
+  #     end
+  #   end
+  class Type
+    PROPERTY_OPTIONS = [
+      :accessor, :reader, :writer,
+      :lazy, :default, :nullable, :key, :serial, :field, :size, :length,
+      :format, :index, :unique_index, :check, :ordinal, :auto_validation,
+      :validates, :unique, :track, :precision, :scale
+    ]
+
+    PROPERTY_OPTION_ALIASES = {
+      :size => [ :length ]
+    }
+
+    class << self
+
+      def configure(primitive_type, options)
+        @_primitive_type = primitive_type
+        @_options = options
+
+        def self.inherited(base)
+          base.primitive @_primitive_type
+
+          @_options.each do |k, v|
+            base.send(k, v)
+          end
+        end
+
+        self
+      end
+
+      # The Ruby primitive type to use as basis for this type. See
+      # DataMapper::Property::TYPES for list of types.
+      #
+      # @param primitive<Class, nil>
+      #   The class for the primitive. If nil is passed in, it returns the
+      #   current primitive
+      #
+      # @return <Class> if the <primitive> param is nil, return the current primitive.
+      #
+      # @api public
+      def primitive(primitive = nil)
+        return @primitive if primitive.nil?
+
+        # TODO: change Integer to be used internally once most in-the-wild code
+        # is updated to use Integer for properties instead of Fixnum, or before
+        # DM 1.0, whichever comes first
+        if Fixnum == primitive
+          warn "#{primitive} properties are deprecated.  Please use Integer instead"
+          primitive = Integer
+        end
+
+        @primitive = primitive
+      end
+
+      # Load DataMapper::Property options
+      PROPERTY_OPTIONS.each do |property_option|
+        self.class_eval <<-EOS, __FILE__, __LINE__
+          def #{property_option}(arg = nil)
+            return @#{property_option} if arg.nil?
+
+            @#{property_option} = arg
+          end
+        EOS
+      end
+
+      # Create property aliases
+      PROPERTY_OPTION_ALIASES.each do |property_option, aliases|
+        aliases.each do |ali|
+          self.class_eval <<-EOS, __FILE__, __LINE__
+            alias #{ali} #{property_option}
+          EOS
+        end
+      end
+
+      # Gives all the options set on this type
+      #
+      # @return <Hash> with all options and their values set on this type
+      #
+      # @api public
+      def options
+        options = {}
+        PROPERTY_OPTIONS.each do |method|
+          next if (value = send(method)).nil?
+          options[method] = value
+        end
+        options
+      end
+    end
+
+    # Stub instance method for dumping
+    #
+    # @param value<Object, nil>       the value to dump
+    # @param property<Property, nil>  the property the type is being used by
+    #
+    # @return <Object> Dumped object
+    #
+    # @api public
+    def self.dump(value, property)
+      value
+    end
+
+    # Stub instance method for loading
+    #
+    # @param value<Object, nil>       the value to serialize
+    # @param property<Property, nil>  the property the type is being used by
+    #
+    # @return <Object> Serialized object. Must be the same type as the Ruby primitive
+    #
+    # @api public
+    def self.load(value, property)
+      value
+    end
+
+    def self.bind(property)
+      # This method should not modify the state of this type class, and
+      # should produce no side-effects on the type class. It's just a
+      # hook to allow your custom-type to modify the property it's bound to.
+    end
+
+  end # class Type
+
+  def self.Type(primitive_type, options = {})
+    Class.new(Type).configure(primitive_type, options)
+  end
+
+end # module DataMapper