sbf-dm-core 1.3.0.beta

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

@@ -0,0 +1,251 @@
+module DataMapper
+
+  # An insertion ordered set of named objects
+  #
+  # {SubjectSet} uses {DataMapper::OrderedSet}
+  # under the hood to keep track of a set of
+  # entries. In DataMapper code, a subject
+  # can be either a {DataMapper::Property}, or
+  # a {DataMapper::Associations::Relationship}.
+  #
+  # All entries added to instances of this
+  # class must respond to the {#name} method
+  #
+  # The motivation behind this is that we
+  # use this class as a base to keep track
+  # properties and relationships.
+  # The following constraints apply for these
+  # types of objects: {Property} names must be
+  # unique within any model.
+  # {Associations::Relationship} names must be
+  # unique within any model
+  #
+  # When adding an entry with a name that
+  # already exists, the already existing
+  # entry will be replaced with the new
+  # entry with the same name. This is because
+  # we want to be able to update properties,
+  # and relationship during the course of
+  # initializing our application.
+  #
+  # This also happens to be consistent with
+  # the way ruby handles redefining methods,
+  # where the last definitions "wins".
+  #
+  # Furthermore, the builtin ruby {Set#<<} method
+  # also updates the old object if a new object
+  # gets added.
+  #
+  # @api private
+  class SubjectSet
+
+    # An {OrderedSet::Cache::API} implementation that establishes
+    # set semantics based on the name of its entries. The cache
+    # uses the entries' names as cache key and refuses to add
+    # entries that don't respond_to?(:name).
+    #
+    # @see OrderedSet::Cache::API
+    #
+    # @api private
+    class NameCache
+
+      include OrderedSet::Cache::API
+
+      # Tests if the given entry qualifies to be added to the cache
+      #
+      # @param [#name] entry
+      #   the entry to be checked
+      #
+      # @return [Boolean]
+      #   true if the entry respond_to?(:name)
+      #
+      # @api private
+      def valid?(entry)
+        entry.respond_to?(:name)
+      end
+
+      # Given an entry, return the key to be used in the cache
+      #
+      # @param [#name] entry
+      #   the entry to get the key for
+      #
+      # @return [#to_s, nil]
+      #   the entry's name or nil if the entry isn't #valid?
+      #
+      # @api private
+      def key_for(entry)
+        valid?(entry) ? entry.name : nil
+      end
+
+    end # class NameCache
+
+    include Enumerable
+
+    # The elements in the SubjectSet
+    #
+    # @return [OrderedSet]
+    #
+    # @api private
+    attr_reader :entries
+
+    # Initialize a SubjectSet
+    #
+    # @param [Enumerable<#name>] entries
+    #   the entries to initialize this set with
+    #
+    # @api private
+    def initialize(entries = [])
+      @entries = OrderedSet.new(entries, NameCache)
+    end
+
+    # Initialize a copy of a SubjectSet
+    #
+    # @api private
+    def initialize_copy(*)
+      @entries = @entries.dup
+    end
+
+    # Make sure that entry is part of this SubjectSet
+    #
+    # If an entry with the same name already exists, it
+    # will be updated. If no such named entry exists, it
+    # will be added.
+    #
+    # @param [#name] entry
+    #   the entry to be added
+    #
+    # @return [SubjectSet] self
+    #
+    # @api private
+    def <<(entry)
+      entries << entry
+      self
+    end
+
+    # Delete an entry from this SubjectSet
+    #
+    # @param [#name] entry
+    #   the entry to delete
+    #
+    # @return [#name, nil]
+    #   the deleted entry or nil
+    #
+    # @api private
+    def delete(entry)
+      entries.delete(entry)
+    end
+
+    # Removes all entries and returns self
+    #
+    # @return [SubjectSet] self
+    #
+    # @api private
+    def clear
+      entries.clear
+      self
+    end
+
+    # Test if the given entry is included in this SubjectSet
+    #
+    # @param [#name] entry
+    #   the entry to test for
+    #
+    # @return [Boolean]
+    #   true if the entry is included in this SubjectSet
+    #
+    # @api private
+    def include?(entry)
+      entries.include?(entry)
+    end
+
+    # Tests wether the SubjectSet contains a entry named name
+    #
+    # @param [#to_s] name
+    #   the entry name to test for
+    #
+    # @return [Boolean]
+    #   true if the SubjectSet contains a entry named name
+    #
+    # @api private
+    def named?(name)
+      !self[name].nil?
+    end
+
+    # Check if there are any entries
+    #
+    # @return [Boolean]
+    #   true if the set contains at least one entry
+    #
+    # @api private
+    def empty?
+      entries.empty?
+    end
+
+    # Lookup an entry in the SubjectSet based on a given name
+    #
+    # @param [#to_s] name
+    #   the name of the entry
+    #
+    # @return [Object, nil]
+    #   the entry having the given name, or nil if not found
+    #
+    # @api private
+    def [](name)
+      name = name.to_s
+      entries.detect { |entry| entry.name.to_s == name }
+    end
+
+    # Iterate over each entry in the set
+    #
+    # @yield [entry]
+    #   each entry in the set
+    #
+    # @yieldparam [#name] entry
+    #   an entry in the set
+    #
+    # @return [SubjectSet] self
+    #
+    # @api private
+    def each
+      return to_enum unless block_given?
+      entries.each { |entry| yield(entry) }
+      self
+    end
+
+    # All entries (or nil values) that have any of the given names
+    #
+    # @param [Enumerable<#to_s>] names
+    #   the names of the desired entries
+    #
+    # @return [Array<#name, nil>]
+    #   an array containing entries whose names match any of the given
+    #   names, or nil values for those names with no matching entries
+    #   in the set
+    #
+    # @api private
+    def values_at(*names)
+      names.map { |name| self[name] }
+    end
+
+    # Get the number of elements inside this SubjectSet
+    #
+    # @return [Integer]
+    #   the number of elements
+    #
+    # @api private
+    def size
+      entries.size
+    end
+
+    # Convert the SubjectSet into an Array
+    #
+    # @return [Array]
+    #   an array containing all the SubjectSet's entries
+    #
+    # @api private
+    def to_ary
+      to_a
+    end
+
+  end # class SubjectSet
+end # module DataMapper

