ardm-core 1.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5d88a1388e05bc0987ce1ea0fcfd902bd19a91b5
+  data.tar.gz: 185295c3d88d126fcefe257eb50894cb9fccb99f
+SHA512:
+  metadata.gz: e3244f70503a3c2174bb896dda56ab841690761edfa2dd21b0009be74d5bd20bd7f125bb088b37066084d27ccb61677eb376817f97e7e8d560dacd26fbfdf56a
+  data.tar.gz: 65012a3e5de43b6923fb0ac9a5e8333fb77315ebdf1bcb7ee5bab75c68127762ce8c35fbf3fb2f966d5be691cf66e6175d79e88f5287f970d5d0a7a57b85e942

data/.autotest

@@ -0,0 +1,29 @@
+Autotest.add_hook :initialize do |at|
+  %w[ .git log script tasks LICENSE README.rdoc ].each do |exception|
+    at.add_exception(exception)
+  end
+
+  at.clear_mappings
+
+  spec_folders = /(?:semi)?public/
+
+  # when a file is updated, make sure it's dependent public and semipublic specs pass
+  at.add_mapping %r{\Alib/dm\-core/(.+)\.rb\z} do |_,match|
+    at.files_matching %r{\Aspec/#{spec_folders}/#{match[1]}_spec\.rb\z}
+  end
+
+  # when the spec configuration changes make sure all specs pass
+  at.add_mapping %r{\Aspec/spec_helper\.rb\z} do
+    at.files_matching %r{\Aspec/.+_spec\.rb\z}
+  end
+
+  # when a spec is updated, make sure it passes
+  at.add_mapping %r{\Aspec/#{spec_folders}/(.+)_spec\.rb\z} do |filename,_|
+    filename
+  end
+
+  # when the collection shared spec is update, make sure all dependent specs pass
+  at.add_mapping %r{\Aspec/lib/collection_shared_spec\.rb\z} do
+    at.files_matching %r{\Aspec/#{spec_folders}/collection_spec\.rb\z}
+  end
+end

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+--
+README.rdoc
+LICENSE

data/.gitignore

@@ -0,0 +1,35 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## Rubinius
+*.rbc
+
+## PROJECT::GENERAL
+*.gem
+coverage
+rdoc
+pkg
+tmp
+doc
+log
+.yardoc
+measurements
+
+## BUNDLER
+.bundle
+Gemfile.*
+
+## PROJECT::SPECIFIC
+spec/db/

data/.travis.yml

@@ -0,0 +1,23 @@
+language: ruby
+sudo: false
+services:
+  - mysql
+before_script:
+  - "bundle exec rake db:create"
+before_install:
+  - gem install bundler
+script: "bundle exec rake spec"
+env:
+  - "ADAPTER=in_memory"
+  - "ADAPTER=yaml"
+  - "ADAPTER=sqlite"
+  - "ADAPTER=mysql DM_DB_USER=root DM_DB_PASSWORD=''"
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.5
+  - 2.2.0
+matrix:
+  allow_failures:
+    - rvm: 2.1.5
+    - rvm: 2.2.0

data/.yardopts

@@ -0,0 +1 @@
+--markup rdoc --title 'DataMapper Documentation' --protected

data/Gemfile

@@ -0,0 +1,63 @@
+require File.expand_path('../lib/dm-core/version', __FILE__)
+
+require 'pathname'
+
+source 'https://rubygems.org'
+
+gemspec
+
+SOURCE         = ENV.fetch('SOURCE', :git).to_sym
+REPO_POSTFIX   = SOURCE == :path ? ''                                : '.git'
+DATAMAPPER     = SOURCE == :path ? Pathname(__FILE__).dirname.parent : 'http://github.com/ar-dm'
+DM_VERSION     = '~> 1.2.0'
+DO_VERSION     = '~> 0.10.6'
+DM_DO_ADAPTERS = %w[ sqlite postgres mysql oracle sqlserver ]
+CURRENT_BRANCH = ENV.fetch('GIT_BRANCH', 'master')
+
+platforms :mri_18 do
+  group :quality do
+
+    gem 'rcov',      '~> 0.9.10'
+    gem 'yard',      '~> 0.7.2'
+    gem 'yardstick', '~> 0.4'
+
+  end
+end
+
+group :datamapper do
+
+  adapters = ENV['ADAPTERS'] || ENV['ADAPTER']
+  adapters = adapters.to_s.tr(',', ' ').split.uniq - %w[ in_memory ]
+
+  if (do_adapters = DM_DO_ADAPTERS & adapters).any?
+    do_options = {}
+    do_options[:git] = "#{DATAMAPPER}/do#{REPO_POSTFIX}" if ENV['DO_GIT'] == 'true'
+
+    gem 'data_objects', DO_VERSION, do_options.dup
+
+    do_adapters.each do |adapter|
+      adapter = 'sqlite3' if adapter == 'sqlite'
+      gem "do_#{adapter}", DO_VERSION, do_options.dup
+    end
+
+    gem 'ardm-do-adapter', DM_VERSION,
+      SOURCE  => "#{DATAMAPPER}/ardm-do-adapter#{REPO_POSTFIX}",
+      :branch => CURRENT_BRANCH
+  end
+
+  adapters.each do |adapter|
+    gem "ardm-#{adapter}-adapter", ENV.fetch('ADAPTER_VERSION', DM_VERSION),
+      SOURCE  => "#{DATAMAPPER}/ardm-#{adapter}-adapter#{REPO_POSTFIX}",
+      :branch => CURRENT_BRANCH
+  end
+
+  plugins = ENV['PLUGINS'] || ENV['PLUGIN']
+  plugins = plugins.to_s.tr(',', ' ').split.push('ardm-migrations').uniq
+
+  plugins.each do |plugin|
+    gem plugin, DM_VERSION,
+      SOURCE  => "#{DATAMAPPER}/#{plugin}#{REPO_POSTFIX}",
+      :branch => CURRENT_BRANCH
+  end
+
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 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/README.rdoc

@@ -0,0 +1,237 @@
+= 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[https://github.com/datamapper/dm-core/issues] or
+patch[http://datamapper.lighthouseapp.com], 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.
+
+  repository do
+    @parent = Tree.first(:name => 'bob')
+
+    @parent.children.each do |child|
+      puts @parent.equal?(child.parent)  # => true
+    end
+  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.
+
+== Eager Loading
+
+Ready for something amazing? The following example executes only two queries
+regardless of how many rows the inner and outer queries return.
+
+  repository do
+    Zoo.all.each { |zoo| zoo.exhibits.to_a }
+  end
+
+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 lazily loaded, 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
+<tt>:lazy</tt> 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 :description, 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:
+
+  repository do
+    Animal.all.each { |animal| animal.description.to_a }
+  end
+
+Did you notice the <tt>#to_a</tt> call in the above example?  That
+was necessary because even DataMapper collections are lazy.  If you don't
+iterate over them, or in this case ask them to become Arrays, they won't
+execute until you need them.  We needed to call <tt>#to_a</tt> to force
+the lazy load because without it, the above example would have only
+executed one query.  This extra bit of laziness can come in very handy,
+for example:
+
+  animals     = Animal.all
+  description = 'foo'
+
+  animals.each do |animal|
+    animal.update(:description => description)
+  end
+
+In the above example, the Animals won't be retrieved until you actually
+need them.  This comes in handy in cases where you initialize the
+collection before you know if you need it, like in a web app controller.
+
+== Collection Chaining
+
+DataMapper's lazy collections are also handy because you can get the
+same effect as named scopes, without any special syntax, eg:
+
+  class Animal
+    # ... setup ...
+
+    def self.mammals
+      all(:mammal => true)
+    end
+
+    def self.zoo(zoo)
+      all(:zoo => zoo)
+    end
+  end
+
+  zoo = Zoo.first(:name => 'Greater Vancouver Zoo')
+
+  Animal.mammals.zoo(zoo).to_a  # => executes one query
+
+In the above example, we ask the Animal model for all the mammals,
+and then all the animals in a specific zoo, and DataMapper will chain
+the collection queries together and execute a single query to retrieve
+the matching records.  There's no special syntax, and no custom DSLs
+to learn, it's just plain ruby all the way down.
+
+You can even use this on association collections, eg:
+
+  zoo.animals.mammals.to_a  # => executes one query
+
+== Custom Properties
+
+With DataMapper it is possible to create custom properties for your models.
+Consider this example:
+
+  module DataMapper
+    class Property
+      class Email < String
+        required true
+        format   /^([\w\.%\+\-]+)@([\w\-]+\.)+([\w]{2,})$/i
+      end
+    end
+  end
+
+  class User
+    include DataMapper::Resource
+
+    property :id,    Serial
+    property :email, Email
+  end
+
+This way there won't be a need to repeat same property options every time you
+add an email to a model. In the example above we create an Email property which
+is just a String with additional pre-configured options: <tt>required</tt> and
+<tt>format</tt>. Please note that it is possible to override these options when
+declaring a property, like this:
+
+  class Member
+    include DataMapper::Resource
+
+    property :id,    Serial
+    property :email, Email, :required => false
+  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:
+
+  # '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)
+
+  # 'not' allows you to match all people without the name "bob"
+  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 ])
+
+  # 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...
+
+== Note on Patches/Pull Requests
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2011 Dan Kubb. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,4 @@
+require 'rubygems'
+require 'rake'
+
+FileList['tasks/**/*.rake'].each { |task| import task }

data/VERSION

@@ -0,0 +1 @@
+1.2.0

data/ardm-core.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/dm-core/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name          = "ardm-core"
+  s.version       = DataMapper::VERSION
+
+  s.summary       = "Ardm fork of dm-core"
+  s.description   = s.summary
+
+  s.authors       = [ "Martin Emde", "Dan Kubb" ]
+  s.email         = [ "me@martinemde.com", "dan.kubb@gmail.com" ]
+  s.homepage      = "https://github.com/ar-dm/ardm-core"
+  s.license       = "MIT"
+
+  s.require_paths = [ "lib" ]
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- spec/*`.split("\n")
+  s.extra_rdoc_files = %w[LICENSE README.rdoc]
+
+  s.add_dependency('addressable', "~> 2.3")
+
+  s.add_development_dependency('rake',  '~> 0.9')
+  s.add_development_dependency('rspec', '~> 1.3')
+end