ddr-models 2.4.0.rc4 → 2.4.0.rc5

data/lib/ddr/index/query_clause.rb

@@ -1,17 +1,42 @@
+require "virtus"
+
 module Ddr::Index
   class QueryClause
+    include Virtus.value_object
+
+    ANY_FIELD = Field.new('*').freeze
+    ANY_VALUE = "[* TO *]"
+    QUOTE     = '"'
+
+    TERM_QUERY      = "{!term f=%{field}}%{value}"
+    STANDARD_QUERY  = "%{field}:%{value}"
+    NEGATIVE_QUERY  = "-%{field}:%{value}"
+    DISJUNCTION     = "{!lucene q.op=OR df=%{field}}%{value}"
+
+    values do
+      attribute :field,       FieldAttribute
+      attribute :value,       String
+      attribute :quote_value, Boolean, default: false
+      attribute :template,    String,  default: STANDARD_QUERY
+    end
+
+    def to_s
+      template % { field: field, value: quote_value ? quote(value) : value }
+    end
 
-    PRESENT = "[* TO *]"
-    TERM = "{!term f=%s}%s"
-    BEFORE_DAYS = "[* TO NOW-%sDAYS]"
+    def quote(value)
+      self.class.quote(value)
+    end
 
     class << self
-      # Builds a standard query clause, no escaping applied.
-      # @param field [Field, String] field
-      # @param value [String] query value
-      # @return [String] query clause
-      def build(field, value)
-        [field, value].join(":")
+
+      def quote(value)
+        # Derived from Blacklight::Solr::SearchBuilderBehavior#solr_param_quote
+        unless value =~ /\A[a-zA-Z0-9$_\-\^]+\z/
+          QUOTE + value.gsub("'", "\\\\\'").gsub('"', "\\\\\"") + QUOTE
+        else
+          value
+        end
       end
 
       # Builds a query clause to retrieve the index document by unique key.
@@ -20,62 +45,51 @@ module Ddr::Index
       end
       alias_method :id, :unique_key
 
+      def where(field, value)
+        if value.respond_to?(:each)
+          disjunction(field, value)
+        else
+          new(field: field, value: value, quote_value: true)
+        end
+      end
+
       # Builds a query clause to filter where field does not have the given value.
-      # @param field [Field, String] field
-      # @param value [String] query value
-      # @return [String] query clause
       def negative(field, value)
-        build("-#{field}", value)
+        new(field: field, value: value, template: NEGATIVE_QUERY, quote_value: true)
       end
 
       # Builds a query clause to filter where field is present (i.e, has any value)
-      # @param field [Field, String] field
-      # @return [String] query clause
       def present(field)
-        build(field, PRESENT)
+        new(field: field, value: ANY_VALUE)
       end
 
       # Builds a query clause to filter where field is NOT present (no values)
-      # @param field [Field, String] field
-      # @return [String] query clause
       def absent(field)
-        negative(field, PRESENT)
+        new(field: "-#{field}", value: ANY_VALUE)
       end
 
       # Builds a query clause to filter where field contains at least one of a set of values.
-      # @param field [Field, String] field
-      # @param values [Array<String>] query values
-      # @return [String] query clause
-      def or_values(field, values)
-        build(field, QueryValue.or_values(values))
+      def disjunction(field, values)
+        value = values.map { |v| quote(v) }.join(" ")
+        new(field: field, value: value, template: DISJUNCTION)
       end
 
       # Builds a query clause to filter where date field value is earlier than a date/time value.
-      # @param field [Field, String] field
-      # @param value [Object] query value, must be coercible to a Solr date string.
-      # @return [String] query clause
-      def before(field, date_time)
-        value = "[* TO %s]" % Ddr::Utils.solr_date(date_time)
-        build(field, value)
+      def before(field, value)
+        new(field: field, value: "[* TO %s]" % Ddr::Utils.solr_date(value))
       end
+      alias_method :before_date_time, :before
 
       # Builds a query clause to filter where date field value is earlier than a number of days before now.
