datamapper 0.3.2 → 0.9.3

data/CHANGELOG

@@ -1,145 +0,0 @@
--- 0.1.0
-* Initial Public Release
-
--- 0.1.1
-* Removed /lib/data_mapper/extensions
-* Moved ActiveRecordImpersonation into DataMapper::Support module
-* Moved CallbackHelper methods into DataMapper::Base class
-* Moved ValidationHelper into DataMapper::Validations module
-* Removed LoadedSet since it's not necessary for it to reference the Database, so it's nothing more than an array now; Replaced with Array
-* Modified data_mapper.rb to load DataMapper::Support::Enumerable
-* Modified example.rb and performance.rb to require 'lib/data_mapper' instead of modifying $LOADPATH
-* Created SqlAdapter base-class
-* Refactored MysqlAdapter to use SqlAdapter superclass
-* Refactored Sqlite3Adapter to use SqlAdapter superclass
-* Moved /lib/data_mapper/queries to /lib/data_mapper/adapters/sql/queries
-* Moved Connection, Result and Reader classes along with Coersion and Quoting modules to DataMapper::Adapters::Sql module
-* Moved DataMapper::Adapters::Sql::Queries to ::Commands
-* Moved Mappings to SqlAdapter
-* Added monolithic DeleteCommand
-* Added monolithic SaveCommand
-* Added TableExistsCommand
-* Moved save/delete logic out of Session
-* Added create-table functionality to SaveCommand
-* Cleaned up Session; #find no longer supported, use #all or #first
-* Moved object materialization into LoadCommand
-* Migrated Sqlite3Adapter::Commands
-* Added Session#query support back in
-* Removed Connection/Reader/Result classes
-* Set DataMapper::Base#key on load to avoid double-hit against Schema
-* Added DataMapper::Support::Struct for increased Session#query performance
-* Added AdvancedHasManyAssociation (preview status)
-* Added benchmarks comparing ActiveRecord::Base::find_by_sql with Session#query
-
--- 0.2.0
-* AdvancedHasManyAssociation now functional for fetches
-* AdvancedHasManyAssociation renamed to HasNAssociation
-* HasManyAssociation refactored to use HasNAssociation superclass
-* Slight spec tweaks to accomodate the updates
-* HasOneAssociation refactored to use HasNAssociation superclass
-* Added HasAndBelongsToManyAssociation, using HasNAssociation as a basis; Need to add corresponding SQL generation code in AdvancedLoadCommand
-* Added spec for habtm query generation
-* HasNAssociation#foreign_key returns a DataMapper::Adapters::Sql::Mappings::Column instance instead of a raw String now
-* Added table, association, association_table and to_sql methods to HasNAssociation
-* Added associations_spec.rb
-* Added a forced table-recreation to spec_helper.rb so the tests could run with a clean version of the database, including any new columns added to the models
-* Added HasAndBelongsToManyAssociation#to_sql (all current specs pass now!)
-* Minor tweaks to Callbacks
-* Added CallbacksHelper to declare class-method ::callbacks on DataMapper::Base
-* Implemented before_validate and after_validate hooks in ValidationHelper
-* Minor documentation additions in callbacks.rb
-* Added callbacks_spec
-* Moved class-method declarations for built-in callbacks to the callbacks helper instead of DataMapper::Base
-* Renamed :before/after_validate callback to :before/after_validation to match ActiveRecord
-* Callbacks#add now accepts a Symbol which maps a callback to a method call on the targetted instance, also added a spec to verify this behavior
-* Documented callbacks.rb
-* Added DataMapper::Associations::Reference class
-* Documented DataMapper::Associations::Reference class
-* Upgraded BelongsToAssociation to new style
-* Added AssociationsSet to handle simple "last-in" for association bindings
-* Fixed extra spec loading
-* Added *Association#columns
-* Some refactoring in AdvancedLoadCommand regarding :include options
-* Added support for class-less Mappings::Table instances, with just a string name
-* HasAndBelongsToManyAssociation#join_table #left_foreign_key and #right_foreign_key reference actual Table or Column objects now
-* Added :shallow_include option for HABTM joins in AdvancedLoadCommand and corresponding spec
-* Added Commands::AdvancedConditions
-* Added ORDER, LIMIT, OFFSET and WHERE support to AdvancedLoadCommand
-* Renamed spec/has_many.rb to spec/has_many_spec.rb
-* Tweaked the loading of has_many relationships; big performance boost; got rid of an extra query
-* Added EmbeddedValue support, and accompanying spec
-* Fleshed out AdvancedConditions a bit; added conditions_spec.rb
-* Added more AdvancedConditions specs
-* Added Loader to handle multi-instanced rows
-* AdvancedLoadCommand replaced LoadCommand; down to 3 failing specs
-* All specs pass
-* Added :intercept_load finder option and accompanying spec
-* Modified :intercept_load block signature to |instance,columns,row|
-* HasAndBelongsToMany works, all specs pass
-* Fixed a couple bugs with keys; Added DataMapper::Base#key= method
-* Made DataMapper::Base#lazy_load! a little more flexible
-* Removed LoadCommand overwrites from MysqlAdapter
-* Default Database#single_threaded mode is true now
-* Removed MysqlAdapter#initialize, which only served to setup the connections, moved to SqlAdapter
-* Added SqlAdapter#create_connection and SqlAdapter#close_connection abstract methods
-* Added MysqlAdapter#create_connection and MysqlAdapter#close_connection concrete methods
-* Made SqlAdapter#connection a concrete method (instead of abstract), with support for single_threaded operation
-* Database#setup now takes a Hash of options instead of a block-initializer
-* Validation chaining should work for all association types
-* Save chaining should work for has_many associations
-* Added benchmarks for in-session performance to performance.rb
-* Removed block conditions; They're slower and don't offer any real advantages
-* Removed DeleteCommand
-* Removed SaveCommand
-* Removed TableExistsCommand
-* Session renamed to Context
-* Most command implementations moved to methods in SqlAdapter
-* Removed UnitOfWork module, instead moving a slightly refactored implementation into Base
-
--- 0.2.1
-* Added :float column support
-* Added association proxies: ie: Zoo.first.exhibits.animals
-* Columns stored in SortedSet
-* Swig files are no longer RDOCed
-* Added :date column support
-* BUG: Fixed UTC issues with datetimes
-* Added #to_yaml method
-* Added #to_xml method
-* Added #to_json method
-* BUG: Fixed HasManyAssociation::Set#inspect
-* BUG: Fixed #reload!
-* BUG: Column copy for STI moved into Table#initialize to better handle STI with multiple mapped databases
-* BUG: before_create callbacks moved in the execution flow since they weren't guaranteed to fire before
-* Threading enhancements: Removed single_threaded_mode, #database block form adjusted for thread-safety
-* BUG: Fixed String#blank? when a multi-line string contained a blank line (thanks zapnap!)
-* Performance enhancements: (thanks wycats!)
-
--- 0.2.2
-* Removed C extension bundles and log files from package
-
--- 0.2.3
-* Added String#t for translation and overrides for default validation messages
-* Give credit where it's due: zapnap, not pimpmaster, submitted the String#blank? patch. My bad. :-(
-* MAJOR: Resolve issue with non-unique-hash values and #dirty?; now frozen original values are stored instead
-* Added Base#update_attributes
-* MAJOR: Queries are now passed to the database drivers in a parameterized fashion
-* Updated PostgreSQL driver and adapter to current
-
--- 0.2.4
-* Bug fixes
-* Added paranoia
-
--- 0.2.5
-* has_one bugfixes
-* Added syntax for setting CHECK-constraints directly in your properties (Postgres)
-* You can now set indexes with :index => true and :index => :unique
-* Support for composite indexes (thanks to Jeffrey Gelens)
-* Add composite scope to validates_uniqueness
-* Added private/protected properties
-* Remove HasOneAssociation, Make HasManyAssociation impersonate has_one relationships
-* Added #get method
-* Persistence module added, inheriting from DataMapper::Base no longer necessary
-
--- 0.3.0
-* HasManyAssociation::Set now has a nil? method, so we can do stuff like cage.animal.nil?
-

