ddr-models 2.4.0.rc2 → 2.4.0.rc3

data/lib/ddr/index/query_clause.rb

@@ -6,43 +6,73 @@ module Ddr::Index
     BEFORE_DAYS = "[* TO NOW-%sDAYS]"
 
     class << self
-      # Standard Solr query, no escaping applied
+      # 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(":")
       end
 
+      # Builds a query clause to retrieve the index document by unique key.
       def unique_key(value)
         term(UniqueKeyField.instance, value)
       end
       alias_method :id, :unique_key
-      alias_method :pid, :unique_key
 
+      # 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
+        build("-#{field}", value)
       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
+        build(field, PRESENT)
       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
+        negative(field, PRESENT)
       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)
+        build(field, QueryValue.or_values(values))
       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
+        build(field, value)
       end
 
+      # 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
+        build(field, 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(/"/, '\"')]
       end

data/lib/ddr/index/query_params.rb

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

data/lib/ddr/index/query_value.rb

@@ -2,11 +2,16 @@ module Ddr::Index
   class QueryValue
 
     class << self
+      # Returns an escaped query value
+      # @param value [String] the unescaped value
+      # @return [String] the escaped value
       def build(value)
         RSolr.solr_escape(value)
       end
 
+      # Builds an escaped query value for use in filtering on a field for any value in the list of values
       # @param values [Enumerable<String>]
+      # @return [String] query value
       def or_values(values)
         unless values.is_a?(::Enumerable) && values.present?
           raise ArgumentError, "`#{self.name}.or_values` requires a non-empty enumerable of strings."

data/lib/ddr/index/sort_order.rb

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

data/lib/ddr/models/version.rb

@@ -1,5 +1,5 @@
 module Ddr
   module Models
-    VERSION = "2.4.0.rc2"
+    VERSION = "2.4.0.rc3"
   end
 end

data/spec/index/fields_spec.rb

@@ -0,0 +1,175 @@
+module Ddr::Index
+  RSpec.describe Fields do
+
+    describe "constants" do
+      describe "ID" do
+        subject { Fields::ID }
+        its(:label) { is_expected.to eq "Fedora PID" }
+        its(:heading) { is_expected.to eq "pid" }
+      end
+
+      describe "PID" do
+        subject { Fields::PID }
+        its(:label) { is_expected.to eq "Fedora PID" }
+        its(:heading) { is_expected.to eq "pid" }
+      end
+
+      describe "ACCESS_ROLE" do
+        subject { Fields::ACCESS_ROLE }
+        its(:label) { is_expected.to eq "Access Role" }
+        its(:heading) { is_expected.to eq "access_role" }
+      end
+
+      describe "ACTIVE_FEDORA_MODEL" do
+        subject { Fields::ACTIVE_FEDORA_MODEL }
+        its(:label) { is_expected.to eq "Model" }
+        its(:heading) { is_expected.to eq "model" }
+      end
+
+      describe "ADMIN_SET" do
+        subject { Fields::ADMIN_SET }
+        its(:label) { is_expected.to eq "Admin Set" }
+        its(:heading) { is_expected.to eq "admin_set" }
+      end
+
+      describe "ASPACE_ID" do
+        subject { Fields::ASPACE_ID }
+        its(:label) { is_expected.to eq "ArchivesSpace ID" }
+        its(:heading) { is_expected.to eq "aspace_id" }
+      end
+
+      describe "DOI" do
+        subject { Fields::DOI }
+        its(:label) { is_expected.to eq "DOI" }
+        its(:heading) { is_expected.to eq "doi" }
+      end
+
+      describe "EAD_ID" do
+        subject { Fields::EAD_ID }
+        its(:label) { is_expected.to eq "EAD ID" }
+        its(:heading) { is_expected.to eq "ead_id" }
+      end
+
+      describe "LOCAL_ID" do
+        subject { Fields::LOCAL_ID }
+        its(:label) { is_expected.to eq "Local ID" }
+        its(:heading) { is_expected.to eq "local_id" }
+      end
+
+      describe "OBJECT_CREATE_DATE" do
+        subject { Fields::OBJECT_CREATE_DATE }
+        its(:label) { is_expected.to eq "Creation Date" }
+        its(:heading) { is_expected.to eq "creation_date" }
+      end
+
+      describe "OBJECT_MODIFIED_DATE" do
+        subject { Fields::OBJECT_MODIFIED_DATE }
+        its(:label) { is_expected.to eq "Modification Date" }
+        its(:heading) { is_expected.to eq "modification_date" }
+      end
+
+      describe "PERMANENT_ID" do
+        subject { Fields::PERMANENT_ID }
+        its(:label) { is_expected.to eq "Permanent ID" }
+        its(:heading) { is_expected.to eq "permanent_id" }
+      end
+
+      describe "PERMANENT_URL" do
+        subject { Fields::PERMANENT_URL }
+        its(:label) { is_expected.to eq "Permanent URL" }
+        its(:heading) { is_expected.to eq "permanent_url" }
+      end
+
+      describe "TECHMD_COLOR_SPACE" do
+        subject { Fields::TECHMD_COLOR_SPACE }
+        its(:label) { is_expected.to eq "Color Space" }
+        its(:heading) { is_expected.to eq "color_space" }
+      end
+
+      describe "TECHMD_CREATING_APPLICATION" do
+        subject { Fields::TECHMD_CREATING_APPLICATION }
+        its(:label) { is_expected.to eq "Creating Application" }
+        its(:heading) { is_expected.to eq "creating_application" }
+      end
+
+      describe "TECHMD_CREATION_TIME" do
+        subject { Fields::TECHMD_CREATION_TIME }
+        its(:label) { is_expected.to eq "Creation Time" }
+        its(:heading) { is_expected.to eq "creation_time" }
+      end
+
+      describe "TECHMD_FILE_SIZE" do
+        subject { Fields::TECHMD_FILE_SIZE }
+        its(:label) { is_expected.to eq "File Size" }
+        its(:heading) { is_expected.to eq "file_size" }
+      end
+
+      describe "TECHMD_FITS_VERSION" do
+        subject { Fields::TECHMD_FITS_VERSION }
+        its(:label) { is_expected.to eq "FITS Version" }
+        its(:heading) { is_expected.to eq "fits_version" }
+      end
+
+      describe "TECHMD_FITS_DATETIME" do
+        subject { Fields::TECHMD_FITS_DATETIME }
+        its(:label) { is_expected.to eq "FITS Run At" }
+        its(:heading) { is_expected.to eq "fits_datetime" }
+      end
+
+      describe "TECHMD_FORMAT_LABEL" do
+        subject { Fields::TECHMD_FORMAT_LABEL }
+        its(:label) { is_expected.to eq "Format Label" }
+        its(:heading) { is_expected.to eq "format_label" }
+      end
+
+      describe "TECHMD_FORMAT_VERSION" do
+        subject { Fields::TECHMD_FORMAT_VERSION }
+        its(:label) { is_expected.to eq "Format Version" }
+        its(:heading) { is_expected.to eq "format_version" }
+      end
+
+      describe "TECHMD_IMAGE_HEIGHT" do
+        subject { Fields::TECHMD_IMAGE_HEIGHT }
+        its(:label) { is_expected.to eq "Image Height" }
+        its(:heading) { is_expected.to eq "image_height" }
+      end
+
+      describe "TECHMD_IMAGE_WIDTH" do
+        subject { Fields::TECHMD_IMAGE_WIDTH }
+        its(:label) { is_expected.to eq "Image Width" }
+        its(:heading) { is_expected.to eq "image_width" }
+      end
+
+      describe "TECHMD_MEDIA_TYPE" do
+        subject { Fields::TECHMD_MEDIA_TYPE }
+        its(:label) { is_expected.to eq "Media Type" }
+        its(:heading) { is_expected.to eq "media_type" }
+      end
+
+      describe "TECHMD_MODIFICATION_TIME" do
+        subject { Fields::TECHMD_MODIFICATION_TIME }
+        its(:label) { is_expected.to eq "Modification Time" }
+        its(:heading) { is_expected.to eq "modification_time" }
+      end
+
+      describe "TECHMD_PRONOM_IDENTIFIER" do
+        subject { Fields::TECHMD_PRONOM_IDENTIFIER }
+        its(:label) { is_expected.to eq "PRONOM Unique ID" }
+        its(:heading) { is_expected.to eq "pronom_uid" }
+      end
+
+      describe "TECHMD_VALID" do
+        subject { Fields::TECHMD_VALID }
+        its(:label) { is_expected.to eq "Valid" }
+        its(:heading) { is_expected.to eq "valid" }
+      end
+
+      describe "TECHMD_WELL_FORMED" do
+        subject { Fields::TECHMD_WELL_FORMED }
+        its(:label) { is_expected.to eq "Well-formed" }
+        its(:heading) { is_expected.to eq "well_formed" }
+      end
+    end
+
+  end
+end

data/spec/index/filter_spec.rb

@@ -1,45 +1,101 @@
 module Ddr::Index
   RSpec.describe Filter do
 
-    describe "#where(conditions)" do
-      it "should add raw query filters for the field, value 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)"])
-      end
-    end
+    its(:clauses) { are_expected.to eq [] }
 