-      # @param field [Field, String] field
-      # @param value [String, Fixnum] query value, must be coercible to integer.
-      # @return [String] query clause
-      def before_days(field, days)
-        value = BEFORE_DAYS % days.to_i
-        build(field, value)
+      def before_days(field, value)
+        new(field: field, value: "[* TO NOW-%iDAYS]" % value)
       end
 
       # Builds a "term query" clause to filter where field contains value.
-      #   Double quotes are escaped.
-      # @param field [Field, String] field
-      # @param value [String] query value
-      # @return [String] Solr term query
       def term(field, value)
-        TERM % [field, value.gsub(/"/, '\"')]
+        new(field: field, value: value, template: TERM_QUERY)
       end
+
     end
 
   end

data/lib/ddr/index/query_params.rb

@@ -1,23 +1,39 @@
-require "delegate"
-
 module Ddr::Index
-  class QueryParams < SimpleDelegator
+  class QueryParams
 
-    attr_reader :params
+    attr_reader :query
 
     def initialize(query)
-      super
-      @params = {
-        q:    q,
-        fq:   fq,
-        fl:   fields.join(","),
-        sort: sort.join(","),
+      @query = query
+    end
+
+    def params
+      { q:    q_param,
+        fq:   filter_queries,
+        fl:   fields,
+        sort: sort,
         rows: rows,
       }.select { |k, v| v.present? }
     end
 
-    def fq
-      filters.map(&:clauses).flatten
+    def q_param
+      query.q.to_s
+    end
+
+    def filter_queries
+      query.filter_clauses.map(&:to_s)
+    end
+
+    def fields
+      query.fields.join(",")
+    end
+
+    def sort
+      query.sort.join(",")
+    end
+
+    def rows
+      query.rows
     end
 
   end

data/lib/ddr/index/sort_order.rb

@@ -2,18 +2,26 @@ require "virtus"
 
 module Ddr::Index
   class SortOrder
-    include Virtus.value_object(strict: true)
+    include Virtus.value_object
 
     ASC = "asc"
     DESC = "desc"
 
     values do
-      attribute :field, String
+      attribute :field, FieldAttribute
       attribute :order, String
     end
 
     def to_s
-      [field, order].join(" ")
+      [ field, order ].join(" ")
+    end
+
+    def self.asc(field)
+      new(field: field, order: ASC)
+    end
+
+    def self.desc(field)
+      new(field: field, order: DESC)
     end
 
   end

data/lib/ddr/models/version.rb

@@ -1,5 +1,5 @@
 module Ddr
   module Models
-    VERSION = "2.4.0.rc4"
+    VERSION = "2.4.0.rc5"
   end
 end

data/spec/index/filter_spec.rb

@@ -6,59 +6,101 @@ module Ddr::Index
     describe "equality" do
       describe "when the other is a Filter instance" do
         describe "and the clauses are equal" do
-          subject { described_class.new(["foo:bar", "spam:eggs"]) }
-          let(:other) { described_class.new(["foo:bar", "spam:eggs"]) }
+          subject { described_class.new(clauses: ["foo:bar", "spam:eggs"]) }
+          let(:other) { described_class.new(clauses: ["foo:bar", "spam:eggs"]) }
           specify { expect(subject).to eq other }
         end
         describe "and the clauses are not equal" do
-          subject { described_class.new(["foo:bar", "bam:baz"]) }
-          let(:other) { described_class.new(["foo:bar", "spam:eggs"]) }
+          subject { described_class.new(clauses: ["foo:bar", "bam:baz"]) }
+          let(:other) { described_class.new(clauses: ["foo:bar", "spam:eggs"]) }
           specify { expect(subject).not_to eq other }
         end
       end
       describe "when the other is not a Filter instance" do
-        subject { described_class.new(["foo:bar", "spam:eggs"]) }
+        subject { described_class.new(clauses: ["foo:bar", "spam:eggs"]) }
         let(:other) { double(clauses: ["foo:bar", "spam:eggs"]) }
         specify { expect(subject).not_to eq other }
       end
     end
 
     describe "class methods" do
-      describe ".where" do
-        subject { Filter.where("foo"=>"bar", "spam"=>"eggs", "stuff"=>["dog", "cat", "bird"]) }
-        its(:clauses) { are_expected.to eq (["{!term f=foo}bar", "{!term f=spam}eggs", "stuff:(dog OR cat OR bird)"]) }
+      describe ".is_governed_by" do
+        describe "with an object" do
+          subject { described_class.is_governed_by(Item.new(pid: "test:1")) }
+          its(:clauses) {
+            are_expected.to eq([QueryClause.term(:is_governed_by, "info:fedora/test:1")])
+          }
+        end
+        describe "with an ID" do
+          subject { described_class.is_governed_by("test:1") }
+          its(:clauses) {
+            are_expected.to eq([QueryClause.term(:is_governed_by, "info:fedora/test:1")])
+          }
+        end
       end
-      describe "#raw" do
-        subject { Filter.raw("foo:bar", "spam:eggs") }
+      describe ".is_member_of_collection" do
+        describe "with an object" do
+          subject { described_class.is_member_of_collection(Item.new(pid: "test:1")) }
+          its(:clauses) {
+            are_expected.to eq([QueryClause.term(:is_member_of_collection, "info:fedora/test:1")])
+          }
+        end
+        describe "with an ID" do
+          subject { described_class.is_member_of_collection("test:1") }
+          its(:clauses) {
+            are_expected.to eq([QueryClause.term(:is_member_of_collection, "info:fedora/test:1")])
+          }
+        end
+      end
+      describe ".has_content" do
+        subject { described_class.has_content }
+        its(:clauses) { are_expected.to eq([QueryClause.where(:active_fedora_model, ["Component", "Attachment", "Target"])]) }
+      end
+      describe ".where" do
+        subject { described_class.where("foo"=>"bar", "spam"=>"eggs", "stuff"=>["dog", "cat", "bird"]) }
+        its(:clauses) {
+          are_expected.to eq([QueryClause.where("foo", "bar"),
+                              QueryClause.where("spam", "eggs"),
+                              QueryClause.where("stuff", ["dog", "cat", "bird"])
+                             ])
+        }
+      end
+      describe ".raw" do
+        subject { described_class.raw("foo:bar", "spam:eggs") }
         its(:clauses) { are_expected.to eq(["foo:bar", "spam:eggs"]) }
       end
-      describe "#negative" do
-        subject { Filter.negative("foo", "bar") }
-        its(:clauses) { are_expected.to eq(["-foo:bar"]) }
+      describe ".negative" do
+        subject { described_class.negative("foo", "bar") }
+        its(:clauses) { are_expected.to eq([QueryClause.negative("foo", "bar")]) }
       end
-      describe "#present" do
-        subject { Filter.present("foo") }
-        its(:clauses) { are_expected.to eq(["foo:[* TO *]"]) }
+      describe ".present" do
+        subject { described_class.present("foo") }
+        its(:clauses) { are_expected.to eq([QueryClause.present("foo")]) }
       end
-      describe "#absent" do
-        subject { Filter.absent("foo") }
-        its(:clauses) { are_expected.to eq(["-foo:[* TO *]"]) }
+      describe ".absent" do
+        subject { described_class.absent("foo") }
+        its(:clauses) { are_expected.to eq([QueryClause.absent("foo")]) }
       end
-      describe "#before_days" do
-        subject { Filter.before_days("foo", 60) }
-        its(:clauses) { are_expected.to eq(["foo:[* TO NOW-60DAYS]"]) }
+      describe ".before_days" do
+        subject { described_class.before_days("foo", 60) }
+        its(:clauses) { are_expected.to eq([QueryClause.before_days("foo", 60)]) }
       end
-      describe "#before" do
-        subject { Filter.before("foo", DateTime.parse("Thu, 27 Aug 2015 17:42:34 -0400")) }
-        its(:clauses) { are_expected.to eq(["foo:[* TO 2015-08-27T21:42:34Z]"]) }
+      describe ".before" do
+        subject { described_class.before("foo", DateTime.parse("Thu, 27 Aug 2015 17:42:34 -0400")) }
+        its(:clauses) {
+          are_expected.to eq([QueryClause.before("foo", DateTime.parse("Thu, 27 Aug 2015 17:42:34 -0400"))])
+        }
       end
     end
 
-    describe "instance methods" do
+    describe "API methods" do
       describe "#where" do
         it "adds raw query filters for the hash of conditions" do
           subject.where("foo"=>"bar", "spam"=>"eggs", "stuff"=>["dog", "cat", "bird"])
-          expect(subject.clauses).to eq(["{!term f=foo}bar", "{!term f=spam}eggs", "stuff:(dog OR cat OR bird)"])
+          expect(subject.clauses).to eq([QueryClause.where("foo", "bar"),
+                                         QueryClause.where("spam", "eggs"),
+                                         QueryClause.where("stuff", ["dog", "cat", "bird"])
+                                        ])
         end
       end
       describe "#raw" do
@@ -70,31 +112,31 @@ module Ddr::Index
       describe "#negative" do
         it "adds a negation query clause" do
           subject.negative("foo", "bar")
-          expect(subject.clauses).to eq(["-foo:bar"])
+          expect(subject.clauses).to eq([QueryClause.negative("foo", "bar")])
         end
       end
       describe "#present" do
         it "adds a \"field present\" query clause" do
           subject.present("foo")
-          expect(subject.clauses).to eq(["foo:[* TO *]"])
+          expect(subject.clauses).to eq([QueryClause.present("foo")])
         end
       end
       describe "#absent" do
         it "adds a \"field not present\" query clause" do
           subject.absent("foo")
-          expect(subject.clauses).to eq(["-foo:[* TO *]"])
+          expect(subject.clauses).to eq([QueryClause.absent("foo")])
         end
       end
       describe "#before_days" do
         it "adds a date range query clause" do
           subject.before_days("foo", 60)
-          expect(subject.clauses).to eq(["foo:[* TO NOW-60DAYS]"])
+          expect(subject.clauses).to eq([QueryClause.before_days("foo", 60)])
         end
       end
       describe "#before" do
         it "adds a date range query clause" do
           subject.before("foo", DateTime.parse("Thu, 27 Aug 2015 17:42:34 -0400"))
-          expect(subject.clauses).to eq(["foo:[* TO 2015-08-27T21:42:34Z]"])
+          expect(subject.clauses).to eq([QueryClause.before("foo", DateTime.parse("Thu, 27 Aug 2015 17:42:34 -0400"))])
         end
       end
     end

data/spec/index/query_builder_spec.rb

@@ -6,90 +6,111 @@ module Ddr::Index
         subject { described_class.new { id "test:1" } }
         specify {
           expect(subject.query.rows).to eq 1
-          expect(subject.query.q).to eq "{!term f=id}test:1"
+          expect(subject.query.q).to eq QueryClause.id("test:1")
         }
       end
-
       describe "q" do
         subject { described_class.new { q "foo:bar" } }
         specify { expect(subject.query.q).to eq "foo:bar" }
       end
-
       describe "asc" do
-        subject { described_class.new { asc "foo" } }
-        specify { expect(subject.query.sort).to eq [SortOrder.new(field: "foo", order: "asc")] }
+        subject { described_class.new { asc "foo", "bar" } }
+        specify {
+          expect(subject.query.sort).to eq [SortOrder.asc("foo"), SortOrder.asc("bar")]
+        }
       end
-
       describe "desc" do
-        subject { described_class.new { desc "foo" } }
-        specify { expect(subject.query.sort).to eq [SortOrder.new(field: "foo", order: "desc")] }
+        subject { described_class.new { desc "foo", "bar" } }
+        specify {
+          expect(subject.query.sort).to eq [SortOrder.desc("foo"), SortOrder.desc("bar")]
+        }
       end
-
       describe "filter" do
         subject { described_class.new { filter Filter.where("foo"=>"bar") } }
         specify { expect(subject.query.filters).to eq [Filter.where("foo"=>"bar")] }
       end
-
+      describe "filters" do
+        subject {
+          described_class.new { filters Filter.where("foo"=>"bar"), Filter.where("bing"=>"bang") }
+        }
+        specify {
+          expect(subject.query.filters).to eq([Filter.where("foo"=>"bar"),
+                                               Filter.where("bing"=>"bang")
+                                              ])
+        }
+      end
       describe "field" do
         subject { described_class.new { field "foo", "bar" } }
         specify { expect(subject.query.fields).to include("foo", "bar") }
       end
-
       describe "fields" do
         subject { described_class.new { fields "foo", "bar" } }
         specify { expect(subject.query.fields).to include("foo", "bar") }
       end
-
       describe "sort" do
         subject { described_class.new { sort "foo"=>"asc", "bar"=>"desc" } }
-        specify { expect(subject.query.sort).to eq [SortOrder.new(field: "foo", order: "asc"), SortOrder.new(field: "bar", order: "desc")] }
+        specify {
+          expect(subject.query.sort).to eq([SortOrder.new(field: "foo", order: "asc"),
+                                            SortOrder.new(field: "bar", order: "desc")
+                                           ])
+        }
       end
-
       describe "order_by" do
         subject { described_class.new { order_by "foo"=>"asc", "bar"=>"desc" } }
         specify { expect(subject.query.sort).to eq [SortOrder.new(field: "foo", order: "asc"), SortOrder.new(field: "bar", order: "desc")] }
       end
-
       describe "limit" do
         subject { described_class.new { limit 5 } }
         specify { expect(subject.query.rows).to eq 5 }
       end
-
       describe "rows" do
         subject { described_class.new { rows 5 } }
         specify { expect(subject.query.rows).to eq 5 }
       end
-
       describe "raw" do
         subject { described_class.new { raw "foo:bar" } }
         specify { expect(subject.query.filters).to eq [Filter.raw("foo:bar")] }
       end
-
       describe "where" do
         subject { described_class.new { where "foo"=>"bar" } }
         specify { expect(subject.query.filters).to eq [Filter.where("foo"=>"bar")] }
       end
-
       describe "absent" do
         subject { described_class.new { absent "foo" } }
         specify { expect(subject.query.filters).to eq [Filter.absent("foo")] }
       end
-
       describe "present" do
         subject { described_class.new { present "foo" } }
         specify { expect(subject.query.filters).to eq [Filter.present("foo")] }
       end
-
       describe "before" do
-        subject { described_class.new { before "foo", DateTime.parse("2015-12-14T20:40:06Z") } }
-        specify { expect(subject.query.filters).to eq [Filter.before("foo", DateTime.parse("2015-12-14T20:40:06Z"))] }
+        subject {
+          described_class.new { before "foo", DateTime.parse("2015-12-14T20:40:06Z") }
+        }
+        specify {
+          expect(subject.query.filters).to eq [Filter.before("foo", DateTime.parse("2015-12-14T20:40:06Z"))]
+        }
       end
-
       describe "before_days" do
         subject { described_class.new { before_days "foo", 7 } }
         specify { expect(subject.query.filters).to eq [Filter.before_days("foo", 7)] }
       end
     end
 
+    describe "using static filters" do
+      describe "has_content" do
+        before { subject.has_content }
+        specify { expect(subject.query.filters).to eq [Filter.has_content] }
+      end
+      describe "is_governed_by" do
+        before { subject.is_governed_by "test:1" }
+        specify { expect(subject.query.filters).to eq [Filter.is_governed_by("test:1")] }
+      end
+      describe "is_governed_by" do
+        before { subject.is_member_of_collection "test:1" }
+        specify { expect(subject.query.filters).to eq [Filter.is_member_of_collection("test:1")] }
+      end
+    end
+
   end
 end