data/FAQ

@@ -1,96 +0,0 @@
-:include:QUICKLINKS
-
-= FAQ
-
-=== I don't want to use :id as a primary key, but I don't see <tt>set_primary_key</tt> anywhere. What do I do?
-
-If you're working with a table that doesn't have a <tt>:id</tt> column, you can declare your properties as you usually do, and declare one of them as a natural key.
-
-   property :name, :string, :key => true
-
-You should now be able to do <tt>Class['name_string']</tt> as well. Remember: this column should be unique, so treat it that way. This is the equivalent to using <tt>set_primary_key</tt> in ActiveRecord.
-
-
-=== How do I make a model paranoid?
-
-  property :deleted_at, :datetime
-
-If you've got deleted_at, your model is paranoid auto-magically. All of your calls to <tt>##all()</tt>, <tt>##first()</tt>, and <tt>##count()</tt> will be scoped with <tt>where deleted_at is null</tt>. Plus, you won't see deleted objects in your associations.
-
-=== Does DataMapper support Has Many Through?
-
-Write me!
-
-=== What about Self-Referential Has And Belongs to Many?
-
-Sure does.  Here's an example implementation: 
-
-  class Task < DataMapper::Base
-    has_and_belongs_to_many :tasks,
-      :join_table => "task_relationships",
-      :left_foreign_key => "parent_id",
-      :right_foreign_key => "child_id"
-  end
-
-You'll notice that instead of <tt>foreign_key</tt> and <tt>association_foreign_key</tt>, DataMapper uses the "database-y" terms <tt>left_foreign_key</tt>, and <tt>right_foreign_key</tt>.
-
-=== Does DataMapper do Single Table Inheritance?
-
-Oh yes, and particularly well too.
-
-  class Person < Datamapper::Base
-    property :type, :class
-    ## other shared properties here
-  end  
-
-  class Salesperson < Person; end
-
-You can claim a column to have the type <tt>:class</tt> and DataMapper will automatically drop the class name of the inherited classes into that column of the database.  
-
-=== What about Class Table Inheritance?
-
-Class Table Inheritance is on the drawing board and everyone's drooling over it. So no, not yet, but soon.
-
-=== How do I run my own commands?
-
-You're probably asking for <tt>find_by_sql</tt>, and DataMapper has that in it's ActiveRecordImpersonation, but if you want to go straight-up DataMapper, you'll want to use <tt>database.query</tt>
-
-  database.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>database.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>database.execute</tt> instead.
-
-=== Can I batch-process a ton of records at once?
-
-  User.each(:performance_rating => "low") do |u|
-    u.employment_status = "fired"
-    u.save
-  end
-
-With ActiveRecord, doing a <tt>User.find(:all).each{}</tt> would execute the find, instantiate an object for EVERY result, THEN apply your transformations to each object in turn. Doesn't sound too horrible unless you have a TON of records; you WILL grind your system to a screeching and bloody halt.
-
-Datamapper's <tt>#each</tt> works in sets of 500 so the amount of objects instantiated at a time won't make your computer think it's a victim in a Saw movie. Once it's done executing your block on the first set of 500, it moves on to the next.
-
-What's more is <tt>#each</tt> is secretly a finder too. You can pass it an options hash and it'll only iterate on 500-item sets matching your query. Don't send it <tt>:offset</tt> though, because that's how it pages. You can overload the page size by sending it <tt>:limit</tt>
-
-=== Can I get an SQL log of what queries DataMapper is issuing?
-
-Yup, when you issue <tt>Database.setup</tt>, tack on the <tt>log_stream</tt> and <tt>log_level</tt>:
-
-  DataMapper::Database.setup({
-   :adapter    => 'mysql',
-   :host       => 'localhost',
-   :username   => 'root',
-   :password   => 'R00tPaswooooord',
-   :database   => 'myspiffyblog_development',
-   :log_stream => 'log/sql.log',
-   :log_level  => 0
-  })
-
-By supplying the <tt>log_stream</tt> you're telling DataMapper what file you want to see your sql logs in. <tt>log_level</tt> is the Logger[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc/] level of output you want to see there. 0, in this case, says that you want to see all DEBUG level messages (and higher) sent to the logger. For more information on how to work with Logger[http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc/], hit up http://www.ruby-doc.org/stdlib/libdoc/logger/rdoc/.
-
-Incidentally, if you'd like to send a message into the Datamapper logger, do:
-
-  database.adapter.logger.info "your message here"
-

