dm-ar-finders 0.9.11 → 0.10.0

data/{History.txt → History.rdoc}

@@ -1,3 +1,7 @@
+=== 0.10.0 / 2009-10-15
+
+* Updated to work with dm-core 0.10.0
+
 === 0.9.11 / 2009-03-29
 
 * No changes this version

data/Manifest.txt

@@ -1,7 +1,7 @@
-History.txt
+History.rdoc
 LICENSE
 Manifest.txt
-README.txt
+README.rdoc
 Rakefile
 TODO
 lib/dm-ar-finders.rb

data/Rakefile

@@ -1,5 +1,4 @@
 require 'pathname'
-require 'rubygems'
 
 ROOT    = Pathname(__FILE__).dirname.expand_path
 JRUBY   = RUBY_PLATFORM =~ /java/
@@ -14,10 +13,10 @@ GEM_NAME = 'dm-ar-finders'
 GEM_VERSION = DataMapper::ARFinders::VERSION
 GEM_DEPENDENCIES = [['dm-core', GEM_VERSION]]
 GEM_CLEAN = %w[ log pkg coverage ]
-GEM_EXTRAS = { :has_rdoc => true, :extra_rdoc_files => %w[ README.txt LICENSE TODO History.txt ] }
+GEM_EXTRAS = { :has_rdoc => true, :extra_rdoc_files => %w[ README.rdoc LICENSE TODO History.rdoc ] }
 
 PROJECT_NAME = 'datamapper'
-PROJECT_URL  = "http://github.com/sam/dm-more/tree/master/#{GEM_NAME}"
+PROJECT_URL  = "http://github.com/datamapper/dm-more/tree/master/#{GEM_NAME}"
 PROJECT_DESCRIPTION = PROJECT_SUMMARY = 'DataMapper plugin providing ActiveRecord-style finders'
 
 [ ROOT, ROOT.parent ].each do |dir|

data/lib/dm-ar-finders/version.rb

@@ -1,5 +1,5 @@
 module DataMapper
   module ARFinders
-    VERSION = '0.9.11'
+    VERSION = '0.10.0'.freeze
   end
 end

data/lib/dm-ar-finders.rb

@@ -1,24 +1,123 @@
-require 'rubygems'
-gem 'dm-core', '0.9.11'
-require 'dm-core'
-
 module DataMapper
   module Model
