ddr-core 0.2.1

data/lib/ddr/index/query.rb

@@ -0,0 +1,82 @@
+require "virtus"
+require "forwardable"
+
+module Ddr::Index
+  class Query
+    include Virtus.model
+    extend Forwardable
+    extend Deprecation
+
+    attribute :q,       String,                default: '*:*'
+    attribute :fields,  Array[FieldAttribute], default: [ ]
+    attribute :filters, Array[Filter],         default: [ ]
+    attribute :sort,    Array[String],         default: [ ]
+    attribute :rows,    Integer
+
+    delegate [:count, :docs, :ids, :each_id, :all] => :result
+    delegate :params => :query_params
+
+    def self.build(*args, &block)
+      new.tap do |query|
+        query.build(*args, &block)
+      end
+    end
+
+    def initialize(**args, &block)
+      super(**args)
+      if block_given?
+        build(&block)
+      end
+    end
+
+    def inspect
+      "#<#{self.class.name} q=#{q.inspect}, filters=#{filters.inspect}," \
+      " sort=#{sort.inspect}, rows=#{rows.inspect}, fields=#{fields.inspect}>"
+    end
+
+    def to_s
+      URI.encode_www_form(params)
+    end
+
+    def pids
+      Deprecation.warn(QueryResult, "`pids` is deprecated; use `ids` instead.")
+      ids
+    end
+
+    def each_pid(&block)
+      Deprecation.warn(QueryResult, "`each_pid` is deprecated; use `each_id` instead.")
+      each_id(&block)
+    end
+
+    def result
+      QueryResult.new(self)
+    end
+
+    def csv
+      CSVQueryResult.new(self)
+    end
+
+    def filter_clauses
+      filters.map(&:clauses).flatten
+    end
+
+    def query_params
+      QueryParams.new(self)
+    end
+
+    def build(*args, &block)
+      QueryBuilder.new(self, *args, &block)
+      self
+    end
+
+    def ==(other)
+      other.instance_of?(self.class) &&
+        other.q == self.q &&
+        other.fields == self.fields &&
+        other.filters == self.filters &&
+        other.rows == self.rows &&
+        other.sort == self.sort
+    end
+
+  end
+end

data/lib/ddr/index/query_builder.rb

@@ -0,0 +1,185 @@
+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
+  #
+  # 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
+  #
+  # id [doc_id]
+  #   For selecting a single document by ID.
+  #
+  # join [from: {field1}, to: {field2}, where: {condition}]
+  #   Adds a Solr join clause (see https://wiki.apache.org/solr/Join)
+  #
+  # limit [int]
+  #   Limits the number of documents returned by the query.
+  #
+  #   Aliased as: rows
+  #
+  # model [model_name], ...
+  #   Adds a filter selecting document where ActiveFedora model equals value
+  #     or one of the values.
+  #
+  # 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).
+  #
+  # regexp [field], [regexp]
+  #   Adds a filter selecting documents where the field has a value
+  #     matching the regular expression.
+  #     Slashes (/) in the regexp will be escaped as required by Solr.
+  #
+  # 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
+
+    attr_reader :query
+
+    def initialize(*args, &block)
+      @query = args.first.is_a?(Query) ? args.shift : Query.new
+      if block_given?
+        instance_exec(*args, &block)
+      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 += filters
+      self
+    end
+    alias_method :filters, :filter
+
+    # @param fields [Array<Field>]
+    # @return [QueryBuilder] self
+    def field(*fields)
+      query.fields += fields.flatten.map { |f| FieldAttribute.coerce(f) }
+      self
+    end
+    alias_method :fields, :field
+
+    # @param num [Integer]
+    # @return [QueryBuilder] self
+    def limit(num)
+      query.rows = num.to_i
+      self
+    end
+    alias_method :rows, :limit
+
+    # @param orderings [Hash<Field, String>]
+    # @return [QueryBuilder] self
+    def order_by(*orderings)
+      query.sort += orderings.first.map { |field, order| SortOrder.new(field: field, order: order) }
+      self
+    end
+    alias_method :sort, :order_by
+
+    # @param fields [Array<Field, Symbol, String>]
+    # @return [QueryBuilder] self
+    def asc(*fields)
+      query.sort += fields.map { |field| SortOrder.asc(field) }
+      self
+    end
+    # @param fields [Array<Field, Symbol, String>]
+    # @return [QueryBuilder] self
+    def desc(*fields)
+      query.sort += fields.map { |field| SortOrder.desc(field) }
+      self
+    end
+
+    # @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

data/lib/ddr/index/query_clause.rb