data/MIT-LICENSE

@@ -1,22 +0,0 @@
-Copyright (c) 2007 Sam Smoot
-
-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/QUICKLINKS

@@ -1,12 +0,0 @@
-= Quick Links
-
-* Finders and CRUD - DataMapper::Persistence::ConvenienceMethods::ClassMethods
-* Properties - DataMapper::Property
-* Validations - Validatable
-* Migrations
-* 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

@@ -1,105 +0,0 @@
-
-: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 database 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.
-
-== Don't Do What You Don't Have To
-
-ActiveRecord updates every column in a row during a save whether that column changed or not. So it performs work it doesn't really need to making it much slower, and more likely to eat data during concurrent access if you don't go around adding locking support to everything. 
-
-DataMapper only does what it needs to. So it plays well with others. You can use it in an Integration Database without worrying that your application will be a bad actor causing trouble for all of your other processes.
-
-== 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 columns are expensive in databases. 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 database server has to hop around all over the place to get what it needs. Since ActiveRecord returns everything by default, adding a text column 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 column (not just text-fields) by passing a @lazy@ option to your column mapping with a value of <tt>true</tt> or <tt>false</tt>.
-
-
-  class Animal < DataMapper::Base
-    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 columns 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 COLUMN_ in your Database, 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 database, not the other way around. 
-
-Unless of course you want to map to a legacy database. 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 database you can't afford to change right now? In DataMapper you control the mappings:
-
-
-  class Fruit < DataMapper::Base
-    set_table_name 'frt'
-    property :name, :string, :column => 'col2'
-  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 SQL, 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...
-
-== Better Is Great, But Familiar Is Nice
-
-The DataMapper also supports a lot of old-fashioned ActiveRecord syntax. We want to make it easy for you to get started, so aside from mapping your columns and changing the base-class your models inherit from, much of AR syntax for finders are supported as well, making your transition easy.

