rpbertp13-dm-core 0.9.11.1

data/.autotest

@@ -0,0 +1,26 @@
+Autotest.add_hook :initialize do |at|
+  ignore = %w[ .git burn www log plugins script tasks bin CHANGELOG FAQ MIT-LICENSE PERFORMANCE QUICKLINKS README ]
+
+  unless ENV['AUTOTEST'] == 'integration'
+    ignore << 'spec/integration'
+  end
+
+  ignore.each do |exception|
+    at.add_exception(exception)
+  end
+
+  at.clear_mappings
+
+  at.add_mapping(%r{^spec/.+_spec\.rb$}) do |filename,_|
+    filename
+  end
+
+  at.add_mapping(%r{^lib/data_mapper/(.+)\.rb$}) do |_,match|
+    [ "spec/unit/#{match[1]}_spec.rb" ] +
+    at.files_matching(%r{^spec/integration/.+_spec\.rb$})
+  end
+
+  at.add_mapping(%r{^spec/spec_helper\.rb$}) do
+    at.files_matching(%r{^spec/.+_spec\.rb$})
+  end
+end

data/.gitignore

@@ -0,0 +1,18 @@
+*.log
+log/*
+doc
+cov
+pkg
+.DS_Store
+coverage/*
+*.db
+spec/integration/*.db*
+nbproject
+profile_results.*
+\#*
+TAGS
+lib/coverage.html
+*.rbc
+_Yardoc
+.yardoc
+tmp/*

data/CONTRIBUTING

@@ -0,0 +1,51 @@
+# NOTE: This is a work in progress. As of July 24, it applies only to dm-core.
+
+# Contributing to Edge DataMapper
+
+We have now implemented Hoe throughout the DataMapper suite, so there will be a 
+handful of new procedures for contributing to our git repositories. I'll give 
+you a run through of how to set up your machine, and then provide a few 
+commands that should be run before committing or pushing changes.
+
+## Installing and configuring Hoe
+
+The first step is to install hoe. You'll need at least version 1.7.0.
+
+    (sudo) gem install hoe --include-dependencies
+    
+Now you'll need to configure hoe. You'll need to run this from inside of 
+dm-core, or one of the other DataMapper projects.
+
+    rake config_hoe
+    
+The only thing you should need to change is the exclude regular expression, 
+which needs to look like this:
+
+    exclude: !ruby/regexp /tmp$|CVS|\.svn|\.git|.+\.gemspec/
+    
+Now you have the correct setup for contributing.
+
+## Before committing changes
+
+Before you commit changes, you must verify that `Manifest.txt` (the file which 
+contains the names of every file to be included in a gem release) and 
+`[project-name].gemspec` are up to date. We have create a rake task to make 
+this easy:
+
+    rake gemspec
+    
+This will check `Manifest.txt` (using Hoe's `rake check_manifest`) to ensure 
+there are no differences between the files in the project, and those listed in 
+the manifest. If there is a difference, it will display a warning and a list of 
+the differences in `diff` format.
+
+If the changes in the diff are correct, then you can run the following command 
+to update the manifest.
+
+    rake check_manifest | patch
+    
+If there are files you do not want added to the manifest, then you should 
+remove the files from the project, and then run `rake gemspec` again.
+
+If `rake gemspec` says it was successful, then you can proceed with committing 
+and pushing your changes.

data/FAQ

@@ -0,0 +1,92 @@
+:include:QUICKLINKS
+
+= FAQ
+
+=== So where's my :id column?
+
+DataMapper will NOT create an auto-incrementing <tt>:id</tt> key for you 
+automatically, so you'll need to either explicitly create one with
+
+  property :id, Serial
+
+You can choose to use a natural key by doing
+
+  property :slug, String, :key => true
+
+Remember, DataMapper supports multiple keys ("composite keys"), so if your
+model has two or more keys, no big deal
+
+  property :store_id, 	Integer, :key => true
+  property :invoice_id, Integer, :key => true
+
+=== How do I make a model paranoid?
+
+Create a property and make it a ParanoidDateTime or ParanoidBoolean type.
+
+  property :deleted_at, ParanoidDateTime
+  property :deleted, ParanoidBoolean
+
+All of your calls to <tt>##all()</tt>, <tt>##first()</tt> will be scoped 
+with <tt>:deleted_at => nil</tt> or <tt>:deleted => false</tt>. Plus, 
+you won't see deleted objects in your associations.
+
+=== Does DataMapper do Single Table Inheritance?
+
+This is what the Discriminator data-type is for:
+
+  class Person
+    include DataMapper::Resource
+    property :id, Serial
+    property :type, Discriminator ## other shared properties here
+  end
+
+  class Salesperson < Person; end
+
+You can claim a column to have the type <tt>Discriminator</tt> and DataMapper will
+automatically drop the class name of the inherited classes into that field of
+the data-store.
+
+=== How do I run my own commands?
+
+  repository.adapter.query("select * from users where clue > 0")
+  repository(:integration).adapter.query("select * from users where clue > 0")
+
+This does not return any Users (har har), but rather Struct's that will quack
+like Users. They'll be read-only as well.
+
+<tt>repository.adapter.query</tt> shouldn't be used if you aren't expecting a result set
+back.  If you want to just execute something against the database, use
+<tt>repository.adapter.execute</tt> instead.
+
+
+=== Can I get an query log of what DataMapper is issuing?
+
+An example of how to modify an existing logger:
+
+  DataMapper.logger.set_log(STDOUT, :debug)
+
+An example of how to create new logger:
+
+  DataMapper::Logger.new(STDOUT, :info)
+
+To send a message to the DataMapper logger:
+
+  DataMapper.logger.debug("something")
+  DataMapper.logger.info ("something")
+  DataMapper.logger.warn ("something")
+  DataMapper.logger.error("something")
+  DataMapper.logger.fatal("something")
+
+
+=== I want to run the specs, but I have a custom database setup
+
+For example, if you installed MySQL using MacPorts, your socket may be located
+at /opt/local/var/run/mysql5/mysqld.sock instead of /tmp/mysql.sock
+
+In that case, setup an environment variable in your shell before running the
+specs:
+  export MYSQL_SPEC_URI="mysql://localhost/dm_core_test?socket=/opt/local/var/run/mysql5/mysqld.sock"
+  rake spec
+
+Using another kind of database? Note that spec_helper.rb will also look for
+SQLITE3_SPEC_URI AND POSTGRES_SPEC_URI.

data/History.txt

@@ -0,0 +1,52 @@
+=== 0.9.11 / 2009-03-29
+
+* 1 major enhancement:
+
+  * Added deprecation warning for inferred child_key naming convention change
+
+* 6 bug fixes:
+
+  * Removed unecessary code from SEL
+  * 1.9.1 fix for Logger to use Array#join instead of Array#to_s
+  * 1.9.1 fix for specs to pass
+  * Fix for multiple join models to create correct SQL
+  * Fix for STI and lazy loading
+  * Fixed Resource#eql?
+
+=== 0.9.10 / 2009-01-19
+
+* 1 major enhancement:
+
+  * Ruby 1.9.1 compatibility
+
+* 1 minor enhancement:
+
+  * Updated Resource marshaling to be more thorough
+
+=== 0.9.9 / 2009-01-04
+
+* 1 minor enhancement:
+
+  * Updated Resource and Collection to be serializable with Marshal
+
+* 1 bug fix:
+
+  * Fixed Model#copy to copy properties that are the same in both
+    repositories.
+
+=== 0.9.8 / 2008-12-07
+
+* 3 minor enhancements:
+
+  * Updated Resource#inspect to not lazy-load unloaded attributes.
+  * Updated ManyToOne::Proxy to delegate #class to parent.  This will
+    allow the Merb resource() route helper method to use the association
+    proxy to generate the URL.
+  * Updated Resource#attributes= to respect method visibility.  This means
+    that only public mutators will set the attribute value.
+
+* 1 bug fix:
+
+  * Fixed regression where an update to a resource with a lazy property
+    could cause the record to reload when accessing the lazy property,
+    clobbering any changes made prior.

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2007, 2008, 2009 Sam Smoot, Dan Kubb
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/Manifest.txt

@@ -0,0 +1,130 @@
+.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

data/QUICKLINKS

@@ -0,0 +1,11 @@
+= Quick Links
+
+* Setup and Configuration - DataMapper
+* Finders and CRUD -
+* Properties - DataMapper::Property
+* FAQ[link:/files/FAQ.html]
+* Contact Us
+  * Website - http://www.datamapper.org
+  * Bug Reports - http://wm.lighthouseapp.com/projects/4819-datamapper/overview
+  * IRC Channel - <tt>##datamapper</tt> on irc.freenode.net
+  * Mailing List - http://groups.google.com/group/datamapper/

data/README.txt

@@ -0,0 +1,143 @@
+
+:include:QUICKLINKS
+
+= Why DataMapper?
+
+== Open Development
+
+DataMapper sports a very accessible code-base and a welcoming community.
+Outside contributions and feedback are welcome and encouraged, especially
+constructive criticism. Make your voice heard! Submit a
+ticket[http://wm.lighthouseapp.com/projects/4819-datamapper/overview] or
+patch[http://wm.lighthouseapp.com/projects/4819-datamapper/overview], speak up
+on our mailing-list[http://groups.google.com/group/datamapper/], chat with us
+on irc[irc://irc.freenode.net/#datamapper], write a spec, get it reviewed, ask
+for commit rights. It's as easy as that to become a contributor.
+
+== Identity Map
+
+One row in the data-store should equal one object reference. Pretty simple idea.
+Pretty profound impact. If you run the following code in ActiveRecord you'll
+see all <tt>false</tt> results. Do the same in DataMapper and it's
+<tt>true</tt> all the way down.
+
+  @parent = Tree.find(:first, :conditions => ['name = ?', 'bob'])
+
+  @parent.children.each do |child|
+    puts @parent.object_id == child.parent.object_id
+  end
+
+This makes DataMapper faster and allocate less resources to get things done.
+
+== Dirty Tracking
+
+When you save a model back to your data-store, DataMapper will only write
+the fields that actually changed. So it plays well with others. You can
+use it in an Integration data-store without worrying that your application will
+be a bad actor causing trouble for all of your other processes.
+
+You can also configure which strategy you'd like to use to track dirtiness.
+
+== Eager Loading
+
+Ready for something amazing? The following example executes only two queries.
+
+  zoos = Zoo.all
+  first = zoos.first
+  first.exhibits  # Loads the exhibits for all the Zoo objects in the zoos variable.
+
+Pretty impressive huh? The idea is that you aren't going to load a set of
+objects and use only an association in just one of them. This should hold up
+pretty well against a 99% rule. When you don't want it to work like this, just
+load the item you want in it's own set. So the DataMapper thinks ahead. We
+like to call it "performant by default". This feature single-handedly wipes
+out the "N+1 Query Problem". No need to specify an <tt>include</tt> option in
+your finders.
+
+== Laziness Can Be A Virtue
+
+Text fields are expensive in data-stores. They're generally stored in a
+different place than the rest of your data. So instead of a fast sequential
+read from your hard-drive, your data-store server has to hop around all over the
+place to get what it needs. Since ActiveRecord returns everything by default,
+adding a text field to a table slows everything down drastically, across the
+board.
+
+Not so with the DataMapper. Text fields are treated like in-row associations
+by default, meaning they only load when you need them. If you want more
+control you can enable or disable this feature for any field (not just
+text-fields) by passing a @lazy@ option to your field mapping with a value of
+<tt>true</tt> or <tt>false</tt>.
+
+  class Animal
+    include DataMapper::Resource
+    property :name, String
+    property :notes, Text, :lazy => false
+  end
+
+Plus, lazy-loading of text fields happens automatically and intelligently when
+working with associations.  The following only issues 2 queries to load up all
+of the notes fields on each animal:
+
+  animals = Animal.all
+  animals.each do |pet|
+    pet.notes
+  end
+
+== Plays Well With Others
+
+In ActiveRecord, all your fields are mapped, whether you want them or not.
+This slows things down. In the DataMapper you define your mappings in your
+model. So instead of an _ALTER TABLE ADD field_ in your data-store, you simply
+add a <tt>property :name, :string</tt> to your model. DRY. No schema.rb. No
+migration files to conflict or die without reverting changes. Your model
+drives the data-store, not the other way around.
+
+Unless of course you want to map to a legacy data-store. Raise your hand if you
+like seeing a method called <tt>col2Name</tt> on your model just because
+that's what it's called in an old data-store you can't afford to change right
+now? In DataMapper you control the mappings:
+
+  class Fruit
+    include DataMapper::Resource
+    storage_names[:repo] = 'frt'
+    property :name, String, :field => 'col2Name'
+  end
+
+== All Ruby, All The Time
+
+It's great that ActiveRecord allows you to write SQL when you need to, but
+should we have to so often?
+
+DataMapper supports issuing your own query, but it also provides more helpers
+and a unique hash-based condition syntax to cover more of the use-cases where
+issuing your own SQL would have been the only way to go. For example, any
+finder option that's non-standard is considered a condition. So you can write
+<tt>Zoo.all(:name => 'Dallas')</tt> and DataMapper will look for zoos with the
+name of 'Dallas'.
+
+It's just a little thing, but it's so much nicer than writing
+<tt>Zoo.find(:all, :conditions => ['name = ?', 'Dallas'])</tt>. What if you
+need other comparisons though? Try these:
+
+  Zoo.first(:name => 'Galveston')
+
+  # 'gt' means greater-than. We also do 'lt'.
+  Person.all(:age.gt => 30)
+
+  # 'gte' means greather-than-or-equal-to. We also do 'lte'.
+  Person.all(:age.gte => 30)
+
+  Person.all(:name.not => 'bob')
+
+  # If the value of a pair is an Array, we do an IN-clause for you.
+  Person.all(:name.like => 'S%', :id => [1, 2, 3, 4, 5])
+
+  # An alias for Zoo.find(11)
+  Zoo[11]
+
+  # Does a NOT IN () clause for you.
+  Person.all(:name.not => ['bob','rick','steve'])
+
+See? Fewer SQL fragments dirtying your Ruby code. And that's just a few of the
+nice syntax tweaks DataMapper delivers out of the box...