@@ -0,0 +1,112 @@
+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}"
+    REGEXP_QUERY    = "%{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
+
+    def quote(value)
+      self.class.quote(value)
+    end
+
+    class << self
+      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.
+      def unique_key(value)
+        term(UniqueKeyField.instance, value)
+      end
+      alias_method :id, :unique_key
+
+      def where(field, value)
+         values = Array(value)
+        if values.size > 1
+          disjunction(field, values)
+        else
+          new(field: field, value: values.first, quote_value: true)
+        end
+      end
+
+      # Builds a query clause to filter where field does not have the given value.
+      def negative(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)
+      def present(field)
+        new(field: field, value: ANY_VALUE)
+      end
+
+      # Builds a query clause to filter where field is NOT present (no values)
+      def absent(field)
+        new(field: field, value: ANY_VALUE, template: NEGATIVE_QUERY)
+      end
+
+      # Builds a query clause to filter where field contains at least one of a set of values.
+      def disjunction(field, values)
+        value = values.map { |v| quote(v) }.join(" ")
+        new(field: field, value: value, template: DISJUNCTION)
+      end
+
+      # Builds a Solr join clause
+      # @see https://wiki.apache.org/solr/Join
+      def join(from:, to:, where:)
+        field, value = where.to_a.first
+        from_field = FieldAttribute.coerce(from)
+        to_field   = FieldAttribute.coerce(to)
+        template = "{!join from=#{from_field} to=#{to_field}}%{field}:%{value}"
+        new(field: field, value: value, template: template, quote_value: true)
+      end
+
+      # Builds a query clause to filter where date field value is earlier than a date/time 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.
+      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.
+      def term(field, value)
+        new(field: field, value: value, template: TERM_QUERY)
+      end
+
+      # Builds a regular expression query clause
+      def regexp(field, value)
+        val = value.gsub(/\//, "\\/")
+        new(field: field, value: val, template: REGEXP_QUERY)
+      end
+    end
+
+  end
+end

data/lib/ddr/index/query_params.rb

@@ -0,0 +1,40 @@
+module Ddr::Index
+  class QueryParams
+
+    attr_reader :query
+
+    def initialize(query)
+      @query = query
+    end
+
+    def params
+      { q:    q_param,
+        fq:   filter_queries,
+        fl:   fields,
+        sort: sort,
+        rows: rows,
+      }.select { |k, v| v.present? }
+    end
+
+    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
+end

data/lib/ddr/index/query_result.rb

@@ -0,0 +1,102 @@
+module Ddr::Index
+  class QueryResult < AbstractQueryResult
+    extend Deprecation
+
+    PAGE_SIZE = 1000
+
+    delegate :csv, to: :query
+
+    def each(&block)
+      if params[:rows]
+        each_unpaginated(&block)
+      else
+        each_paginated(&block)
+      end
+    end
+
+    def each_unpaginated(&block)
+      Connection.select(params).docs.each(&block)
+    end
+
+    def each_paginated(&block)
+      pages.each { |pg| pg.each(&block) }
+    end
+
+    def pids
+      Deprecation.warn(QueryResult,
+                       "`pids` is deprecated; use `ids` instead." \
+                       " (called from #{caller.first})"
+                      )
+      ids
+    end
+
+    def ids
+      Enumerator.new do |e|
+        each do |doc|
+          e << doc[Fields::ID]
+        end
+      end
+    end
+
+    def each_pid(&block)
+      Deprecation.warn(QueryResult,
+                       "`each_pid` is deprecated; use `each_id` instead." \
+                       " (called from #{caller.first})"
+                      )
+      each_id(&block)
+    end
+
+    def each_id(&block)
+      ids.each(&block)
+    end
+
+    def docs
+      Enumerator.new do |e|
+        each do |doc|
+          e << DocumentBuilder.build(doc)
+        end
+      end
+    end
+
+    def objects
+      Enumerator.new do |e|
+        each_id do |id|
+          e << ActiveFedora::Base.find(id)
+        end
+      end
+    end
+
+    def facet_fields
+      response = Connection.select(params, rows: 0)
+      response.facet_fields.each_with_object({}) do |(field, values), memo|
+        memo[field] = Hash[*values]
+      end
+    end
+
+    def all
+      to_a
+    end
+
+    def pages
+      num = 1
+      Enumerator.new do |e|
+        loop do
+          pg = page(num)
+          e << pg
+          unless pg.has_next?
+            break
+          end
+          num += 1
+        end
+      end
+    end
+
+    def page(num)
+      page_params = params.dup
+      page_size = page_params.delete(:rows) || PAGE_SIZE
+      response = Connection.page(num, page_size, "select", params: page_params)
+      response.docs
+    end
+
+  end
+end