ddr-models 2.4.0.rc4 → 2.4.0.rc5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2406a157a006c5fff980da281a457b140c467e27
-  data.tar.gz: ca9c89caf184aa999333ef3781373fa71137c408
+  metadata.gz: a57bdb43e8f09d8bba57f543fa677e6f584d49e0
+  data.tar.gz: aaf3160fc9732099da710cff89d874701f2c9432
 SHA512:
-  metadata.gz: 82dfb88bdb1cdb4cde005ce04ad8153ae2742638d8eb4a79f697d68f8fb4a4b7524b1885c105257a0036a2da50dc66741bf0f37dbea64ac447f2f536977dd209
-  data.tar.gz: 1441428287cdcdb26c8a9e8337520e15b5b384974da1acd7ae525a21c8f09da06172ebe37222b18fa99e420c4e31fd7d4e875977ff419da31a6ca28ac7ce4033
+  metadata.gz: dbb52a96b1ea4168b8bc8a0d7cc813b425b3e407f9ce5a13d1a330a176c1684e039c3195182bf615f3199d13fc8465b3765dbc97c95bc6be47822feba9fbb7a1
+  data.tar.gz: d8f17c7f174c712105de7c53a6107fafb216fb6121655b9e439adeb886cf359f8c524edd06a7a9e2123e252ee0a05a2408fba4da5e2ee66762c3fc4561ce2bbc

data/.travis.yml

@@ -1,11 +1,11 @@
 language: ruby
 before_install:
+  - sudo apt-get update -qq
   - sudo apt-get install libvips-dev
+  - gem install bundler
+bundler_args: --without production
 rvm:
-  - 2.1
+  - 2.1.5
 script: "bundle exec rake ci"
-cache:
-  - bundler
-  - apt
 env:
   - DDR_AUX_API_URL=http://localhost:3000/api

data/ddr-models.gemspec

@@ -34,7 +34,7 @@ Gem::Specification.new do |s|
   s.add_dependency "ddr-antivirus", "~> 2.1.1"
   s.add_dependency "virtus", "~> 1.0.5"
 
-  s.add_development_dependency "bundler", "~> 1.7"
+  s.add_development_dependency "bundler", "~> 1.11"
   s.add_development_dependency "rake"
   s.add_development_dependency "sqlite3"
   s.add_development_dependency "rspec-rails", "~> 3.1"

data/lib/ddr/index.rb

@@ -7,17 +7,16 @@ module Ddr
     autoload :CSVQueryResult
     autoload :DocumentBuilder
     autoload :Field
+    autoload :FieldAttribute
     autoload :Fields
     autoload :Filter
     autoload :Filters
     autoload :LegacyLicenseFields
-    autoload :Queries
     autoload :Query
     autoload :QueryBuilder
     autoload :QueryClause
     autoload :QueryParams
     autoload :QueryResult
-    autoload :QueryValue
     autoload :Response
     autoload :SortOrder
     autoload :UniqueKeyField

data/lib/ddr/index/field_attribute.rb

@@ -0,0 +1,18 @@
+require "virtus"
+
+module Ddr::Index
+  class FieldAttribute < Virtus::Attribute
+
+    def coerce(value)
+      case value
+      when Field
+        value
+      when String
+        Field.new(value)
+      when Symbol
+        Fields.get(value)
+      end
+    end
+
+  end
+end

data/lib/ddr/index/filter.rb

@@ -1,61 +1,93 @@
 require "forwardable"
+require "virtus"
 
 module Ddr::Index
   class Filter
+    include Virtus.model
 
-    class << self
-      extend Forwardable
+    attribute :clauses, Array, default: [ ]
 
-      def_delegators :new, :raw, :where, :absent, :present, :negative, :before, :before_days
+    def ==(other)
+      other.instance_of?(self.class) && (other.clauses == self.clauses)
     end
 
-    attr_accessor :clauses
+    module Api
+      def raw(*clauses)
+        self.clauses += clauses
+        self
+      end
 
