ddr-models 2.11.0 → 3.0.0.alpha.1

data/lib/ddr/index/filter.rb

@@ -1,121 +1,48 @@
-require "forwardable"
-require "virtus"
-
 module Ddr::Index
   class Filter
-    include Virtus.model
-
-    attribute :clauses, Array, default: [ ]
 
-    def ==(other)
-      other.instance_of?(self.class) && (other.clauses == self.clauses)
+    class << self
+      delegate :where, :raw, :before_days, :before, :present, :absent, to: :new
     end
 
-    module Api
-      def raw(*clauses)
-        self.clauses += clauses
-        self
-      end
-
-      def term(conditions)
-        self.clauses += conditions.map { |f, v| QueryClause.term(f, v) }
-        self
-      end
-
-      def where(conditions)
-        self.clauses += conditions.map { |f, v| QueryClause.where(f, v) }
-        self
-      end
-
-      def where_not(conditions)
-        self.clauses += conditions.map do |field, v|
-          Array(v).map { |value| QueryClause.negative(field, value) }
-        end.flatten
-        self
-      end
-
-      def absent(field)
-        self.clauses << QueryClause.absent(field)
-        self
-      end
-
-      def present(field)
-        self.clauses << QueryClause.present(field)
-        self
-      end
-
-      def negative(field, value)
-        self.clauses << QueryClause.negative(field, value)
-        self
-      end
-
-      def before(field, value)
-        self.clauses << QueryClause.before(field, value)
-        self
-      end
+    attr_accessor :clauses
 
-      def before_days(field, value)
-        self.clauses << QueryClause.before_days(field, value)
-        self
-      end
-
-      def join(**args)
-        self.clauses << QueryClause.join(**args)
-        self
-      end
-
-      def regexp(field, value)
-        self.clauses << QueryClause.regexp(field, value)
-        self
-      end
+    def initialize
+      @clauses = [ ]
     end
 
-    module ClassMethods
-      extend Forwardable
-
-      delegate Api.public_instance_methods => :new_filter
-
-      def has_content
-        model "Component", "Attachment", "Target"
-      end
-
-      def is_governed_by(arg)
-        term is_governed_by: get_uri(arg)
-      end
-
-      def is_member_of_collection(arg)
-        term is_member_of_collection: get_uri(arg)
-      end
-
-      def is_part_of(arg)
-        term is_part_of: get_uri(arg)
-      end
-
-      def model(*models)
-        where active_fedora_model: models
-      end
-
-      private
-
-      def get_uri(arg)
-        case arg
-        when ActiveFedora::Base
-          arg.internal_uri
-        when String
-          arg.start_with?("info:fedora/") ? arg : "info:fedora/#{arg}"
+    def where(conditions)
+      clauses = conditions.map do |field, value|
+        if value.respond_to?(:each)
+          QueryClause.or_values(field, *value)
         else
-          raise TypeError, "Argument must be a String or ActiveFedora::Base instance: #{arg.class}"
+          QueryClause.term(field, value)
         end
       end
+      raw *clauses
+    end
 
-      def new_filter
-        Filter.new
-      end
+    # Adds clause (String) w/o escaping
+    def raw(*clauses)
+      self.clauses += clauses
+      self
+    end
 
+    def present(field)
+      raw QueryClause.present(field)
     end
 
-    include Api
-    extend ClassMethods
+    def absent(field)
+      raw QueryClause.absent(field)
+    end
+
+    def before(field, date_time)
+      raw QueryClause.before(field, date_time)
+    end
+
+    def before_days(field, days)
+      raw QueryClause.before_days(field, days)
+    end
 
   end
 end

data/lib/ddr/index/filters.rb

@@ -0,0 +1,19 @@
+module Ddr::Index
+  module Filters
+
+    HAS_CONTENT = Filter.where(Fields::ACTIVE_FEDORA_MODEL => ["Component", "Attachment", "Target"])
+
+    class << self
+      def is_governed_by(pid)
+        Filter.where(Fields::IS_GOVERNED_BY => pid)
+      end
+
+      def internal_uri(pid)
+        ActiveFedora::Base.internal_uri(pid)
+      end
+    end
+
+    private_class_method :internal_uri
+
+  end
+end

data/lib/ddr/index/query.rb

@@ -1,33 +1,9 @@
-require "virtus"
-require "forwardable"
-
 module Ddr::Index
   class Query
-    include Virtus.model
-    extend Forwardable
-    extend Deprecation
-
-    attribute :q,       String
-    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
+    attr_reader :q, :fields, :filters, :sort, :rows
 
-    def initialize(**args, &block)
-      super(**args)
-      if block_given?
-        build(&block)
-      end
-    end
+    delegate :count, :docs, :pids, :each_pid, :all, to: :result
 
     def inspect
       "#<#{self.class.name} q=#{q.inspect}, filters=#{filters.inspect}," \
@@ -38,44 +14,21 @@ module Ddr::Index
       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)
+    def params
+      { q:    q,
+        fq:   filters.map(&:clauses).flatten,
+        fl:   fields.join(","),
+        sort: sort.join(","),
+        rows: rows,
+      }.select { |k, v| v.present? }
     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
+    def csv(**opts)
+      CSVQueryResult.new(self, **opts)
     end
 
   end

data/lib/ddr/index/query_builder.rb

@@ -1,184 +1,73 @@
 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 self.build
+      builder = new
+      yield builder
+      builder.query
+    end
+
+    def initialize
+      @q       = nil
+      @fields  = [ ]
+      @filters = [ ]
+      @sort    = [ ]
+      @rows    = nil
+    end
 
-    def initialize(*args, &block)
-      @query = args.first.is_a?(Query) ? args.shift : Query.new
-      if block_given?
-        instance_exec(*args, &block)
+    def query
+      Query.new.tap do |qry|
+        instance_variables.each do |var|
+          qry.instance_variable_set(var, instance_variable_get(var))
+        end
       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
+    def filter(*fltrs)
+      @filters.push *fltrs
       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) }
+    def fields(*flds)
+      @fields.push *flds
       self
     end
-    alias_method :fields, :field
 
-    # @param num [Integer]
-    # @return [QueryBuilder] self
     def limit(num)
-      query.rows = num.to_i
+      @rows = num
       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) }
+    def order_by(field, order)
+      @sort << [field, order].join(" ")
       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
+    def asc(field)
+      order_by field, "asc"
     end
-    # @param fields [Array<Field, Symbol, String>]
-    # @return [QueryBuilder] self
-    def desc(*fields)
-      query.sort += fields.map { |field| SortOrder.desc(field) }
-      self
+
+    def desc(field)
+      order_by field, "desc"
     end
 
-    # @param query_clause [QueryClause, String]
-    # @return [QueryBuilder] self
-    def q(query_clause)
-      query.q = query_clause
+    def q(q)
+      @q = q
       self
     end
 
-    private
-
-    def respond_to_missing?(name, include_all)
-      Filter::ClassMethods.public_instance_methods.include?(name)
-    end
+    protected
 
     def method_missing(name, *args, &block)
-      if respond_to?(name)
-        filter Filter.send(name, *args)
-      else
-        super
+      if Filter.respond_to? name
+        return filter Filter.send(name, *args, &block)
       end
+      super
     end
 
   end