data/lib/dm-core/version.rb

@@ -0,0 +1,3 @@
+module DataMapper
+  VERSION = '1.3.0.beta'.freeze
+end

data/lib/dm-core.rb

@@ -0,0 +1,274 @@
+require 'addressable/uri'
+require 'bigdecimal'
+require 'bigdecimal/util'
+require 'date'
+require 'pathname'
+require 'time'
+require 'yaml'
+
+module DataMapper
+  module Undefined; end
+end
+
+require 'dm-core/support/ext/blank'
+require 'dm-core/support/ext/hash'
+require 'dm-core/support/ext/object'
+require 'dm-core/support/ext/string'
+
+require 'dm-core/core_ext/pathname'
+require 'dm-core/support/ext/module'
+require 'dm-core/support/ext/array'
+require 'dm-core/support/ext/try_dup'
+
+require 'dm-core/support/mash'
+require 'dm-core/support/inflector/inflections'
+require 'dm-core/support/inflector/methods'
+require 'dm-core/support/inflections'
+require 'dm-core/support/chainable'
+require 'dm-core/support/deprecate'
+require 'dm-core/support/descendant_set'
+require 'dm-core/support/equalizer'
+require 'dm-core/support/assertions'
+require 'dm-core/support/lazy_array'
+require 'dm-core/support/local_object_space'
+require 'dm-core/support/hook'
+require 'dm-core/support/subject'
+require 'dm-core/support/ordered_set'
+require 'dm-core/support/subject_set'
+
+require 'dm-core/query'
+require 'dm-core/query/conditions/operation'
+require 'dm-core/query/conditions/comparison'
+require 'dm-core/query/operator'
+require 'dm-core/query/direction'
+require 'dm-core/query/path'
+require 'dm-core/query/sort'
+
+require 'dm-core/resource'
+require 'dm-core/resource/persistence_state'
+require 'dm-core/resource/persistence_state/transient'
+require 'dm-core/resource/persistence_state/immutable'
+require 'dm-core/resource/persistence_state/persisted'
+require 'dm-core/resource/persistence_state/clean'
+require 'dm-core/resource/persistence_state/deleted'
+require 'dm-core/resource/persistence_state/dirty'
+
+require 'dm-core/property/invalid_value_error'
+require 'dm-core/property'
+require 'dm-core/property/typecast/numeric'
+require 'dm-core/property/typecast/time'
+require 'dm-core/property/object'
+require 'dm-core/property/string'
+require 'dm-core/property/binary'
+require 'dm-core/property/text'
+require 'dm-core/property/numeric'
+require 'dm-core/property/float'
+require 'dm-core/property/decimal'
+require 'dm-core/property/boolean'
+require 'dm-core/property/integer'
+require 'dm-core/property/serial'
+require 'dm-core/property/date'
+require 'dm-core/property/date_time'
+require 'dm-core/property/time'
+require 'dm-core/property/class'
+require 'dm-core/property/discriminator'
+require 'dm-core/property/lookup'
+require 'dm-core/property_set'
+
+require 'dm-core/model'
+require 'dm-core/model/hook'
+require 'dm-core/model/is'
+require 'dm-core/model/scope'
+require 'dm-core/model/relationship'
+require 'dm-core/model/property'
+
+require 'dm-core/collection'
+require 'dm-core/relationship_set'
+require 'dm-core/associations/relationship'
+require 'dm-core/associations/one_to_many'
+require 'dm-core/associations/one_to_one'
+require 'dm-core/associations/many_to_one'
+require 'dm-core/associations/many_to_many'
+
+require 'dm-core/identity_map'
+require 'dm-core/repository'
+require 'dm-core/adapters'
+require 'dm-core/adapters/abstract_adapter'
+
+require 'dm-core/support/logger'
+require 'dm-core/support/naming_conventions'
+require 'dm-core/version'
+
+require 'dm-core/core_ext/kernel'             # TODO: do not load automatically
+require 'dm-core/core_ext/symbol'             # TODO: do not load automatically
+
+require 'dm-core/backwards'                   # TODO: do not load automatically
+
+# A logger should always be present. Lets be consistent with DO
+DataMapper::Logger.new(StringIO.new, :fatal)
+
+Infinity = 1.0 / 0 unless defined?(Infinity)
+
+# == Setup and Configuration
+# DataMapper uses URIs or a connection hash to connect to your data-store.
+# URI connections takes the form of:
+#   DataMapper.setup(:default, 'protocol://username:password@127.0.0.1:port/path/to/repo')
+#
+# Breaking this down, the first argument is the name you wish to give this
+# connection.  If you do not specify one, it will be assigned :default. If you
+# would like to connect to more than one data-store, simply issue this command
+# again, but with a different name specified.
+#
+# In order to issue ORM commands without specifying the repository context, you
+# must define the :default database. Otherwise, you'll need to wrap your ORM
+# calls in <tt>repository(:name) { }</tt>.
+#
+# Second, the URI breaks down into the access protocol, the username, the
+# server, the password, and whatever path information is needed to properly
+# address the data-store on the server.
+#
+# Here's some examples
+#   DataMapper.setup(:default, 'sqlite3://path/to/your/project/db/development.db')
+#   DataMapper.setup(:default, 'mysql://127.0.0.1/dm_core_test')
+#     # no auth-info
+#   DataMapper.setup(:default, 'postgres://root:supahsekret@127.0.0.1/dm_core_test')
+#     # with auth-info
+#
+#
+# Alternatively, you can supply a hash as the second parameter, which would
+# take the form:
+#
+#   DataMapper.setup(:default, {
+#     :adapter  => 'adapter_name_here',
+#     :database => 'path/to/repo',
+#     :username => 'username',
+#     :password => 'password',
+#     :host     => 'hostname'
+#   })
+#
+# === Logging
+# To turn on error logging to STDOUT, issue:
+#
+#   DataMapper::Logger.new($stdout, :debug)
+#
+# You can pass a file location ("/path/to/log/file.log") in place of $stdout.
+# see DataMapper::Logger for more information.
+#
+module DataMapper
+  extend DataMapper::Assertions
+
+  class RepositoryNotSetupError < StandardError; end
+
+  class IncompleteModelError < StandardError; end
+
+  class PluginNotFoundError < StandardError; end
+
+  class UnknownRelationshipError < StandardError; end
+
+  class ObjectNotFoundError < RuntimeError; end
+
+  class PersistenceError < RuntimeError; end
+
+  class UpdateConflictError < PersistenceError; end
+
+  class SaveFailureError < PersistenceError
+    attr_reader :resource
+
+    def initialize(message, resource)
+      super(message)
+      @resource = resource
+    end
+  end
+
+  class ImmutableError < RuntimeError; end
+
+  class ImmutableDeletedError < ImmutableError; end
+
+  # Raised on attempt to operate on collection of child objects
+  # when parent object is not yet saved.
+  # For instance, if your article object is not saved,
+  # but you try to fetch or scope down comments (1:n case), or
+  # publications (n:m case), operation cannot be completed
+  # because parent object's keys are not yet persisted,
+  # and thus there is no FK value to use in the query.
+  class UnsavedParentError < PersistenceError; end
+
+  # @api private
+  def self.root
+    @root ||= Pathname(__FILE__).dirname.parent.expand_path.freeze
+  end
+
+  # Setups up a connection to a data-store
+  #
+  # @param [Symbol] name
+  #   a name for the context, defaults to :default
+  # @param [Hash(Symbol => String), Addressable::URI, String] uri_or_options
+  #   connection information
+  #
+  # @return [DataMapper::Adapters::AbstractAdapter]
+  #   the resulting setup adapter
+  #
+  # @raise [ArgumentError] "+name+ must be a Symbol, but was..."
+  #   indicates that an invalid argument was passed for name[Symbol]
+  # @raise [ArgumentError] "+uri_or_options+ must be a Hash, URI or String, but was..."
+  #   indicates that connection information could not be gleaned from
+  #   the given uri_or_options[Hash, Addressable::URI, String]
+  #
+  # @api public
+  def self.setup(*args)
+    adapter = args.first
+
+    adapter = Adapters.new(*args) unless adapter.is_a?(Adapters::AbstractAdapter)
+
+    Repository.adapters[adapter.name] = adapter
+  end
+
+  # Block Syntax
+  #   Pushes the named repository onto the context-stack,
+  #   yields a new session, and pops the context-stack.
+  #
+  # Non-Block Syntax
+  #   Returns the current session, or if there is none,
+  #   a new Session.
+  #
+  # @param [Symbol] args the name of a repository to act within or return, :default is default
+  #
+  # @yield [Proc] (optional) block to execute within the context of the named repository
+  #
+  # @api public
+  def self.repository(name = nil)
+    context = Repository.context
+
+    current_repository = if name
+                           name = name.to_sym
+                           context.detect { |repository| repository.name == name }
+                         else
+                           name = Repository.default_name
+                           context.last
+                         end
+
+    current_repository ||= Repository.new(name)
+
+    if block_given?
+      current_repository.scope { |*block_args| yield(*block_args) }
+    else
+      current_repository
+    end
+  end
+
+  # Perform necessary steps to finalize DataMapper for the current repository
+  #
+  # This method should be called after loading all models and plugins.
+  #
+  # It ensures foreign key properties and anonymous join models are created.
+  # These are otherwise lazily declared, which can lead to unexpected errors.
+  # It also performs basic validity checking of the DataMapper models.
+  #
+  # @return [self]
+  #
+  # @api public
+  def self.finalize
+    Model.descendants.each(&:finalize)
+    self
+  end
+end