ghost_dm-core 1.3.0.beta

data/lib/dm-core.rb

@@ -0,0 +1,292 @@
+require 'addressable/uri'
+require 'bigdecimal'
+require 'bigdecimal/util'
+require 'date'
+require 'pathname'
+require 'set'
+require 'time'
+require 'yaml'
+
+module DataMapper
+  module Undefined; end
+end
+
+require 'virtus'
+
+class Virtus::Coercion::Object
+  def self.to_string(value)
+    value.nil? ? value : value.to_s
+  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'
+
+begin
+  require 'fastthread'
+rescue LoadError
+  # fastthread not installed
+end
+
+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'
+require 'dm-core/property/invalid_value_error'
+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)
+
+unless defined?(Infinity)
+  Infinity = 1.0/0
+end
+
+# == 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@localhost: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://localhost/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
+
+    unless adapter.kind_of?(Adapters::AbstractAdapter)
+      adapter = Adapters.new(*args)
+    end
+
+    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 { |model| model.finalize }
+    self
+  end
+
+end # module DataMapper

data/lib/dm-core/adapters.rb

@@ -0,0 +1,222 @@
+module DataMapper
+  module Adapters
+    extend Chainable
+    extend DataMapper::Assertions
+
+    # Set up an adapter for a storage engine
+    #
+    # @see DataMapper.setup
+    #
+    # @api private
+    def self.new(repository_name, options)
+      options = normalize_options(options)
+      adapter_class(options.fetch(:adapter)).new(repository_name, options)
+    end
+
+    # The path used to require the in memory adapter
+    #
+    # Set this if you want to register your own adapter
+    # to be used when you specify an 'in_memory' connection
+    # during
+    #
+    # @see DataMapper.setup
+    #
+    # @param [String] path
+    #   the path used to require the desired in memory adapter
+    #
+    # @api semipublic
+    def self.in_memory_adapter_path=(path)
+      @in_memory_adapter_path = path
+    end
+
+    # The path used to require the in memory adapter
+    #
+    # @see DataMapper.setup
+    #
+    # @return [String]
+    #   the path used to require the desired in memory adapter
+    #
+    # @api semipublic
+    def self.in_memory_adapter_path
+      @in_memory_adapter_path ||= 'dm-core/adapters/in_memory_adapter'
+    end
+
+    class << self
+      private
+
+      # Normalize the arguments passed to new()
+      #
+      # Turns options hash or connection URI into the options hash used
+      # by the adapter.
+      #
+      # @param [Hash, Addressable::URI, String] options
+      #   the options to be normalized
+      #
+      # @return [Mash]
+      #   the options normalized as a Mash
+      #
+      # @api private
+      def normalize_options(options)
+        case options
+          when Hash             then normalize_options_hash(options)
+          when Addressable::URI then normalize_options_uri(options)
+          when String           then normalize_options_string(options)
+          else
+            assert_kind_of 'options', options, Hash, Addressable::URI, String
+        end
+      end
+
+      # Normalize Hash options into a Mash
+      #
+      # @param [Hash] hash
+      #   the hash to be normalized
+      #
+      # @return [Mash]
+      #   the options normalized as a Mash
+      #
+      # @api private
+      def normalize_options_hash(hash)
+        DataMapper::Ext::Hash.to_mash(hash)
+      end
+
+      # Normalize Addressable::URI options into a Mash
+      #
+      # @param [Addressable::URI] uri
+      #   the uri to be normalized
+      #
+      # @return [Mash]
+      #   the options normalized as a Mash
+      #
+      # @api private
+      def normalize_options_uri(uri)
+        options = normalize_options_hash(uri.to_hash)
+
+        # Extract the name/value pairs from the query portion of the
+        # connection uri, and set them as options directly.
+        if options.fetch(:query)
+          options.update(uri.query_values)
+        end
+
+        options[:adapter] = options.fetch(:scheme)
+
+        options
+      end
+
+      # Normalize String options into a Mash
+      #
+      # @param [String] string
+      #   the string to be normalized
+      #
+      # @return [Mash]
+      #   the options normalized as a Mash
+      #
+      # @api private
+      def normalize_options_string(string)
+        normalize_options_uri(Addressable::URI.parse(string))
+      end
+
+      # Return the adapter class constant
+      #
+      # @example
+      #   DataMapper::Adapters.send(:adapter_class, 'mysql') # => DataMapper::Adapters::MysqlAdapter
+      #
+      # @param [Symbol] name
+      #   the name of the adapter
+      #
+      # @return [Class]
+      #   the AbstractAdapter subclass
+      #
+      # @api private
+      def adapter_class(name)
+        adapter_name = normalize_adapter_name(name)
+        class_name = (DataMapper::Inflector.camelize(adapter_name) << 'Adapter').to_sym
+        load_adapter(adapter_name) unless const_defined?(class_name)
+        const_get(class_name)
+      end
+
+      # Return the name of the adapter
+      #
+      # @example
+      #   DataMapper::Adapters.adapter_name('MysqlAdapter') # => 'mysql'
+      #
+      # @param [String] const_name
+      #   the adapter constant name
+      #
+      # @return [String]
+      #   the name of the adapter
+      #
+      # @api semipublic
+      def adapter_name(const_name)
+        const_name.to_s.chomp('Adapter').downcase
+      end
+
+      # Require the adapter library
+      #
+      # @param [String, Symbol] name
+      #   the name of the adapter
+      #
+      # @return [Boolean]
+      #   true if the adapter is loaded
+      #
+      # @api private
+      def load_adapter(name)
+        require "dm-#{name}-adapter"
+      rescue LoadError => original_error
+        begin
+          require in_memory_adapter?(name) ? in_memory_adapter_path : legacy_path(name)
+        rescue LoadError
+          raise original_error
+        end
+      end
+
+      # Returns wether or not the given adapter name is considered an in memory adapter
+      #
+      # @param [String, Symbol] name
+      #   the name of the adapter
+      #
+      # @return [Boolean]
+      #   true if the adapter is considered to be an in memory adapter
+      #
+      # @api private
+      def in_memory_adapter?(name)
+        name.to_s == 'in_memory'
+      end
+
+      # Returns the fallback filename that would be used to require the named adapter
+      #
+      # The fallback format is "#{name}_adapter" and will be phased out in favor of
+      # the properly 'namespaced' "dm-#{name}-adapter" format.
+      #
+      # @param [String, Symbol] name
+      #   the name of the adapter to require
+      #
+      # @return [String]
+      #   the filename that gets required for the adapter identified by name
+      #
+      # @api private
+      def legacy_path(name)
+        "#{name}_adapter"
+      end
+
+      # Adjust the adapter name to match the name used in the gem providing the adapter
+      #
+      # @param [String, Symbol] name
+      #   the name of the adapter
+      #
+      # @return [String]
+      #   the normalized adapter name
+      #
+      # @api private
+      def normalize_adapter_name(name)
+        (original = name.to_s) == 'sqlite3' ? 'sqlite' : original
+      end
+
+    end
+
+    extendable do
+      # @api private
+      def const_added(const_name)
+      end
+    end
+  end # module Adapters
+end # module DataMapper