ghost_dm-core 1.3.0.beta

data/lib/dm-core/query/direction.rb

@@ -0,0 +1,36 @@
+# TODO: rename this DM::Symbol::Direction
+
+# TODO: add a method to convert it into a DM::Query::Sort object, eg:
+#   operator.sort_for(model)
+
+# TODO: rename #target to #property_name
+
+# TODO: make sure Query converts this into a DM::Query::Sort object
+#   immediately and passes that down to the Adapter
+
+# TODO: remove #get method
+
+module DataMapper
+  class Query
+    class Direction < Operator
+
+      # @api private
+      def reverse!
+        @operator = @operator == :asc ? :desc : :asc
+        self
+      end
+
+      # @api private
+      def get(resource)
+        Sort.new(target.get(resource), @operator == :asc)
+      end
+
+      private
+
+      # @api private
+      def initialize(target, operator = :asc)
+        super
+      end
+    end # class Direction
+  end # class Query
+end # module DataMapper

data/lib/dm-core/query/operator.rb

@@ -0,0 +1,35 @@
+# TODO: rename this DM::Symbol::Operator
+
+# TODO: add a method to convert it into a DM::Query::AbstractComparison object, eg:
+#   operator.comparison_for(repository, model)
+
+# TODO: rename #target to #property_name
+
+module DataMapper
+  class Query
+    class Operator
+      include DataMapper::Assertions
+      extend Equalizer
+
+      equalize :target, :operator
+
+      # @api private
+      attr_reader :target
+
+      # @api private
+      attr_reader :operator
+
+      # @api private
+      def inspect
+        "#<#{self.class.name} @target=#{target.inspect} @operator=#{operator.inspect}>"
+      end
+
+      private
+
+      # @api private
+      def initialize(target, operator)
+        @target, @operator = target, operator.to_sym
+      end
+    end # class Operator
+  end # class Query
+end # module DataMapper

data/lib/dm-core/query/path.rb