-    def find_or_create(search_attributes, create_attributes = {})
-      first(search_attributes) || create(search_attributes.merge(create_attributes))
+    # Find resources by providing your own SQL query or DataMapper::Query
+    # instance.
+    #
+    # @param [Array] sql_or_query
+    #   An array whose first element is an SQL query, and the other
+    #   elements are bind values for the query.
+    # @param [Hash] options
+    #   A hash containing extra options.
+    #
+    # @overload find_by_sql(string_query, options = {})
+    #   @param [String] sql_or_query
+    #     A string containing an SQL query to execute.
+    #   @param [Hash] options
+    #     A hash containing extra options.
+    #
+    # @overload find_by_sql(dm_query, options = {})
+    #   @param [DataMapper::Query] sql_or_query
+    #     A DataMapper::Query instance to be used to generate an SQL query.
+    #   @param [Hash] options
+    #     A hash containing extra options.
+    #
+    # @option options [true, false] :reload (false)
+    #   Whether to reload any matching resources which are already loaded.
+    # @option options [Symbol, Array, DataMapper::Property, DataMapper::PropertySet] :properties
+    #   Specific properties to be loaded. May be a single symbol, a Property
+    #   instance, an array of Properties, or a PropertySet.
+    # @option options [Symbol] :repository
+    #   The repository to query. Uses the model default if none is specified.
+    #
+    # @return [DataMapper::Collection]
+    #   A collection containing any records which matched your query.
+    #
+    # @raise [ArgumentError]
+    #
+    # @example Query with bind values
+    #   MyClass.find_by_sql(["SELECT id FROM my_classes WHERE county = ?",
+    #     selected_county])
+    #
+    # @example String query
+    #   MyClass.find_by_sql("SELECT id FROM my_classes LIMIT 1")
+    #
+    # @example Query with properties option
+    #   MyClass.find_by_sql("SELECT id FROM my_classes LIMIT 1",
+    #     :properties => [:id, :name])
+    #
+    # @example Query with repository
+    #   MyClass.find_by_sql(["SELECT id FROM my_classes WHERE county = ?",
+    #     selected_county], :properties => MyClass.property[:name],
+    #     :repository => :county_repo)
+    #
+    # @api public
+    def find_by_sql(sql_or_query, options = {})
+      # Figure out what the user passed in.
+      case sql_or_query
+      when Array
+        sql, *bind_values = sql_or_query
+      when String
+        sql, bind_values = sql_or_query, []
+      when DataMapper::Query
+        sql, bind_values = repository.adapter.send(:select_statement, query)
+      else
+        raise ArgumentError, '#find_by_sql requires a query of some kind to work'
+      end
+
+      # Sort out the options.
+      repository = repository(options.fetch(:repository, default_repository_name))
+
+      if options.key?(:properties)
+        if options[:properties].kind_of?(DataMapper::PropertySet)
+          properties = Array(options[:properties])
+        else
+          # Normalize properties into PropertySet[Property].
+          properties = Array(options[:properties]).map! do |prop|
+            prop.kind_of?(Symbol) ? self.properties[prop] : prop
+          end
+
+          properties = DataMapper::PropertySet.new(properties)
+        end
+      else
+        properties = self.properties(repository.name)
+      end
+
+      unless repository.adapter.kind_of?(Adapters::DataObjectsAdapter)
+        raise '#find_by_sql only available for Repositories served by a DataObjectsAdapter'
+      end
+
+      records = []
+
+      repository.adapter.send(:with_connection) do |connection|
+        reader = connection.create_command(sql).execute_reader(*bind_values)
+        fields = properties.values_at(*reader.fields).compact
+
+        begin
+          while reader.next!
+            records << fields.zip(reader.values).to_hash
+          end
+        ensure
+          reader.close
+        end
+      end
+
+      query = Query.new(repository, self,
+        :fields => properties, :reload => options.fetch(:reload, false))
+
+      Collection.new(query, query.model.load(records, query))
     end
 
+    alias find_or_create     first_or_create
+    alias find_or_initialize first_or_new
+
     private
 
     def method_missing_with_find_by(method, *args, &block)
       if match = matches_dynamic_finder?(method)
-        finder = determine_finder(match)
+        finder          = determine_finder(match)
         attribute_names = extract_attribute_names_from_match(match)
 
-        conditions = {}
-        attribute_names.each {|key| conditions[key] = args.shift}
-
-        send(finder, conditions)
+        send(finder, attribute_names.zip(args).to_hash)
       else
         method_missing_without_find_by(method, *args, &block)
       end
@@ -39,4 +138,4 @@ module DataMapper
       match.captures.last.split('_and_')
     end
   end
-end
+end # module Model

data/spec/integration/ar-finders_spec.rb

@@ -1,16 +1,15 @@
-require 'pathname'
-require Pathname(__FILE__).dirname.expand_path.parent + 'spec_helper'
+require 'spec_helper'
 
 if HAS_SQLITE3 || HAS_MYSQL || HAS_POSTGRES
   describe "DataMapper::Resource" do
     after do
-     repository(:default).adapter.execute('DELETE from green_smoothies');
+     DataMapper.repository(:default).adapter.execute('DELETE from green_smoothies');
     end
 
     before(:all) do
       class ::GreenSmoothie
         include DataMapper::Resource
-        property :id, Integer, :serial => true
+        property :id, Serial
         property :name, String
 
         auto_migrate!(:default)
@@ -18,7 +17,7 @@ if HAS_SQLITE3 || HAS_MYSQL || HAS_POSTGRES
     end
 
     it "should find/create using find_or_create" do
-      repository(:default) do
+      DataMapper.repository(:default) do
         green_smoothie = GreenSmoothie.new(:name => 'Banana')
         green_smoothie.save
         GreenSmoothie.find_or_create({:name => 'Banana'}).id.should eql(green_smoothie.id)
@@ -27,14 +26,14 @@ if HAS_SQLITE3 || HAS_MYSQL || HAS_POSTGRES
     end
 
     it "should use find_by and use the name attribute to find a record" do
