rpbertp13-dm-core 0.9.11.1

data/Rakefile

@@ -0,0 +1,32 @@
+#!/usr/bin/env ruby
+require 'pathname'
+require 'rubygems'
+require 'rake'
+require 'rake/rdoctask'
+require 'spec/rake/spectask'
+
+require 'lib/dm-core/version'
+
+ROOT = Pathname(__FILE__).dirname.expand_path
+
+AUTHOR           = 'Dan Kubb'
+EMAIL            = 'dan.kubb@gmail.com'
+GEM_NAME         = 'dm-core'
+GEM_VERSION      = DataMapper::VERSION
+GEM_DEPENDENCIES = [
+  %w[ data_objects ~>0.9.11 ],
+  %w[ extlib       ~>0.9.11 ],
+  %w[ addressable  ~>2.0.2  ],
+]
+
+PROJECT_NAME        = 'datamapper'
+PROJECT_DESCRIPTION = 'Faster, Better, Simpler.'
+PROJECT_SUMMARY     = 'An Object/Relational Mapper for Ruby'
+PROJECT_URL         = 'http://datamapper.org'
+
+require ROOT + 'tasks/hoe'
+require ROOT + 'tasks/gemspec'
+require ROOT + 'tasks/install'
+require ROOT + 'tasks/dm'
+require ROOT + 'tasks/doc'
+require ROOT + 'tasks/ci'

data/SPECS

@@ -0,0 +1,62 @@
+Reading Specs
+=============
+
+  Blah blah blah...
+
+Writing Specs
+=============
+
+  Here are some general dos and don'ts
+
+  = DO:
+
+  * Write more specs for error conditions than clean conditions.
+  * Write specs with readability in mind. Somebody knew to DataMapper should be
+    able to read specs to learn how something works.
+  * Use existing models that are part of a metaphor.
+  * Nest describe blocks (2 or 3 levels deep is probably fine).
+  * Limit a describe block to 10 - 15 examples.
+  * Group specs by method being tested. (See the 'Ordering Specs' section)
+  * Use custom matchers.
+
+  = DON'T:
+
+  * Spec more than one unit of functionality in an example. An example should be
+    as short as possible (while still remaining readable).
+  * Spec implementation. Refactoring code should not break specs.
+  * Declare models in the spec file.
+
+  And a final do: Do go against the guidelines if your best judgement tells you
+  to. These are just guidelines and are obviously not fast rules.
+
+Models
+======
+
+  Models are declared in separate files as opposed to individual spec files for
+  two reasons. The first is to improve readability. By creating as few models
+  as possible and sharing these models throughout the specs, a reader can
+  become familiar with the models being used quicker. Models also follow a
+  few simple metaphors, such as a zoo, a blog implementation, etc... Following
+  metaphors makes it easier for a reader to guess what is going on with respect
+  to the models.
+
+  The second reason is to allow the spec environment to be as pristine as
+  possible going into an example. Models being loaded from the model directory
+  are tracked and reloaded before each example. Any changes that might be made
+  to the model are reset at the end.
+
+Mocks and Stubs
+===============
+
+  Obviously, mocks and stubs are a powerful feature when it comes to BDD;
+  however, remember that you are writing specs for behavior and NOT
+  implementation.
+
+Ordering Specs
+==============
+
+  Specs aren't much use if nobody can find where anything is, so keeping specs
+  well organized is critical. Currently, we are trying out the following
+  structure:
+
+    * List guidelines here...

data/TODO

@@ -0,0 +1 @@
+See: http://github.com/sam/dm-core/wikis

data/dm-core.gemspec