data/environment.rb

@@ -1,62 +0,0 @@
-unless defined?(INITIAL_CLASSES)
-  # Require the DataMapper, and a Mock Adapter.
-  require File.dirname(__FILE__) + '/lib/data_mapper'
-  require File.dirname(__FILE__) + '/spec/mock_adapter'
-
-  adapter = ENV['ADAPTER'] || 'sqlite3'
-
-  configuration_options = {
-    :adapter => adapter,
-    :database =>  (ENV['DATABASE'] || 'data_mapper_1').dup
-  }
-
-  # Prepare the log path, and remove the existing spec.log
-  require 'fileutils'
-
-  if ENV['LOG_NAME']
-    log_path = nil
-    
-    if ENV['LOG_NAME'] != 'STDOUT'
-      FileUtils::mkdir_p(File.dirname(__FILE__) + '/log')
-      log_path = File.dirname(__FILE__) + "/log/#{ENV['LOG_NAME']}.log"
-      FileUtils::rm log_path if File.exists?(log_path)
-    else
-      log_path = 'STDOUT'
-    end
-    
-    configuration_options.merge!(:log_stream => log_path, :log_level => Logger::DEBUG)
-  end
-
-  case adapter
-    when 'postgresql' then
-      configuration_options[:username] = ENV['USERNAME'] || 'postgres'
-    when 'mysql' then
-      configuration_options[:username] = 'root'
-    when 'sqlite3' then
-      unless configuration_options[:database] == ':memory:'
-        configuration_options[:database] << '.db'
-      end
-  end
-
-  load_models = lambda do
-    Dir[File.dirname(__FILE__) + '/spec/models/*.rb'].sort.each { |path| load path }
-  end
-
-  secondary_configuration_options = configuration_options.dup
-  secondary_configuration_options.merge!(:database => (adapter == 'sqlite3' ? 'data_mapper_2.db' : 'data_mapper_2'))
-  
-  DataMapper::Database.setup(configuration_options)
-  DataMapper::Database.setup(:secondary, secondary_configuration_options)
-  DataMapper::Database.setup(:mock, :adapter => MockAdapter)
-
-  [:default, :secondary, :mock].each { |name| database(name) { load_models.call } }
-
-  # Reset the test database.
-  unless ENV['AUTO_MIGRATE'] == 'false'
-    [:default, :secondary].each { |name| database(name) { DataMapper::Persistence.auto_migrate! } }
-  end
-
-  # Save the initial database layout so we can put everything back together
-  # after auto migrations testing
-  INITIAL_CLASSES = Array.new(DataMapper::Persistence.subclasses.to_a)
-end