-      repository(:default) do
+      DataMapper.repository(:default) do
         green_smoothie = GreenSmoothie.create({:name => 'Banana'})
         green_smoothie.should == GreenSmoothie.find_by_name('Banana')
       end
     end
 
     it "should use find_all_by to find records using an attribute" do
-      repository(:default) do
+      DataMapper.repository(:default) do
         green_smoothie = GreenSmoothie.create({:name => 'Banana'})
         green_smoothie2 = GreenSmoothie.create({:name => 'Banana'})
         found_records = GreenSmoothie.find_all_by_name('Banana')
@@ -44,5 +43,191 @@ if HAS_SQLITE3 || HAS_MYSQL || HAS_POSTGRES
         end
       end
     end
+
+    ###
+
+    describe '#find_by_sql' do
+      before(:each) do
+        DataMapper.repository(:default) do
+          @resource = GreenSmoothie.create({:name => 'Banana'})
+        end
+      end
+
+      it 'should find the resource when given a string' do
+        DataMapper.repository(:default) do
+          found = GreenSmoothie.find_by_sql <<-SQL
+            SELECT id, name FROM green_smoothies LIMIT 1
+          SQL
+
+          found.should_not be_empty
+          found.first.should == @resource
+        end
+      end
+
+      it 'should find the resource when given an array containing SQL and bind values' do
+        DataMapper.repository(:default) do
+          found = GreenSmoothie.find_by_sql [<<-SQL, @resource.id]
+            SELECT id, name FROM green_smoothies WHERE id = ?
+          SQL
+
+          found.should_not be_empty
+          found.first.should == @resource
+        end
+      end
+
+      it 'should return an empty collection when nothing is found' do
+        DataMapper.repository(:default) do
+          found = GreenSmoothie.find_by_sql [<<-SQL, 0]
+            SELECT id, name FROM green_smoothies WHERE id = ?
+          SQL
+
+          found.should be_kind_of(DataMapper::Collection)
+          found.should be_empty
+        end
+      end
+
+      it 'should raise an error if no SQL string or Query is given' do
+        DataMapper.repository(:default) do
+          lambda { GreenSmoothie.find_by_sql nil }.should raise_error(ArgumentError, /requires a query/)
+        end
+      end
+
+      it 'should raise an error if an unacceptable argument is given' do
+        DataMapper.repository(:default) do
+          lambda { GreenSmoothie.find_by_sql :go }.should raise_error(ArgumentError)
+        end
+      end
+
+      it 'should accept a Query instance' do
+        query = GreenSmoothie.find_by_sql([<<-SQL, @resource.id]).query
+          SELECT id, name FROM green_smoothies WHERE id = ?
+        SQL
+
+        found = GreenSmoothie.find_by_sql(query)
+        found.should_not be_empty
+        found.first.should == @resource
+      end
+
+      # Options.
+
+      describe ':repository option' do
+        it 'should use repository identified by the given symbol' do
+          found = GreenSmoothie.find_by_sql <<-SQL, :repository => ENV['ADAPTER'].intern
+            SELECT id, name FROM green_smoothies LIMIT 1
+          SQL
+
+          found.repository.should == DataMapper.repository(ENV['ADAPTER'].intern)
+        end
+
+        it 'should use the default repository if no repository option is specified' do
+          found = GreenSmoothie.find_by_sql <<-SQL
+            SELECT id, name FROM green_smoothies LIMIT 1
+          SQL
+
+          found.repository.should == DataMapper.repository(:default)
+        end
+      end
+
+      describe ':reload option' do
+        it 'should reload existing resources in the identity map if given true' do
+          found = GreenSmoothie.find_by_sql <<-SQL, :reload => true
+            SELECT id, name FROM green_smoothies LIMIT 1
+          SQL
+
+          found.query.reload?.should be_true
+        end
+
+        it 'should not reload existing resources in the identity map if given false' do
+          found = GreenSmoothie.find_by_sql <<-SQL, :reload => false
+            SELECT id, name FROM green_smoothies LIMIT 1
+          SQL
+
+          found.query.reload?.should be_false
+        end
+
+        it 'should default to false' do
+          found = GreenSmoothie.find_by_sql <<-SQL
+            SELECT id, name FROM green_smoothies LIMIT 1
+          SQL
+
+          found.query.reload?.should be_false
+        end
+      end
+
+      describe ':properties option' do
+        it 'should accept an array of symbols' do
+          found = GreenSmoothie.find_by_sql <<-SQL, :properties => [:id, :name]
+            SELECT id, name FROM green_smoothies LIMIT 1
+          SQL
+
+          properties = found.first.loaded_properties
+          properties.should have(2).properties
+          properties.should include(GreenSmoothie.properties[:id])
+          properties.should include(GreenSmoothie.properties[:name])
+        end
+
+        it 'should accept a single Symbol' do
+          found = GreenSmoothie.find_by_sql <<-SQL, :properties => :id
+            SELECT id, name FROM green_smoothies LIMIT 1
+          SQL
+
+          properties = found.first.loaded_properties
+          properties.should have(1).properties
+          properties.should include(GreenSmoothie.properties[:id])
+        end
+
+        it 'should accept a PropertySet' do
+          found = GreenSmoothie.find_by_sql <<-SQL, :properties => GreenSmoothie.properties
+            SELECT id, name FROM green_smoothies LIMIT 1
+          SQL
+
+          properties = found.first.loaded_properties
+          properties.should have(2).properties
+          properties.should include(GreenSmoothie.properties[:id])
+          properties.should include(GreenSmoothie.properties[:name])
+        end
+
+        it 'should accept a single property' do
+          found = GreenSmoothie.find_by_sql <<-SQL, :properties => GreenSmoothie.properties[:id]
+            SELECT id, name FROM green_smoothies LIMIT 1
+          SQL
+
+          properties = found.first.loaded_properties
+          properties.should have(1).property
+          properties.first.should == GreenSmoothie.properties[:id]
+        end
+
+        it 'should accept an array of Properties' do
+          found = GreenSmoothie.find_by_sql <<-SQL, :properties => GreenSmoothie.properties.to_a
+            SELECT id, name FROM green_smoothies LIMIT 1
+          SQL
+
+          properties = found.first.loaded_properties
+          properties.should have(2).properties
+          properties.should include(GreenSmoothie.properties[:id])
+          properties.should include(GreenSmoothie.properties[:name])
+        end
+
+        it 'should use the given properties in preference over those in the SQL query' do
+          found = GreenSmoothie.find_by_sql <<-SQL, :properties => GreenSmoothie.properties
+            SELECT id, name FROM green_smoothies LIMIT 1
+          SQL
+
+          properties = found.first.loaded_properties
+          properties.should have(2).properties
+          properties.should include(GreenSmoothie.properties[:id])
+          properties.should include(GreenSmoothie.properties[:name])
+        end
+
+        it 'should use the default properties if none are specified' do
+          found = GreenSmoothie.find_by_sql <<-SQL
+            SELECT id, name FROM green_smoothies LIMIT 1
+          SQL
+
+          found.first.loaded_properties.should == GreenSmoothie.properties
+        end
+      end
+    end # find_by_sql
+
   end
 end

