mack-data_mapper 0.8.1 → 0.8.2

data/lib/gems/dm-core-0.9.7/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/gems/dm-core-0.9.7/lib/dm-core/support/kernel.rb

@@ -0,0 +1,11 @@
+module Kernel
+  # Delegates to DataMapper::repository.
+  # Will not overwrite if a method of the same name is pre-defined.
+  def repository(*args)
+    if block_given?
+      DataMapper.repository(*args) { |*block_args| yield(*block_args) }
+    else
+      DataMapper.repository(*args)
+    end
+  end
+end # module Kernel

data/lib/gems/dm-core-0.9.7/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/gems/dm-core-0.9.7/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/gems/dm-core-0.9.7/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)
+      @transaction_primitives = {}
+      @state = :none
+      @adapters = {}
+      link(*things)
+      commit { |*block_args| yield(*block_args) } 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)
+      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_args| yield(*block_args) } 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
+      if block_given?
+        raise "Illegal state for commit with block: #{@state}" unless @state == :none
+        begin
+          self.begin
+          rval = within { |*block_args| yield(*block_args) }
+          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
+      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/gems/dm-core-0.9.7/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

data/lib/gems/dm-core-0.9.7/lib/dm-core/type_map.rb

@@ -0,0 +1,80 @@
+# TODO: move to dm-more/dm-migrations
+
+module DataMapper
+  class TypeMap
+
+    attr_accessor :parent, :chains
+
+    def initialize(parent = nil, &blk)
+      @parent, @chains = parent, {}
+
+      blk.call(self) unless blk.nil?
+    end
+
+    def map(type)
+      @chains[type] ||= TypeChain.new
+    end
+
+    def lookup(type)
+      if type_mapped?(type)
+        lookup_from_map(type)
+      else
+        lookup_by_type(type)
+      end
+    end
+
+    def lookup_from_map(type)
+      lookup_from_parent(type).merge(map(type).translate)
+    end
+
+    def lookup_from_parent(type)
+      if !@parent.nil? && @parent.type_mapped?(type)
+        @parent[type]
+      else
+        {}
+      end
+    end
+
+    # @raise <DataMapper::TypeMap::Error> if the type is not a default primitive or has a type map entry.
+    def lookup_by_type(type)
+      raise DataMapper::TypeMap::Error.new(type) unless type.respond_to?(:primitive) && !type.primitive.nil?
+
+      lookup(type.primitive).merge(Type::PROPERTY_OPTIONS.inject({}) {|h, k| h[k] = type.send(k); h})
+    end
+
+    alias [] lookup
+
+    def type_mapped?(type)
+      @chains.has_key?(type) || (@parent.nil? ? false : @parent.type_mapped?(type))
+    end
+
+    class TypeChain
+      attr_accessor :primitive, :attributes
+
+      def initialize
+        @attributes = {}
+      end
+
+      def to(primitive)
+        @primitive = primitive
+        self
+      end
+
+      def with(attributes)
+        raise "method 'with' expects a hash" unless attributes.kind_of?(Hash)
+        @attributes.merge!(attributes)
+        self
+      end
+
+      def translate
+        @attributes.merge((@primitive.nil? ? {} : {:primitive => @primitive}))
+      end
+    end # class TypeChain
+
+    class Error < StandardError
+      def initialize(type)
+        super("Type #{type} must have a default primitive or type map entry")
+      end
+    end
+  end # class TypeMap
+end # module DataMapper

data/lib/gems/dm-core-0.9.7/lib/dm-core/types/boolean.rb

@@ -0,0 +1,7 @@
+module DataMapper
+  module Types
+    class Boolean < DataMapper::Type
+      primitive TrueClass
+    end # class Boolean
+  end # module Types
+end # module DataMapper

data/lib/gems/dm-core-0.9.7/lib/dm-core/types/discriminator.rb

@@ -0,0 +1,34 @@
+module DataMapper
+  module Types
+    class Discriminator < DataMapper::Type
+      primitive Class
+      track :set
+      default lambda { |r,p| p.model }
+      nullable false
+
+      def self.bind(property)
+        model = property.model
+
+        model.class_eval <<-EOS, __FILE__, __LINE__
+          def self.descendants
+            (@descendants ||= []).uniq!
+            @descendants
+          end
+
+          after_class_method :inherited, :add_scope_for_discriminator
+
+          def self.add_scope_for_discriminator(retval, target)
+            target.descendants << target
+            target.default_scope.update(#{property.name.inspect} => target.descendants)
+            propagate_descendants(target)
+          end
+
+          def self.propagate_descendants(target)
+            descendants << target
+            superclass.propagate_descendants(target) if superclass.respond_to?(:propagate_descendants)
+          end
+        EOS
+      end
+    end # class Discriminator
+  end # module Types
+end # module DataMapper

data/lib/gems/dm-core-0.9.7/lib/dm-core/types/object.rb

@@ -0,0 +1,24 @@
+require "base64"
+
+module DataMapper
+  module Types
+    class Object < DataMapper::Type
+      primitive String
+      size 65535
+      lazy true
+      track :hash
+
+      def self.typecast(value, property)
+        value
+      end
+
+      def self.dump(value, property)
+        Base64.encode64(Marshal.dump(value))
+      end
+
+      def self.load(value, property)
+        value.nil? ? nil : Marshal.load(Base64.decode64(value))
+      end
+    end
+  end
+end

data/lib/gems/dm-core-0.9.7/lib/dm-core/types/paranoid_boolean.rb

@@ -0,0 +1,34 @@
+module DataMapper
+  module Types
+    class ParanoidBoolean < DataMapper::Type(Boolean)
+      primitive TrueClass
+      default   false
+      lazy      true
+
+      def self.bind(property)
+        model = property.model
+        repository = property.repository
+
+        model.send(:set_paranoid_property, property.name){true}
+
+        model.class_eval <<-EOS, __FILE__, __LINE__
+
+          def self.with_deleted
+            with_exclusive_scope(#{property.name.inspect} => true) do
+              yield
+            end
+          end
+
+          def destroy
+            self.class.paranoid_properties.each do |name, blk|
+              attribute_set(name, blk.call(self))
+            end
+            save
+          end
+        EOS
+
+        model.default_scope(repository.name).update(property.name => false)
+      end
+    end # class ParanoidBoolean
+  end # module Types
+end # module DataMapper