-    def initialize(clauses = nil)
-      @clauses = Array(clauses)
-    end
+      def term(conditions)
+        self.clauses += conditions.map { |f, v| QueryClause.term(f, v) }
+        self
+      end
 
-    # Adds clause (String) w/o escaping
-    def raw(*clauses)
-      self.clauses.push *clauses
-      self
-    end
+      def where(conditions)
+        self.clauses += conditions.map { |f, v| QueryClause.where(f, v) }
+        self
+      end
 
-    def where(conditions)
-      clauses = conditions.map do |field, value|
-        values = Array(value)
-        if values.size > 1
-          QueryClause.or_values(field, values)
-        else
-          QueryClause.term(field, values.first)
-        end
+      def absent(field)
+        self.clauses << QueryClause.absent(field)
+        self
       end
-      raw *clauses
-    end
 
-    def absent(*args)
-      raw QueryClause.absent(*args)
-    end
+      def present(field)
+        self.clauses << QueryClause.present(field)
+        self
+      end
 
-    def present(*args)
-      raw QueryClause.present(*args)
-    end
+      def negative(field, value)
+        self.clauses << QueryClause.negative(field, value)
+        self
+      end
 
-    def negative(*args)
-      raw QueryClause.negative(*args)
-    end
+      def before(field, value)
+        self.clauses << QueryClause.before(field, value)
+        self
+      end
 
-    def before(*args)
-      raw QueryClause.before(*args)
+      def before_days(field, value)
+        self.clauses << QueryClause.before_days(field, value)
+        self
+      end
     end
 
-    def before_days(*args)
-      raw QueryClause.before_days(*args)
-    end
+    module ClassMethods
+      extend Forwardable
+
+      delegate Api.public_instance_methods => :new_filter
+
+      def has_content
+        where active_fedora_model: [ "Component", "Attachment", "Target" ]
+      end
+
+      def is_governed_by(object_or_id)
+        term is_governed_by: internal_uri(object_or_id)
+      end
+
+      def is_member_of_collection(object_or_id)
+        term is_member_of_collection: internal_uri(object_or_id)
+      end
+
+      private
+
+      def internal_uri(object_or_id)
+        if object_or_id.respond_to?(:internal_uri)
+          object_or_id.internal_uri
+        else
+          ActiveFedora::Base.internal_uri(object_or_id)
+        end
+      end
+
+      def new_filter
+        Filter.new
+      end
 
-    def ==(other)
-      other.instance_of?(self.class) && (other.clauses == self.clauses)
     end
 
+    include Api
+    extend ClassMethods
+
   end
 end

data/lib/ddr/index/filters.rb

@@ -2,16 +2,11 @@ module Ddr::Index
   module Filters
     extend Deprecation
 
-    def self.has_content
-      Filter.where(Fields::ACTIVE_FEDORA_MODEL => ["Component", "Attachment", "Target"])
-    end
-
-    def self.is_governed_by(object_or_id)
-      Filter.where(Fields::IS_GOVERNED_BY => internal_uri(object_or_id))
-    end
-
-    def self.is_member_of_collection(object_or_id)
-      Filter.where(Fields::IS_MEMBER_OF_COLLECTION => internal_uri(object_or_id))
+    def self.is_governed_by(pid)
+      Deprecation.warn(self,
+                       "`Ddr::Index:Filters.is_governed_by` is deprecated and will be removed in ddr-models 3.0." \
+                       " Use `Ddr::Index::Filter.is_governed_by` instead.")
+      Filter.is_governed_by(pid)
     end
 
     private
@@ -20,20 +15,12 @@ module Ddr::Index
       if name == :HAS_CONTENT
         Deprecation.warn(self,
                          "`Ddr::Index::Filters::#{name}` is deprecated and will be removed in ddr-models 3.0." \
-                         " Use `Ddr::Index::Filters.has_content` instead.")
-        has_content
+                         " Use `Ddr::Index::Filter.has_content` instead.")
+        Filter.has_content
       else
         super
       end
     end
 