data/spec/spec.opts

@@ -1 +1,2 @@
 --colour
+--loadby random

data/spec/spec_helper.rb

@@ -1,7 +1,14 @@
-require 'pathname'
 require 'rubygems'
 
-require Pathname(__FILE__).dirname.expand_path.parent + 'lib/dm-ar-finders'
+# use local dm-core if running from a typical dev checkout.
+lib = File.join('..', '..', 'dm-core', 'lib')
+$LOAD_PATH.unshift(lib) if File.directory?(lib)
+require 'dm-core'
+
+# Support running specs with 'rake spec' and 'spec'
+$LOAD_PATH.unshift('lib') unless $LOAD_PATH.include?('lib')
+
+require 'dm-ar-finders'
 
 def load_driver(name, default_uri)
   return false if ENV['ADAPTER'] != name.to_s
@@ -9,10 +16,6 @@ def load_driver(name, default_uri)
   begin
     DataMapper.setup(name, ENV["#{name.to_s.upcase}_SPEC_URI"] || default_uri)
     DataMapper::Repository.adapters[:default] =  DataMapper::Repository.adapters[name]
-
-    FileUtils.touch LOG_PATH
-    DataMapper::Logger.new(LOG_PATH, :debug)
-    at_exit { DataMapper.logger.close }
     true
   rescue LoadError => e
     warn "Could not load do_#{name}: #{e}"