-    describe "#raw(*clauses)" do
-      it "should add the clauses w/o escaping" do
-        subject.raw("foo:bar", "spam:eggs")
-        expect(subject.clauses).to eq(["foo:bar", "spam:eggs"])
+    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"]) }
+          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"]) }
+          specify { expect(subject).not_to eq other }
+        end
       end
-    end
-
-    describe "#present(field)" do
-      it "should add a \"field present\" clause" do
-        subject.present("foo")
-        expect(subject.clauses).to eq(["foo:[* TO *]"])
+      describe "when the other is not a Filter instance" do
+        subject { described_class.new(["foo:bar", "spam:eggs"]) }
+        let(:other) { double(clauses: ["foo:bar", "spam:eggs"]) }
+        specify { expect(subject).not_to eq other }
       end
     end
 
-    describe "#absent(field)" do
-      it "should add a \"field not present\" clause" do
-        subject.absent("foo")
-        expect(subject.clauses).to eq(["-foo:[* TO *]"])
+    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)"]) }
       end
-    end
-
-    describe "#before_days(field, days)" do
-      it "should add a date range query clause" do
-        subject.before_days("foo", 60)
-        expect(subject.clauses).to eq(["foo:[* TO NOW-60DAYS]"])
+      describe "#raw" do
+        subject { Filter.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"]) }
+      end
+      describe "#present" do
+        subject { Filter.present("foo") }
+        its(:clauses) { are_expected.to eq(["foo:[* TO *]"]) }
+      end
+      describe "#absent" do
+        subject { Filter.absent("foo") }
+        its(:clauses) { are_expected.to eq(["-foo:[* TO *]"]) }
+      end
+      describe "#before_days" do
+        subject { Filter.before_days("foo", 60) }
+        its(:clauses) { are_expected.to eq(["foo:[* TO NOW-60DAYS]"]) }
+      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]"]) }
       end
     end
 
-    describe "#before(field, date_time)" do
-      it "should add 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]"])
+    describe "instance 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)"])
+        end
+      end
+      describe "#raw" do
+        it "adds the query clauses w/o escaping" do
+          subject.raw("foo:bar", "spam:eggs")
+          expect(subject.clauses).to eq(["foo:bar", "spam:eggs"])
+        end
+      end
+      describe "#negative" do
+        it "adds a negation query clause" do
+          subject.negative("foo", "bar")
+          expect(subject.clauses).to eq(["-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 *]"])
+        end
+      end
+      describe "#absent" do
+        it "adds a \"field not present\" query clause" do
+          subject.absent("foo")
+          expect(subject.clauses).to eq(["-foo:[* TO *]"])
+        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]"])
+        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]"])
+        end
       end
     end