-    def self.internal_uri(object_or_id)
-      if object_or_id.respond_to?(:internal_uri)
-        object_or_id.internal_uri
-      else
-        ActiveFedora::Base.internal_uri(object_or_id)
-      end
-    end
-
   end
 end

data/lib/ddr/index/query.rb

@@ -7,12 +7,13 @@ module Ddr::Index
     extend Forwardable
 
     attribute :q,       String
-    attribute :fields,  Array[String], default: [ ]
-    attribute :filters, Array[Filter], default: [ ]
-    attribute :sort,    Array[String], default: [ ]
+    attribute :fields,  Array[FieldAttribute], default: [ ]
+    attribute :filters, Array[Filter],         default: [ ]
+    attribute :sort,    Array[String],         default: [ ]
     attribute :rows,    Integer
 
-    def_delegators :result, :count, :docs, :pids, :each_pid, :all
+    delegate [:count, :docs, :pids, :each_pid, :all] => :result
+    delegate :params => :query_params
 
     def inspect
       "#<#{self.class.name} q=#{q.inspect}, filters=#{filters.inspect}," \
@@ -23,10 +24,6 @@ module Ddr::Index
       URI.encode_www_form(params)
     end
 
-    def params
-      QueryParams.new(self).params
-    end
-
     def result
       QueryResult.new(self)
     end
@@ -35,5 +32,13 @@ module Ddr::Index
       CSVQueryResult.new(self, **opts)
     end
 
+    def filter_clauses
+      filters.map(&:clauses).flatten
+    end
+
+    def query_params
+      QueryParams.new(self)
+    end
+
   end
 end

data/lib/ddr/index/query_builder.rb

@@ -2,8 +2,84 @@ module Ddr::Index
   #
   # QueryBuilder - Provides a DSL for building a Query.
   #
+  # Note: Where a method receives a [field] parameter, the parameter value is
+  # coerced to a Field instance. See FieldAttribute#coerce for details.
+  #
+  # *** DSL METHODS ***
+  #
+  # absent [field]
+  #   Adds a filter selecting documents where the field is not present (no values).
+  #
+  # asc [field], ...
+  #   Adds ascending orderings by the fields specified.
+  #   See also: desc, order_by
+  #
+  # before [field], [date_time]
+  #   Adds a filter selecting documents where the field has a date/time before
+  #   (earlier than) the value.
+  #
+  # before_days [field], [int]
+  #   Adds a filter selecting documents where the field has a date/time the
+  #   specified number of days before today (now) or earlier.
+  #
+  # desc [field], ...
+  #   Adds descending orderings by the fields specified.
+  #   See also: asc, order_by
+  #
+  # id [doc_id]
+  #   For selecting a single document by ID.
+  #
+  # filter [filter1], ...
+  #   Adds filters to the query.
+  #   Aliased as: filters
+  #
+  # filters [filter], ...
+  #   Alias for: filter
+  #
+  # field [field1], ...
+  #   Adds fields to result documents.
+  #   Note that all fields are returned when none is specified.
+  #   Aliased as: fields
+  #
+  # fields [field], ...
+  #   Alias for: field
+  #
+  # limit [int]
+  #   Limits the number of documents returned by the query.
+  #   Aliased as: rows
+  #
+  # negative [field], [value]
+  #   Adds a filter selecting document where field does not have the value.
+  #
+  # order_by [{field => order, ...}], ...
+  #   Adds ordering(s) to the query.
+  #   Aliased as: sort
+  #
+  # present [field]
+  #   Adds a filter selecting document where the field has any value.
+  #
+  # q [query_clause]
+  #   Sets a query clause for the `q` parameter.
+  #
+  # raw [clause1], ...
+  #   Adds a filter of "raw" query clauses (i.e., pre-constructed).
+  #
+  # rows [int]
+  #   Alias for: limit
+  #
+  # sort [{field => order, ...}]
+  #   Alias for: order_by
+  #
+  # term [{field => value, ...}]
+  #   Adds a filter of "term" query clauses for the fields and values.
+  #
+  # where [{field => value, ...}]
+  #   Adds a filter of "standard" query clauses.
+  #   Values will be escaped when the filter is serialized.
+  #   If a hash value is an array, that query clause will select documents
+  #     where the field matches any array entry.
+  #
   class QueryBuilder