@@ -21,7 +24,7 @@ def load_driver(name, default_uri)
 end
 
 ENV['ADAPTER'] ||= 'sqlite3'
-LOG_PATH     = Pathname(__FILE__).dirname.expand_path.to_s + '/sql.log'
+
 HAS_SQLITE3  = load_driver(:sqlite3,  'sqlite3::memory:')
 HAS_MYSQL    = load_driver(:mysql,    'mysql://localhost/dm_core_test')
 HAS_POSTGRES = load_driver(:postgres, 'postgres://postgres@localhost/dm_core_test')

data/tasks/install.rb

@@ -4,7 +4,7 @@ end
 
 desc "Install #{GEM_NAME} #{GEM_VERSION}"
 task :install => [ :package ] do
-  sudo_gem "install --local pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources"
+  sudo_gem "install pkg/#{GEM_NAME}-#{GEM_VERSION} --no-update-sources"
 end
 
 desc "Uninstall #{GEM_NAME} #{GEM_VERSION}"

data/tasks/spec.rb

@@ -1,6 +1,4 @@
 begin
-  gem 'rspec', '~>1.2'
-  require 'spec'
   require 'spec/rake/spectask'
 
   task :default => [ :spec ]
@@ -8,16 +6,18 @@ begin
   desc 'Run specifications'
   Spec::Rake::SpecTask.new(:spec) do |t|
     t.spec_opts << '--options' << 'spec/spec.opts' if File.exists?('spec/spec.opts')
-    t.spec_files = Pathname.glob((ROOT + 'spec/**/*_spec.rb').to_s).map { |f| f.to_s }
+    t.libs      << 'lib' << 'spec' # needed for CI rake spec task, duplicated in spec_helper
 
     begin
-      gem 'rcov', '~>0.8'
+      require 'rcov'
       t.rcov = JRUBY ? false : (ENV.has_key?('NO_RCOV') ? ENV['NO_RCOV'] != 'true' : true)
       t.rcov_opts << '--exclude' << 'spec'
       t.rcov_opts << '--text-summary'
       t.rcov_opts << '--sort' << 'coverage' << '--sort-reverse'
     rescue LoadError
       # rcov not installed
+    rescue SyntaxError
+      # rcov syntax invalid
     end
   end
 rescue LoadError

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dm-ar-finders
 version: !ruby/object:Gem::Version 
-  version: 0.9.11
+  version: 0.10.0
 platform: ruby
 authors: 
 - John W Higgins
@@ -9,19 +9,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-03-29 00:00:00 -07:00
+date: 2009-09-16 00:00:00 -07:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: dm-core
-  type: :runtime
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - "="
-      - !ruby/object:Gem::Version 
-        version: 0.9.11
-    version: 
+dependencies: []
+
 description: DataMapper plugin providing ActiveRecord-style finders
 email: 
 - john [a] wishVPS [d] com
@@ -30,15 +21,15 @@ executables: []
 extensions: []
 
 extra_rdoc_files: 
-- README.txt
+- README.rdoc
 - LICENSE
 - TODO
-- History.txt
+- History.rdoc
 files: 
-- History.txt
+- History.rdoc
 - LICENSE
 - Manifest.txt
-- README.txt
+- README.rdoc
 - Rakefile
 - TODO
 - lib/dm-ar-finders.rb
@@ -49,11 +40,13 @@ files:
 - tasks/install.rb
 - tasks/spec.rb
 has_rdoc: true
-homepage: http://github.com/sam/dm-more/tree/master/dm-ar-finders
+homepage: http://github.com/datamapper/dm-more/tree/master/dm-ar-finders
+licenses: []
+
 post_install_message: 
 rdoc_options: 
 - --main
-- README.txt
+- README.rdoc
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -71,9 +64,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: datamapper
-rubygems_version: 1.3.1
+rubygems_version: 1.3.5
 signing_key: 
-specification_version: 2
+specification_version: 3
 summary: DataMapper plugin providing ActiveRecord-style finders
 test_files: []