active_fedora_finders 0.4.0 → 0.5.0

data/README.textile

@@ -14,16 +14,20 @@ SUPPORTED_ALTS = [:cdate, :create_date, :mdate, :modified_date, :owner_id]
 Example:
 
 class MyModel < ActiveFedora::Base
-  include ActiveFedora::Finders
+  include ActiveFedora::RepositoryQuerying
 end
 
-obj = MyModel.find_by_identifier("fedora-system:ContentModel-3.0")
+obj = MyModel.search_repo(pid: "fedora-system:ContentModel-3.0").first!
 
 **
 
 Roadmap:
 
 0.1: dynamic finders, bang support
-0.2: support or_create|initialize
-0.3: support _all and _last
-0.4: support scopes
+0.2 rubydora 1.x
+0.3: Rubydora 1.0...2.0
+0.4: AF 6.7+
+0.5: Rails 4 and Hydra 7
+0.6: support or_create|initialize
+0.7: support _all and _last
+0.8: support scopes

data/active_fedora_finders.gemspec

@@ -9,12 +9,12 @@ Gem::Specification.new do |s|
   s.authors     = ["Benjamin Armintor"]
   s.email       = ["armintor@gmail.com"]
   s.homepage    = %q{https://github.com/barmintor/active_fedora_finders}
-  s.summary     = %q{A library for adding ActiveRecord-style dynamic finders to ActiveFedora::Base subclasses.}
-  s.description = %q{A mixin library for ActiveFedora. Generates dynamic finder methods operating against the FCRepo object search terms (DCES elements and object properties).}
+  s.summary     = %q{A library for adding ActiveRecord-style relations to ActiveFedora::Base subclasses.}
+  s.description = %q{A mixin library for ActiveFedora. Realtion methods operating against the FCRepo object search terms (DCES elements and object properties).}
 
   s.rubygems_version = %q{1.3.7}
 
-  s.add_dependency('active-fedora', '>=6.7.0')
+  s.add_dependency('active-fedora', '>=7.0.0')
   s.add_dependency('activerecord')
   s.add_dependency('nokogiri')
   s.add_development_dependency("yard")

data/lib/active_fedora_finders.rb

@@ -1,119 +1,22 @@
-require 'active-fedora'
+require 'active_fedora'
 require 'active_support'
+require 'active_support/deprecation'
 require 'active_record'
 require 'active_record/errors' # RecordNotFound is not autoloaded, and ActiveRecord::Base not referenced
-module ActiveFedora
-  module Finders
-    extend ActiveSupport::Concern
-    extend ActiveSupport::Autoload
-    autoload :Version
-
-    SINGLE_VALUE_FIELDS = [:pid, :cDate, :mDate, :label]
-    SYSTEM_FIELDS = [:ownerId].concat(SINGLE_VALUE_FIELDS)
-    DC_FIELDS = [:contributor, :coverage, :creator, :date, :description, :format,
-                 :identifier, :language, :publisher, :relation, :rights, :source,
-                 :subject, :title, :type ]
-    SUPPORTED_ALTS = [:cdate, :create_date, :mdate, :modified_date, :owner_id]
-    ALL_FIELDS = [].concat(SYSTEM_FIELDS).concat(DC_FIELDS)
-    FIELD_KEYS = begin
-      fk = Hash[ALL_FIELDS.map {|a| [a.to_s, a]}]
-      fk["cdate"] = :cDate
-      fk["create_date"] = :cDate
-      fk["mdate"] = :mDate
-      fk["modified_date"] = :mDate
-      fk["owner_id"] = :ownerId
-      fk
-    end
-
-    module ClassMethods    
-        
-      # modeled after ActiveRecord::FinderMethods.find_by_attributes
-      def find_by_attributes(match, attribute_names, *args)
-        conditions = Hash[attribute_names.map {|a| [a, args[attribute_names.index(a)]]}]
-        result = fcrepo_find(match, conditions)
-        if match.bang? && result.blank?
-          raise ActiveRecord::RecordNotFound, "Couldn't find #{self.name} with #{conditions.to_a.collect {|p| p.join(' = ')}.join(', ')}"
-        else
-          yield(result) if block_given?
-          result
-        end
-      end
-    
-      def fcrepo_find(match, args)
-        parms = args.dup
-        maxResults = (match.nil? or match.finder == :first) ? 1 : 25 # find_all and find_last not yet supported    
-        query = ""
-        parms.each { |key, val|
-          if SINGLE_VALUE_FIELDS.include? key
-            query.concat "#{key.to_s}=#{val.to_s} "
-          else
-            query.concat "#{key.to_s}~#{val.to_s} "
-          end
-        }
-        query.strip!
-        results = []
-        if ActiveFedora.config.sharded?
-          (0...ActiveFedora.config.credentials.length).each {|ix|
-            ActiveFedora::Base.fedora_connection[ix] ||= ActiveFedora::RubydoraConnection.new(ActiveFedora.config.credentials[ix])
-            rubydora = ActiveFedora::Base.fedora_connection[ix].connection
-            if results.length <= maxResults
-              results.concat process_results(rubydora.find_objects(:query=>query,:pid=>'true', :maxResults=>maxResults))
-            end
-          }
-        else
-          ActiveFedora::Base.fedora_connection[0] ||= ActiveFedora::RubydoraConnection.new(ActiveFedora.config.credentials)
-          rubydora = ActiveFedora::Base.fedora_connection[0].connection
-          results.concat process_results(rubydora.find_objects(:query=>query,:pid=>'true', :maxResults=>maxResults))
-        end
-        return (maxResults == 1) ? results[0] : results
-      end
-      
-      def process_results(results)
-        results = Nokogiri::XML.parse(results)
-        results = results.xpath('/f:result/f:resultList/f:objectFields/f:pid',{'f'=>"http://www.fedora.info/definitions/1/0/types/"})
-        results.collect { |result| find_one(result.text) }
-      end
-      
-      # this method is patterned after an analog in ActiveRecord::DynamicMatchers
-      def all_attributes_exists?(attribute_names)
-        attribute_names.reduce(true) {|result, att| ALL_FIELDS.include? att or SUPPORTED_ALTS.include? att}
-      end
-      
-      def normalize_attribute_names!(attribute_names)
-        field_keys = attribute_names.map {|val| FIELD_KEYS[val] or val}
-        attribute_names.replace field_keys
-      end
-      
-      # adapted from ActiveRecord::DynamicMatchers
-      def method_missing(method_id, *arguments, &block)
-        if match = (ActiveRecord::DynamicFinderMatch.match(method_id) || ActiveRecord::DynamicScopeMatch.match(method_id))
-          attribute_names = match.attribute_names
-          normalize_attribute_names!(attribute_names)
-          super unless all_attributes_exists?(attribute_names)
-          if !(match.is_a?(ActiveRecord::DynamicFinderMatch) && match.instantiator? && arguments.first.is_a?(Hash)) && arguments.size < attribute_names.size
-            method_trace = "#{__FILE__}:#{__LINE__}:in `#{method_id}'"
-            backtrace = [method_trace] + caller
-            raise ArgumentError, "wrong number of arguments (#{arguments.size} for #{attribute_names.size})", backtrace
-          end
-          if match.respond_to?(:scope?) && match.scope?
-            self.class_eval <<-METHOD, __FILE__, __LINE__ + 1
-              def self.#{method_id}(*args)                                    # def self.scoped_by_user_name_and_password(*args)
-                attributes = Hash[[:#{attribute_names.join(',:')}].zip(args)] #   attributes = Hash[[:user_name, :password].zip(args)]
-                                                                              #
-                scoped(:conditions => attributes)                             #   scoped(:conditions => attributes)
-              end                                                             # end
-            METHOD
-            send(method_id, *arguments)
-          elsif match.finder?
-            find_by_attributes(match, attribute_names, *arguments, &block)
-          elsif match.instantiator?
-            find_or_instantiator_by_attributes(match, attribute_names, *arguments, &block)
-          end
-        else
-          super
-        end
-      end
-      
+module ActiveFedora::FinderMethods::RepositoryMethods
+  autoload :Version, 'active_fedora_finders/version'
+  autoload :Relation, 'active_fedora_finders/relation'
+  extend ActiveSupport::Concern
+  module ClassMethods
+    def search_repo(conditions={})
+      Relation.new(self).where!(conditions)
     end
   end
+end
+module ActiveFedora::Finders
+  extend ActiveSupport::Concern
+  included do
+    ActiveSupport::Deprecation.warn("ActiveFedora::Finders will be removed in favor of ActiveFedora::FinderMethods::RepositoryMethods")
+    include ActiveFedora::FinderMethods::RepositoryMethods
+  end    
 end

data/lib/active_fedora_finders/relation.rb

@@ -0,0 +1,152 @@
+require 'active_record/errors'
+module ActiveFedora::FinderMethods::RepositoryMethods
+  class Relation
+
+    SINGLE_VALUE_FIELDS = [:pid, :cDate, :mDate, :label]
+    SYSTEM_FIELDS = [:ownerId].concat(SINGLE_VALUE_FIELDS)
+    DC_FIELDS = [:contributor, :coverage, :creator, :date, :description, :format,
+                 :identifier, :language, :publisher, :relation, :rights, :source,
+                 :subject, :title, :type ]
+    SUPPORTED_ALTS = [:cdate, :create_date, :mdate, :modified_date, :owner_id]
+    ALL_FIELDS = [].concat(SYSTEM_FIELDS).concat(DC_FIELDS)
+    FIELD_KEYS = begin
+      fk = Hash[ALL_FIELDS.map {|a| [a.to_s, a]}]
+      fk["cdate"] = :cDate
+      fk["create_date"] = :cDate
+      fk["mdate"] = :mDate
+      fk["modified_date"] = :mDate
+      fk["owner_id"] = :ownerId
+      fk
+    end
+
+    attr_reader :loaded
+    attr_accessor :default_scoped
+    alias :loaded? :loaded
+
+    def initialize(klass, values = nil)
+      @klass = klass
+      @loaded = false
+      @values = values || {}
+    end
+
+    def reset
+      spawn.reset!
+    end
+
+    def reset!
+      @values.delete_if {|k,v| true}
+      @loaded = false
+      @records = nil
+      self
+    end
+
+    def spawn
+      self.class.new(@klass, @values.dup)
+    end
+
+    def where(conditions={})
+      spawn.where!(conditions)
+    end
+
+    def where!(conditions={})
+      query = (@values[:query] ||= {})
+      conditions.each do |k,v|
+        k = FIELD_KEYS[k.to_s]
+        v = Array(v)
+        if query[k] and not SINGLE_VALUE_FIELDS.include?(k)
+          query[k] = (Array(query[k]) + v).uniq
+        else
+          query[k] = v[1] ? v : v.first
+        end
+      end
+      self
+    end
+
+    def limit(limit_value)
+      spawn.limit!(limit_value)
+    end
+
+    def limit!(limit_value)
+      @values[:maxResults] = limit_value
+      self
+    end
+
+    def to_a
+      load
+      @records
+    end
+
+    def load
+      @records = fcrepo_find(@values)
+      @loaded = true
+    end
+
+    def first
+      if loaded?
+        @records.first
+      else
+        @first ||= limit(1).to_a[0]
+      end
+    end
+
+    def first!
+      r = first()
+      raise ActiveRecord::RecordNotFound.new(@values.inspect) unless r
+      r
+    end
+
+    def find_by(conditions={})
+      where(conditions).to_a.first
+    end
+
+    def find_by!(conditions={})
+      r = find_by(conditions)
+      raise ActiveRecord::RecordNotFound.new(conditions.inspect) unless r
+      r
+    end
+
+    private
+    def fcrepo_find(args)
+      parms = args.dup
+      parms[:query] ||= {}
+      if parms[:query][:pid] and parms[:query].size == 1
+        return [@klass.find(parms[:query][:pid], cast: false)]
+      end
+      maxResults = parms[:maxResults] || 25 # find_all and find_last not yet supported    
+      
+      query = ""
+      parms.fetch(:query, {}).each { |key, val|
+        if SINGLE_VALUE_FIELDS.include? key
+          query.concat "#{key.to_s}=#{val.to_s} "
+        else
+          Array(val).each do |v|
+            query.concat "#{key.to_s}~#{v.to_s} "
+          end
+        end
+      }
+      query.strip!
+      results = []
+      if ActiveFedora.config.sharded?
+        (0...ActiveFedora.config.credentials.length).each {|ix|
+          ActiveFedora::Base.fedora_connection[ix] ||= ActiveFedora::RubydoraConnection.new(ActiveFedora.config.credentials[ix])
+          rubydora = ActiveFedora::Base.fedora_connection[ix].connection
+          if results.length <= maxResults
+            results.concat process_results(rubydora.find_objects(:query=>query,:pid=>'true', :maxResults=>maxResults))
+          end
+        }
+      else
+        ActiveFedora::Base.fedora_connection[0] ||= ActiveFedora::RubydoraConnection.new(ActiveFedora.config.credentials)
+        rubydora = ActiveFedora::Base.fedora_connection[0].connection
+        results.concat process_results(rubydora.find_objects(:query=>query,:pid=>'true', :maxResults=>maxResults))
+      end
+      return results
+    end
+
+    def process_results(results)
+      results = Nokogiri::XML.parse(results)
+      results = results.xpath('/f:result/f:resultList/f:objectFields/f:pid',{'f'=>"http://www.fedora.info/definitions/1/0/types/"})
+      results.collect { |result| @klass.find(result.text, cast: false) }
+    end
+
+  end
+end	

data/lib/active_fedora_finders/version.rb

@@ -1,5 +1,5 @@
 module ActiveFedora
-  module Finders
-    VERSION = '0.4.0'
+	module Finders
+      VERSION = '0.5.0'
   end
 end

data/spec/finders_spec.rb

@@ -2,53 +2,128 @@ require 'spec_helper'
 require 'config_helper'
 
 describe ActiveFedora::Finders do
-  class TestBase < ActiveFedora::Base
-    include ActiveFedora::Finders
+  before( :all) do
+    class SpecModel < ::ActiveFedora::Base
+      include ActiveFedora::Finders
+    end
+    expect(SpecModel.new).to be_kind_of ActiveFedora::Base
+    expect(SpecModel).to respond_to :find
+  end
+  after(:all) do
+    Object.send(:remove_const, :SpecModel)
   end
+
   FCREPO_ID = 'fedora-system:ContentModel-3.0'
   FCREPO_DATE = '2012-06-01T12:34:56.000Z'
   
   describe "finder methods" do
+    let(:connection) { double('ActiveFedora::RubydoraConnection') }
+    let(:rubydora) { double('Rubydora::Connection') }
+    before :each do
+      connection.stub(:connect) { rubydora }
+      connection.stub(:connection) { rubydora }
+      ActiveFedora::Base.fedora_connection[0]= connection
+    end
+
     describe "default find method" do
       it "should call the normal find method when passed a string" do
-        TestBase.expects(:find_one).returns TestBase.new
-        TestBase.find(FCREPO_ID)
+        all = double('ActiveFedora::Relation')
+        SpecModel.stub(:all) {all}
+        all.should_receive(:find).with(FCREPO_ID).and_return(SpecModel.new)
+        SpecModel.find(FCREPO_ID)
       end
     end
+
     describe "dynamic finder methods" do
-      it "should call .find_by_conditions with correct attributes" do
-        TestBase.expects(:fcrepo_find).with(is_a(ActiveRecord::DynamicFinderMatch), :identifier => FCREPO_ID).returns(TestBase.new)
-        TestBase.find_by_identifier(FCREPO_ID)
-        TestBase.expects(:fcrepo_find).with(is_a(ActiveRecord::DynamicFinderMatch), :cDate => FCREPO_DATE, :identifier => FCREPO_ID).returns(TestBase.new)
-        TestBase.find_by_create_date_and_identifier(FCREPO_DATE, FCREPO_ID)
+      it "should shortcut if only given a PID" do
+        SpecModel.should_receive(:find).with(FCREPO_ID, :cast=>false).and_return(SpecModel.new)
+        expect(SpecModel.search_repo.where(:pid => FCREPO_ID).first).to be_a SpecModel
+      end
+      it "should call .find_objects with correct attributes" do
+        rubydora.should_receive(:find_objects).with(hash_including(query: "identifier~#{FCREPO_ID}")).and_return(fixture('find_one.xml'))
+        SpecModel.should_receive(:find).with(FCREPO_ID, cast: false).and_return(SpecModel.new)
+        SpecModel.search_repo.where(:identifier => FCREPO_ID).load
+      end
+      it "should call .find_objects with multiple attributes" do
+        rubydora.should_receive(:find_objects).with(hash_including(query: "cDate=#{FCREPO_DATE} date~#{FCREPO_DATE} identifier~#{FCREPO_ID}")).and_return(fixture('find_one.xml'))
+        SpecModel.should_receive(:find).with(FCREPO_ID, cast: false).and_return(SpecModel.new)
+        SpecModel.search_repo.where(create_date: FCREPO_DATE).where(date: FCREPO_DATE, identifier: FCREPO_ID).load
       end
       it "should return an ActiveFedora::Base when there is a single result" do
-        stubfedora = mock("Fedora")
-        stubfedora.expects(:connection).returns(mock("Connection", :find_objects =>fixture('find_one.xml')))
-        TestBase.expects(:find_one).with(FCREPO_ID).returns TestBase.new(:pid=>FCREPO_ID)
-        ActiveFedora::Base.fedora_connection = [stubfedora]
-        TestBase.find_by_identifier(FCREPO_ID).should be_a TestBase
+        rubydora.stub(:find_objects =>fixture('find_one.xml'))
+        SpecModel.should_receive(:find).with(FCREPO_ID, cast: false).and_return SpecModel.new(:pid=>FCREPO_ID)
+        expect(SpecModel.search_repo.find_by(:identifier => FCREPO_ID)).to be_a SpecModel
       end
       it "should return an array when there are multiple results" do
-        stubfedora = mock("Fedora")
-        stubfedora.expects(:connection).returns(mock("Connection", :find_objects =>fixture('find_multiple.xml')))
-        ActiveFedora::Base.fedora_connection = [stubfedora]
-        TestBase.expects(:find_one).with(FCREPO_ID).returns TestBase.new(:pid=>FCREPO_ID)
-        TestBase.expects(:find_one).with("demo:1").returns TestBase.new(:pid=>"demo:1")
-        TestBase.find_all_by_source("test").should be_a Array
-      end
-      it "should throw an error when no results and a bang" do
-        stubfedora = mock("Fedora")
-        stubfedora.expects(:connection).returns(mock("Connection", :find_objects =>fixture('find_none.xml')))
-        ActiveFedora::Base.fedora_connection = [stubfedora]
-        #ActiveRecord::Base
+        SpecModel.stub(:find).with(FCREPO_ID, cast: false) {SpecModel.new(:pid=>FCREPO_ID)}
+        SpecModel.stub(:find).with("demo:1", cast: false) {SpecModel.new(:pid=>"demo:1")}
+        rubydora.should_receive(:find_objects).with(query: "source~test", pid: "true", maxResults: 25).and_return(fixture('find_multiple.xml'))
+        expect(SpecModel.search_repo.where(source: "test").to_a).to be_a Array
+      end
+    end
+    describe "#first" do
+      let(:pid) {'dummy:1'}
+      it "should return nil when no results" do
+        rubydora.stub(:find_objects) {fixture('find_none.xml')}
+        expect(SpecModel.search_repo.where(:identifier =>pid).first).to be_nil
+      end
+      it "should work with one result" do
+        rubydora.stub(:find_objects) {fixture('find_one.xml')}
+        SpecModel.stub(:find).with(FCREPO_ID, cast: false) {(SpecModel.new)}
+        expect(SpecModel.search_repo.where(:identifier =>pid).first).to be_a SpecModel
+      end
+      it "should work with multiple results" do
+        rubydora.stub(:find_objects) {fixture('find_multiple.xml')}
+        SpecModel.stub(:find).with(FCREPO_ID, cast: false) {(SpecModel.new)}
+        SpecModel.stub(:find).with('demo:1', cast: false) {(SpecModel.new)}
+        expect(SpecModel.search_repo.where(:identifier =>pid).first).to be_a SpecModel
+      end
+    end
+    describe "#find_by!" do
+      let(:pid) {'dummy:1'}
+      it "should throw an error when no results" do
+        rubydora.stub(:find_objects) {fixture('find_none.xml')}
+        begin
+          SpecModel.search_repo.find_by!(:identifier =>pid)
+          fail "should not successfully return from bang method with no results"
+        rescue Exception => e
+          e.should be_a ActiveRecord::RecordNotFound
+        end
+      end
+      it "should with one result" do
+        rubydora.stub(:find_objects) {fixture('find_one.xml')}
+        SpecModel.stub(:find).with(FCREPO_ID, cast: false) {(SpecModel.new)}
+        expect(SpecModel.search_repo.find_by!(:identifier =>pid)).to be_a SpecModel
+      end
+      it "should with multiple results" do
+        rubydora.stub(:find_objects) {fixture('find_multiple.xml')}
+        SpecModel.stub(:find).with(FCREPO_ID, cast: false) {(SpecModel.new)}
+        SpecModel.stub(:find).with('demo:1', cast: false) {(SpecModel.new)}
+        expect(SpecModel.search_repo.find_by!(:identifier =>pid)).to be_a SpecModel
+      end
+    end
+    describe "#first!" do
+      let(:pid) {'demo:1'}
+      it "should throw an error when no results" do
+        rubydora.stub(:find_objects) {fixture('find_none.xml')}
         begin
-          TestBase.find_by_identifier!("dummy:1")
+          SpecModel.search_repo.where(:identifier =>pid).first!
           fail "should not successfully return from bang method with no results"
         rescue Exception => e
           e.should be_a ActiveRecord::RecordNotFound
         end
       end
+      it "should work with one result" do
+        rubydora.stub(:find_objects) {fixture('find_one.xml')}
+        SpecModel.stub(:find).with(FCREPO_ID, cast: false) {(SpecModel.new)}
+        expect(SpecModel.search_repo.where(:identifier =>pid).first!).to be_a SpecModel
+      end
+      it "should work with multiple results" do
+        rubydora.stub(:find_objects) {fixture('find_multiple.xml')}
+        SpecModel.stub(:find).with(FCREPO_ID, cast: false) {(SpecModel.new)}
+        SpecModel.stub(:find).with('demo:1', cast: false) {(SpecModel.new)}
+        expect(SpecModel.search_repo.where(:identifier =>pid).first!).to be_a SpecModel
+      end
     end
   end
 end

data/spec/spec_helper.rb

@@ -12,12 +12,11 @@ end
 
 require 'active-fedora'
 require 'rspec'
-
+include RSpec::Mocks::ArgumentMatchers
 require 'support/mock_fedora'
 require 'active_fedora_finders'
 
 RSpec.configure do |config|
-  config.mock_with :mocha
   config.color_enabled = true
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_fedora_finders
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-21 00:00:00.000000000 Z
+date: 2014-04-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active-fedora
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 6.7.0
+        version: 7.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 6.7.0
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -139,8 +139,8 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 0.10.5
-description: A mixin library for ActiveFedora. Generates dynamic finder methods operating
-  against the FCRepo object search terms (DCES elements and object properties).
+description: A mixin library for ActiveFedora. Realtion methods operating against
+  the FCRepo object search terms (DCES elements and object properties).
 email:
 - armintor@gmail.com
 executables: []
@@ -155,6 +155,7 @@ files:
 - Rakefile
 - active_fedora_finders.gemspec
 - lib/active_fedora_finders.rb
+- lib/active_fedora_finders/relation.rb
 - lib/active_fedora_finders/version.rb
 - lib/tasks/af_finders_dev.rake
 - spec/config_helper.rb
@@ -187,8 +188,7 @@ rubyforge_project:
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: A library for adding ActiveRecord-style dynamic finders to ActiveFedora::Base
-  subclasses.
+summary: A library for adding ActiveRecord-style relations to ActiveFedora::Base subclasses.
 test_files:
 - spec/config_helper.rb
 - spec/finders_spec.rb