-    extend Deprecation
 
     # Builds a Query object
     # @yield [builder] a new QueryBuilder instance.
@@ -26,86 +102,83 @@ module Ddr::Index
       end
     end
 
+    # @param pid [String]
+    # @return [QueryBuilder]
     def id(pid)
       q QueryClause.id(pid)
       limit 1
     end
 
+    # @param filters [Array<Filter>]
+    # @return [QueryBuilder]
     def filter(*filters)
-      query.filters.push(*filters)
+      query.filters += filters
       self
     end
     alias_method :filters, :filter
 
-    def raw(*args)
-      filter Filter.raw(*args)
-    end
-
-    def where(*args)
-      filter Filter.where(*args)
-    end
-
-    def absent(*args)
-      filter Filter.absent(*args)
-    end
-
-    def present(*args)
-      filter Filter.present(*args)
-    end
-
-    def negative(*args)
-      filter Filter.negative(*args)
-    end
-
-    def before(*args)
-      filter Filter.before(*args)
-    end
-
-    def before_days(*args)
-      filter Filter.before_days(*args)
-    end
-
+    # @param fields [Array<Field>]
+    # @return [QueryBuilder] self
     def field(*fields)
-      query.fields.push(*fields)
+      query.fields += fields
       self
     end
     alias_method :fields, :field
 
+    # @param num [Integer]
+    # @return [QueryBuilder] self
     def limit(num)
-      query.rows = num
+      query.rows = num.to_i
       self
     end
     alias_method :rows, :limit
 
-    def order_by(*args)
-      unless args.first.is_a? Hash
+    # @param orderings [Hash<Field, String>]
+    # @return [QueryBuilder] self
+    def order_by(*orderings)
+      unless orderings.first.is_a? Hash
         Deprecation.warn(QueryBuilder, "`order_by` will require a hash of orderings in ddr-models 3.0.")
-        field, order = args
+        field, order = orderings
         return order_by(field => order)
       end
-      query.sort += args.first.map { |field, order| SortOrder.new(field: field, order: order) }
+      query.sort += orderings.first.map { |field, order| SortOrder.new(field: field, order: order) }
       self
     end
     alias_method :sort, :order_by
 
-    def asc(field)
-      Deprecation.warn(QueryBuilder,
-                       "`asc(field)` is deprecated and will be removed from ddr-models 3.0." \
-                       " Use `order_by(field => \"asc\")` instead.")
-      order_by(field => SortOrder::ASC)
+    # @param fields [Array<Field, Symbol, String>]
+    # @return [QueryBuilder] self
+    def asc(*fields)
+      query.sort += fields.map { |field| SortOrder.asc(field) }
+      self
     end
-
-    def desc(field)
-      Deprecation.warn(QueryBuilder,
-                       "`desc(field)` is deprecated and will be removed from ddr-models 3.0." \
-                       " Use `order_by(field => \"desc\")` instead.")
-      order_by(field => SortOrder::DESC)
+    # @param fields [Array<Field, Symbol, String>]
+    # @return [QueryBuilder] self
+    def desc(*fields)
+      query.sort += fields.map { |field| SortOrder.desc(field) }
+      self
     end
 
-    def q(q)
-      query.q = q
+    # @param query_clause [QueryClause, String]
+    # @return [QueryBuilder] self
+    def q(query_clause)
+      query.q = query_clause
       self
     end
 
+    private
+
+    def respond_to_missing?(name, include_all)
+      Filter::ClassMethods.public_instance_methods.include?(name)
+    end
+
+    def method_missing(name, *args, &block)
+      if respond_to?(name)
+        filter Filter.send(name, *args)
+      else
+        super
+      end
+    end
+
   end
 end