@@ -0,0 +1,40 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{dm-core}
+  s.version = "0.9.11.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Dan Kubb"]
+  s.date = %q{2009-03-29}
+  s.description = %q{Faster, Better, Simpler.}
+  s.email = ["dan.kubb@gmail.com"]
+  s.extra_rdoc_files = ["History.txt", "Manifest.txt", "README.txt"]
+  s.files = [".autotest", ".gitignore", "CONTRIBUTING", "FAQ", "History.txt", "MIT-LICENSE", "Manifest.txt", "QUICKLINKS", "README.txt", "Rakefile", "SPECS", "TODO", "dm-core.gemspec", "lib/dm-core.rb", "lib/dm-core/adapters.rb", "lib/dm-core/adapters/abstract_adapter.rb", "lib/dm-core/adapters/data_objects_adapter.rb", "lib/dm-core/adapters/in_memory_adapter.rb", "lib/dm-core/adapters/mysql_adapter.rb", "lib/dm-core/adapters/postgres_adapter.rb", "lib/dm-core/adapters/sqlite3_adapter.rb", "lib/dm-core/associations.rb", "lib/dm-core/associations/many_to_many.rb", "lib/dm-core/associations/many_to_one.rb", "lib/dm-core/associations/one_to_many.rb", "lib/dm-core/associations/one_to_one.rb", "lib/dm-core/associations/relationship.rb", "lib/dm-core/associations/relationship_chain.rb", "lib/dm-core/auto_migrations.rb", "lib/dm-core/collection.rb", "lib/dm-core/dependency_queue.rb", "lib/dm-core/hook.rb", "lib/dm-core/identity_map.rb", "lib/dm-core/is.rb", "lib/dm-core/logger.rb", "lib/dm-core/migrations/destructive_migrations.rb", "lib/dm-core/migrator.rb", "lib/dm-core/model.rb", "lib/dm-core/naming_conventions.rb", "lib/dm-core/property.rb", "lib/dm-core/property_set.rb", "lib/dm-core/query.rb", "lib/dm-core/repository.rb", "lib/dm-core/resource.rb", "lib/dm-core/scope.rb", "lib/dm-core/support.rb", "lib/dm-core/support/array.rb", "lib/dm-core/support/assertions.rb", "lib/dm-core/support/errors.rb", "lib/dm-core/support/kernel.rb", "lib/dm-core/support/symbol.rb", "lib/dm-core/transaction.rb", "lib/dm-core/type.rb", "lib/dm-core/type_map.rb", "lib/dm-core/types.rb", "lib/dm-core/types/boolean.rb", "lib/dm-core/types/discriminator.rb", "lib/dm-core/types/object.rb", "lib/dm-core/types/paranoid_boolean.rb", "lib/dm-core/types/paranoid_datetime.rb", "lib/dm-core/types/serial.rb", "lib/dm-core/types/text.rb", "lib/dm-core/version.rb", "script/all", "script/performance.rb", "script/profile.rb", "spec/integration/association_spec.rb", "spec/integration/association_through_spec.rb", "spec/integration/associations/many_to_many_spec.rb", "spec/integration/associations/many_to_one_spec.rb", "spec/integration/associations/one_to_many_spec.rb", "spec/integration/auto_migrations_spec.rb", "spec/integration/collection_spec.rb", "spec/integration/data_objects_adapter_spec.rb", "spec/integration/dependency_queue_spec.rb", "spec/integration/model_spec.rb", "spec/integration/mysql_adapter_spec.rb", "spec/integration/postgres_adapter_spec.rb", "spec/integration/property_spec.rb", "spec/integration/query_spec.rb", "spec/integration/repository_spec.rb", "spec/integration/resource_spec.rb", "spec/integration/sqlite3_adapter_spec.rb", "spec/integration/sti_spec.rb", "spec/integration/strategic_eager_loading_spec.rb", "spec/integration/transaction_spec.rb", "spec/integration/type_spec.rb", "spec/lib/logging_helper.rb", "spec/lib/mock_adapter.rb", "spec/lib/model_loader.rb", "spec/lib/publicize_methods.rb", "spec/models/content.rb", "spec/models/vehicles.rb", "spec/models/zoo.rb", "spec/spec.opts", "spec/spec_helper.rb", "spec/unit/adapters/abstract_adapter_spec.rb", "spec/unit/adapters/adapter_shared_spec.rb", "spec/unit/adapters/data_objects_adapter_spec.rb", "spec/unit/adapters/in_memory_adapter_spec.rb", "spec/unit/adapters/postgres_adapter_spec.rb", "spec/unit/associations/many_to_many_spec.rb", "spec/unit/associations/many_to_one_spec.rb", "spec/unit/associations/one_to_many_spec.rb", "spec/unit/associations/one_to_one_spec.rb", "spec/unit/associations/relationship_spec.rb", "spec/unit/associations_spec.rb", "spec/unit/auto_migrations_spec.rb", "spec/unit/collection_spec.rb", "spec/unit/data_mapper_spec.rb", "spec/unit/identity_map_spec.rb", "spec/unit/is_spec.rb", "spec/unit/migrator_spec.rb", "spec/unit/model_spec.rb", "spec/unit/naming_conventions_spec.rb", "spec/unit/property_set_spec.rb", "spec/unit/property_spec.rb", "spec/unit/query_spec.rb", "spec/unit/repository_spec.rb", "spec/unit/resource_spec.rb", "spec/unit/scope_spec.rb", "spec/unit/transaction_spec.rb", "spec/unit/type_map_spec.rb", "spec/unit/type_spec.rb", "tasks/ci.rb", "tasks/dm.rb", "tasks/doc.rb", "tasks/gemspec.rb", "tasks/hoe.rb", "tasks/install.rb"]
+  s.has_rdoc = true
+  s.homepage = %q{http://datamapper.org}
+  s.rdoc_options = ["--main", "README.txt"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{datamapper}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{An Object/Relational Mapper for Ruby}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<data_objects>, ["~> 0.10.0"])
+      s.add_runtime_dependency(%q<extlib>, ["~> 0.9.11"])
+      s.add_runtime_dependency(%q<addressable>, ["~> 2.0"])
+    else
+      s.add_dependency(%q<data_objects>, ["~> 0.10.0"])
+      s.add_dependency(%q<extlib>, ["~> 0.9.11"])
+      s.add_dependency(%q<addressable>, ["~> 2.0"])
+    end
+  else
+    s.add_dependency(%q<data_objects>, ["~> 0.10.0"])
+    s.add_dependency(%q<extlib>, ["~> 0.9.11"])
+    s.add_dependency(%q<addressable>, ["~> 2.0"])
+  end
+end

data/lib/dm-core.rb

@@ -0,0 +1,217 @@
+# This file begins the loading sequence.
+#
+# Quick Overview:
+# * Requires fastthread, support libs, and base.
+# * Sets the application root and environment for compatibility with frameworks
+#   such as Rails or Merb.
+# * Checks for the database.yml and loads it if it exists.
+# * Sets up the database using the config from the Yaml file or from the
+#   environment.
+#
+
+require 'date'
+require 'pathname'
+require 'rubygems'
+require 'set'
+require 'time'
+require 'yaml'
+
+gem 'addressable', '~>2.0'
+require 'addressable/uri'
+
+gem 'extlib', '~>0.9.11'
+require 'extlib'
+require 'extlib/inflection'
+
+begin
+  gem 'fastthread', '~>1.0.4'
+  require 'fastthread'
+rescue LoadError
+  # fastthread not installed
+end
+
+dir = Pathname(__FILE__).dirname.expand_path / 'dm-core'
+
+require dir / 'support'
+require dir / 'resource'
+require dir / 'model'
+
+require dir / 'dependency_queue'
+require dir / 'type'
+require dir / 'type_map'
+require dir / 'types'
+require dir / 'hook'
+require dir / 'associations'
+require dir / 'auto_migrations'
+require dir / 'identity_map'
+require dir / 'logger'
+require dir / 'migrator'
+require dir / 'naming_conventions'
+require dir / 'property_set'
+require dir / 'query'
+require dir / 'transaction'
+require dir / 'repository'
+require dir / 'scope'
+require dir / 'property'
+require dir / 'adapters'
+require dir / 'collection'
+require dir / 'is'
+
+# == 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, 0)
+#
+# You can pass a file location ("/path/to/log/file.log") in place of STDOUT.
+# see DataMapper::Logger for more information.
+#
+module DataMapper
+  extend Assertions
+
+  def self.root
+    @root ||= Pathname(__FILE__).dirname.parent.expand_path
+  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 Repository the resulting setup repository
+  #
+  # @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(name, uri_or_options)
+    assert_kind_of 'name',           name,           Symbol
+    assert_kind_of 'uri_or_options', uri_or_options, Addressable::URI, Hash, String
+
+    case uri_or_options
+      when Hash
+        adapter_name = uri_or_options[:adapter].to_s
+      when String, DataObjects::URI, Addressable::URI
+        uri_or_options = DataObjects::URI.parse(uri_or_options) if uri_or_options.kind_of?(String)
+        adapter_name = uri_or_options.scheme
+    end
+
+    class_name = Extlib::Inflection.classify(adapter_name) + 'Adapter'
+
+    unless Adapters::const_defined?(class_name)
+      lib_name = "#{Extlib::Inflection.underscore(adapter_name)}_adapter"
+      begin
+        require root / 'lib' / 'dm-core' / 'adapters' / lib_name
+      rescue LoadError => e
+        begin
+          require lib_name
+        rescue Exception
+          # library not found, raise the original error
+          raise e
+        end
+      end
+    end
+
+    Repository.adapters[name] = Adapters::const_get(class_name).new(name, uri_or_options)
+  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
+  # @demo spec/integration/repository_spec.rb
+  def self.repository(name = nil) # :yields: current_context
+    current_repository = if name
+      raise ArgumentError, "First optional argument must be a Symbol, but was #{name.inspect}" unless name.is_a?(Symbol)
+      Repository.context.detect { |r| r.name == name } || Repository.new(name)
+    else
+      Repository.context.last || Repository.new(Repository.default_name)
+    end
+
+    if block_given?
+      current_repository.scope { |*block_args| yield(*block_args) }
+    else
+      current_repository
+    end
+  end
+
+  # A logger should always be present. Lets be consistent with DO
+  Logger.new(nil, :off)
+
+  ##
+  # destructively migrates the repository upwards to match model definitions
+  #
+  # @param [Symbol] name repository to act on, :default is the default
+  def self.migrate!(name = Repository.default_name)
+    repository(name).migrate!
+  end
+
+  ##
+  # drops and recreates the repository upwards to match model definitions
+  #
+  # @param [Symbol] name repository to act on, :default is the default
+  def self.auto_migrate!(repository_name = nil)
+    AutoMigrator.auto_migrate(repository_name)
+  end
+
+  def self.auto_upgrade!(repository_name = nil)
+    AutoMigrator.auto_upgrade(repository_name)
+  end
+
+  def self.prepare(*args, &blk)
+    yield repository(*args)
+  end
+
+  def self.dependency_queue
+    @dependency_queue ||= DependencyQueue.new
+  end
+end

data/lib/dm-core/adapters.rb

@@ -0,0 +1,16 @@
+dir = Pathname(__FILE__).dirname.expand_path / 'adapters'
+
+require dir / 'abstract_adapter'
+require dir / 'in_memory_adapter'
+
+# NOTE: this is a temporary work-around to the load error problems,
+# and is better fixed in dm-core/next.  The main reason the fix is
+# not applied in dm-core/master is because the change is non-trivial.
+
+%w[ data_objects sqlite3 mysql postgres ].each do |gem|
+  begin
+    require dir / "#{gem}_adapter"
+  rescue LoadError, Gem::Exception
+    # ignore it
+  end
+end

data/lib/dm-core/adapters/abstract_adapter.rb

@@ -0,0 +1,209 @@
+module DataMapper
+  module Adapters
+    class AbstractAdapter
+      include Assertions
+
+      attr_reader :name, :uri
+      attr_accessor :resource_naming_convention, :field_naming_convention
+
+      def create(resources)
+        raise NotImplementedError
+      end
+
+      def read_many(query)
+        raise NotImplementedError
+      end
+
+      def read_one(query)
+        raise NotImplementedError
+      end
+
+      def update(attributes, query)
+        raise NotImplementedError
+      end
+
+      def delete(query)
+        raise NotImplementedError
+      end
+
+      protected
+
+      def normalize_uri(uri_or_options)
+        uri_or_options
+      end
+
+      private
+
+      # Instantiate an Adapter by passing it a DataMapper::Repository
+      # connection string for configuration.
+      def initialize(name, uri_or_options)
+        assert_kind_of 'name',           name,           Symbol
+        assert_kind_of 'uri_or_options', uri_or_options, Addressable::URI, DataObjects::URI, Hash, String
+
+        @name = name
+        @uri  = normalize_uri(uri_or_options)
+
+        @resource_naming_convention = NamingConventions::Resource::UnderscoredAndPluralized
+        @field_naming_convention    = NamingConventions::Field::Underscored
+
+        @transactions = {}
+      end
+
+      # TODO: move to dm-more/dm-migrations
+      module Migration
+        #
+        # Returns whether the storage_name exists.
+        #
+        # @param storage_name<String> a String defining the name of a storage,
+        #   for example a table name.
+        #
+        # @return <Boolean> true if the storage exists
+        #
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def storage_exists?(storage_name)
+          raise NotImplementedError
+        end
+
+        #
+        # Returns whether the field exists.
+        #
+        # @param storage_name<String> a String defining the name of a storage, for example a table name.
+        # @param field_name<String> a String defining the name of a field, for example a column name.
+        #
+        # @return <Boolean> true if the field exists.
+        #
+        # TODO: move to dm-more/dm-migrations (if possible)
+        def field_exists?(storage_name, field_name)
+          raise NotImplementedError
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def upgrade_model_storage(repository, model)
+          raise NotImplementedError
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def create_model_storage(repository, model)
+          raise NotImplementedError
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def destroy_model_storage(repository, model)
+          raise NotImplementedError
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def alter_model_storage(repository, *args)
+          raise NotImplementedError
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def create_property_storage(repository, property)
+          raise NotImplementedError
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def destroy_property_storage(repository, property)
+          raise NotImplementedError
+        end
+
+        # TODO: move to dm-more/dm-migrations
+        def alter_property_storage(repository, *args)
+          raise NotImplementedError
+        end
+
+        module ClassMethods
+          # Default TypeMap for all adapters.
+          #
+          # @return <DataMapper::TypeMap> default TypeMap
+          #
+          # TODO: move to dm-more/dm-migrations
+          def type_map
+            @type_map ||= TypeMap.new
+          end
+        end
+      end
+
+      include Migration
+      extend Migration::ClassMethods
+
+      # TODO: move to dm-more/dm-transaction
+      module Transaction
+        #
+        # Pushes the given Transaction onto the per thread Transaction stack so
+        # that everything done by this Adapter is done within the context of said
+        # Transaction.
+        #
+        # @param transaction<DataMapper::Transaction> a Transaction to be the
+        #   'current' transaction until popped.
+        #
+        # TODO: move to dm-more/dm-transaction
+        def push_transaction(transaction)
+          transactions(Thread.current) << transaction
+        end
+
+        #
+        # Pop the 'current' Transaction from the per thread Transaction stack so
+        # that everything done by this Adapter is no longer necessarily within the
+        # context of said Transaction.
+        #
+        # @return <DataMapper::Transaction> the former 'current' transaction.
+        #
+        # TODO: move to dm-more/dm-transaction
+        def pop_transaction
+          transactions(Thread.current).pop
+        end
+
+        #
+        # Retrieve the current transaction for this Adapter.
+        #
+        # Everything done by this Adapter is done within the context of this
+        # Transaction.
+        #
+        # @return <DataMapper::Transaction> the 'current' transaction for this Adapter.
+        #
+        # TODO: move to dm-more/dm-transaction
+        def current_transaction
+          transactions(Thread.current).last
+        end
+
+        #
+        # Returns whether we are within a Transaction.
+        #
+        # @return <Boolean> whether we are within a Transaction.
+        #
+        # TODO: move to dm-more/dm-transaction
+        def within_transaction?
+          !current_transaction.nil?
+        end
+
+        #
+        # Produces a fresh transaction primitive for this Adapter
+        #
+        # Used by DataMapper::Transaction to perform its various tasks.
+        #
+        # @return <Object> a new Object that responds to :close, :begin, :commit,
+        #   :rollback, :rollback_prepared and :prepare
+        #
+        # TODO: move to dm-more/dm-transaction (if possible)
+        def transaction_primitive
+          raise NotImplementedError
+        end
+
+        private
+        def transactions(thread)
+          unless @transactions[thread]
+            @transactions.delete_if do |key, value|
+              !key.respond_to?(:alive?) || !key.alive?
+            end
+            @transactions[thread] = []
+          end
+          @transactions[thread]
+        end
+
+      end
+
+      include Transaction
+    end # class AbstractAdapter
+  end # module Adapters
+end # module DataMapper