@@ -0,0 +1,114 @@
+# TODO: instead of an Array of Path objects, create a Relationship
+# on the fly using :through on the previous relationship, creating a
+# chain.  Query::Path could then be a thin wrapper that specifies extra
+# conditions on the Relationships, like the target property o match
+# on.
+
+module DataMapper
+  class Query
+    class Path
+      # TODO: replace this with BasicObject
+      instance_methods.each do |method|
+        next if method =~ /\A__/ ||
+          %w[ send class dup object_id kind_of? instance_of? respond_to? respond_to_missing? equal? freeze frozen? should should_not instance_variables instance_variable_set instance_variable_get instance_variable_defined? remove_instance_variable extend hash inspect to_s copy_object initialize_dup ].include?(method.to_s)
+        undef_method method
+      end
+
+      include DataMapper::Assertions
+      extend Equalizer
+
+      equalize :relationships, :property
+
+      # @api semipublic
+      attr_reader :repository_name
+
+      # @api semipublic
+      attr_reader :relationships
+
+      # @api semipublic
+      attr_reader :model
+
+      # @api semipublic
+      attr_reader :property
+
+      (Conditions::Comparison.slugs | [ :not ]).each do |slug|
+        class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{slug}                                                                                                      # def eql
+            #{"raise \"explicit use of '#{slug}' operator is deprecated (#{caller.first})\"" if slug == :eql || slug == :in}  #   raise "explicit use of 'eql' operator is deprecated (#{caller.first})"
+            Operator.new(self, #{slug.inspect})                                                                            #   Operator.new(self, :eql)
+          end                                                                                                              # end
+        RUBY
+      end
+
+      # @api public
+      def kind_of?(klass)
+        super || (defined?(@property) ? @property.kind_of?(klass) : false)
+      end
+
+      # @api public
+      def instance_of?(klass)
+        super || (defined?(@property) ? @property.instance_of?(klass) : false)
+      end
+
+      # Used for creating :order options. This technique may be deprecated,
+      # so marking as semipublic until the issue is resolved.
+      #
+      # @api semipublic
+      def asc
+        Operator.new(property, :asc)
+      end
+
+      # Used for creating :order options. This technique may be deprecated,
+      # so marking as semipublic until the issue is resolved.
+      #
+      # @api semipublic
+      def desc
+        Operator.new(property, :desc)
+      end
+
+      # @api semipublic
+      def respond_to?(method, include_private = false)
+        super                                                                   ||
+        (defined?(@property) && @property.respond_to?(method, include_private)) ||
+        @model.relationships(@repository_name).named?(method)                   ||
+        @model.properties(@repository_name).named?(method)
+      end
+
+      private
+
+      # @api semipublic
+      def initialize(relationships, property_name = nil)
+        @relationships = relationships.to_ary.dup
+
+        last_relationship = @relationships.last
+        @repository_name  = last_relationship.relative_target_repository_name
+        @model            = last_relationship.target_model
+
+        if property_name
+          property_name = property_name.to_sym
+          @property = @model.properties(@repository_name)[property_name] ||
+            raise(ArgumentError, "Unknown property '#{property_name}' in #{@model}")
+        end
+      end
+
+      # @api semipublic
+      def method_missing(method, *args)
+        if @property
+          return @property.send(method, *args)
+        end
+
+        path_class = self.class
+
+        if relationship = @model.relationships(@repository_name)[method]
+          return path_class.new(@relationships.dup << relationship)
+        end
+
+        if @model.properties(@repository_name).named?(method)
+          return path_class.new(@relationships, method)
+        end
+
+        raise NoMethodError, "undefined property or relationship '#{method}' on #{@model}"
+      end
+    end # class Path
+  end # class Query
+end # module DataMapper

data/lib/dm-core/query/sort.rb

@@ -0,0 +1,39 @@
+# TODO: add #reverse and #reverse! methods
+
+module DataMapper
+  class Query
+    class Sort
+      # @api semipublic
+      attr_reader :value
+
+      # @api semipublic
+      def direction
+        @ascending ? :ascending : :descending
+      end
+
+      # @api private
+      def <=>(other)
+        other_value = other.value
+        value_nil   = @value.nil?
+        other_nil   = other_value.nil?
+
+        cmp = case
+          when value_nil then other_nil ? 0 : 1
+          when other_nil then -1
+          else
+            @value <=> other_value
+        end
+
+        @ascending ? cmp : cmp * -1
+      end
+
+      private
+
+      # @api private
+      def initialize(value, ascending = true)
+        @value     = value
+        @ascending = ascending
+      end
+    end # class Sort
+  end # class Query
+end # module DataMapper

data/lib/dm-core/relationship_set.rb

@@ -0,0 +1,72 @@
+module DataMapper
+
+  # A {SubjectSet} that keeps track of relationships defined in a {Model}
+  #
+  class RelationshipSet < SubjectSet
+
+    # A list of all relationships in this set
+    #
+    # @deprecated use DataMapper::RelationshipSet#each or DataMapper::RelationshipSet#to_a instead
+    #
+    # @return [Array]
+    #    a list of all relationships in the set
+    #
+    # @api semipublic
+    def values
+      warn "#{self.class}#values is deprecated. Use #{self.class}#each or #{self.class}#to_a instead: #{caller.first}"
+      to_a
+    end
+
+    # A list of all relationships in this set
+    #
+    # @deprecated use DataMapper::RelationshipSet#each instead
+    #
+    # @yield [DataMapper::Associations::Relationship]
+    #    all relationships in the set
+    #
+    # @yieldparam [DataMapper::Associations::Relationship] relationship
+    #    a relationship in the set
+    #
+    # @return [RelationshipSet] self
+    #
+    # @api semipublic
+    def each_value
+      warn "#{self.class}#each_value is deprecated. Use #{self.class}#each instead: #{caller.first}"
+      each { |relationship| yield(relationship) }
+      self
+    end
+
+    # Check wether this RelationshipSet includes an entry with the given name
+    #
+    # @deprecated use DataMapper::RelationshipSet#named? instead
+    #
+    # @param [#to_s] name
+    #   the name of the entry to look for
+    #
+    # @return [Boolean]
+    #   true if the set contains a relationship with the given name
+    #
+    # @api semipublic
+    def key?(name)
+      warn "#{self.class}#key? is deprecated. Use #{self.class}#named? instead: #{caller.first}"
+      named?(name)
+    end
+
+    # Check wether this RelationshipSet includes an entry with the given name
+    #
+    # @deprecated use DataMapper::RelationshipSet#named? instead
+    #
+    # @param [#to_s] name
+    #   the name of the entry to look for
+    #
+    # @return [Boolean]
+    #   true if the set contains a relationship with the given name
+    #
+    # @api semipublic
+    def has_key?(name)
+      warn "#{self.class}#has_key? is deprecated. Use #{self.class}#named? instead: #{caller.first}"
+      named?(name)
+    end
+
+  end # class RelationshipSet
+end # module DataMapper

data/lib/dm-core/repository.rb

@@ -0,0 +1,226 @@
+module DataMapper
+  class Repository
+    include DataMapper::Assertions
+    extend Equalizer
+
+    equalize :name
+
+    # Get the list of adapters registered for all Repositories,
+    # keyed by repository name.
+    #
+    #   TODO: create example
+    #
+    # @return [Hash(Symbol => Adapters::AbstractAdapter)]
+    #   the adapters registered for all Repositories
+    #
+    # @api private
+    def self.adapters
+      @adapters ||= {}
+    end
+
+    # Get the stack of current repository contexts
+    #
+    #   TODO: create example
+    #
+    # @return [Array]
+    #   List of Repository contexts for the current Thread
+    #
+    # @api private
+    def self.context
+      Thread.current[:dm_repository_contexts] ||= []
+    end
+
+    # Get the default name of this Repository
+    #
+    #   TODO: create example
+    #
+    # @return [Symbol]
+    #   the default name of this repository
+    #
+    # @api private
+    def self.default_name
+      :default
+    end
+
+    # @api semipublic
+    attr_reader :name
+
+    # @api semipublic
+    alias_method :to_sym, :name
+
+    # Get the adapter for this repository
+    #
+    # Lazy loads adapter setup from registered adapters
+    #
+    #   TODO: create example
+    #
+    # @return [Adapters::AbstractAdapter]
+    #   the adapter for this repository
+    #
+    # @raise [RepositoryNotSetupError]
+    #   if there is no adapter registered for a repository named @name
+    #
+    # @api semipublic
+    def adapter
+      # Make adapter instantiation lazy so we can defer repository setup until it's actually
+      # needed. Do not remove this code.
+      @adapter ||=
+        begin
+          adapters = self.class.adapters
+
+          unless adapters.key?(@name)
+            raise RepositoryNotSetupError, "Adapter not set: #{@name}. Did you forget to setup?"
+          end
+
+          adapters[@name]
+        end
+    end
+
+    # Get the identity for a particular model within this repository.
+    #
+    # If one doesn't yet exist, create a new default in-memory IdentityMap
+    # for the requested model.
+    #
+    #   TODO: create example
+    #
+    # @param [Model] model
+    #   Model whose identity map should be returned
+    #
+    # @return [IdentityMap]
+    #   The IdentityMap for model in this Repository
+    #
+    # @api private
+    def identity_map(model)
+      @identity_maps[model.base_model] ||= IdentityMap.new
+    end
+
+    # Executes a block in the scope of this Repository
+    #
+    #   TODO: create example
+    #
+    # @yieldparam [Repository] repository
+    #   yields self within the block
+    #
+    # @yield
+    #   execute block in the scope of this Repository
+    #
+    # @api private
+    def scope
+      context = Repository.context
+
+      context << self
+
+      begin
+        yield self
+      ensure
+        context.pop
+      end
+    end
+
+    # Create a Query or subclass instance for this repository.
+    #
+    # @param [Model] model
+    #   the Model to retrieve results from
+    # @param [Hash] options
+    #   the conditions and scope
+    #
+    # @return [Query]
+    #
+    # @api semipublic
+    def new_query(model, options = {})
+      adapter.new_query(self, model, options)
+    end
+
+    # Create one or more resource instances in this repository.
+    #
+    #   TODO: create example
+    #
+    # @param [Enumerable(Resource)] resources
+    #   The list of resources (model instances) to create
+    #
+    # @return [Integer]
+    #   The number of records that were actually saved into the data-store
+    #
+    # @api semipublic
+    def create(resources)
+      adapter.create(resources)
+    end
+
+    # Retrieve a collection of results of a query
+    #
+    #   TODO: create example
+    #
+    # @param [Query] query
+    #   composition of the query to perform
+    #
+    # @return [Array]
+    #   result set of the query
+    #
+    # @api semipublic
+    def read(query)
+      return [] unless query.valid?
+      query.model.load(adapter.read(query), query)
+    end
+
+    # Update the attributes of one or more resource instances
+    #
+    #   TODO: create example
+    #
+    # @param [Hash(Property => Object)] attributes
+    #   hash of attribute values to set, keyed by Property
+    # @param [Collection] collection
+    #   collection of records to be updated
+    #
+    # @return [Integer]
+    #   the number of records updated
+    #
+    # @api semipublic
+    def update(attributes, collection)
+      return 0 unless collection.query.valid? && attributes.any?
+      adapter.update(attributes, collection)
+    end
+
+    # Delete one or more resource instances
+    #
+    #   TODO: create example
+    #
+    # @param [Collection] collection
+    #   collection of records to be deleted
+    #
+    # @return [Integer]
+    #   the number of records deleted
+    #
+    # @api semipublic
+    def delete(collection)
+      return 0 unless collection.query.valid?
+      adapter.delete(collection)
+    end
+
+    # Return a human readable representation of the repository
+    #
+    #   TODO: create example
+    #
+    # @return [String]
+    #   human readable representation of the repository
+    #
+    # @api private
+    def inspect
+      "#<#{self.class.name} @name=#{@name}>"
+    end
+
+    private
+
+    # Initializes a new Repository
+    #
+    #   TODO: create example
+    #
+    # @param [Symbol] name
+    #   The name of the Repository
+    #
+    # @api semipublic
+    def initialize(name)
+      @name          = name.to_sym
+      @identity_maps = {}
+    end
+  end # class Repository
+end # module DataMapper