solrbee 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 11deb067a219ff325c0aa6dfaeb14422674cfd2a30338d14a1f00fa3f2081550
-  data.tar.gz: b6566f900e8a437feb379dba1e7f8de64e9c5a4b821cc501256ce0ee58da52e1
+  metadata.gz: 32b15ba57c92024c22c90c365c673098bbc5031fb14e76ae62ea75868e0d1ec3
+  data.tar.gz: 7aa16b385b8ddff45506966c1fbbb9b3e6252cfff2053b4f29377f09b9c4b9a1
 SHA512:
-  metadata.gz: aa65e21c6552dc4d4276ecfdc1a4089e69d3625af84d014cb6353183a9e145ed8adf34158b180e2c70d1718d211e35b32fbd545438bd13753d171484b1577010
-  data.tar.gz: 78fd833f50640f5f875be47160a87642f2b612c90906e3d349e68042f5d267b4b375727babcc8c2512c90006e7e858535e2382ecfc638d7dff333822f20e04c4
+  metadata.gz: c20241f1f4ed8e31fee8aa383bcf1a643f3dd94f8a6435d2ba170efe2858b0215472c65434575d62dfe9b40fb3899050c9bf39eb1457443ad29ff744d926f87f
+  data.tar.gz: '023180eea1874e7d4c17caa61bf39b5b8d5163b5681b4d0356ee8b41c65de4d9a4b32ddc233645d38b780fc6a4ae8345bd3d808d241e2d108021c38e67f9ccc5'

data/lib/rom/solr.rb

@@ -1,9 +1,13 @@
-require 'rom-http'
 require 'securerandom'
+require 'rom-http'
 
 module ROM
   module Solr
 
+    ESCAPE_CHARS     = Regexp.new('[%s]' % Regexp.escape('+-!(){}[]^"~*?:/'))
+    DOUBLE_AMPERSAND = Regexp.new('&&')
+    DOUBLE_PIPE      = Regexp.new('\|\|')
+
     def self.dataset_class(name)
       prefix = name.to_s.split(/[_\/]/).map(&:capitalize).join('')
       const_name = "#{prefix}Dataset"
@@ -20,32 +24,33 @@ module ROM
 end
 
 # Utilities
-require_relative 'solr/array'
+require 'rom/solr/array'
+require 'rom/solr/utils'
 
 # Handlers
-require_relative 'solr/request_handler'
-require_relative 'solr/response_handler'
+require 'rom/solr/request_handler'
+require 'rom/solr/response_handler'
 
 # Datasets
-require_relative 'solr/dataset'
-require_relative 'solr/documents_dataset'
-require_relative 'solr/schema_info_dataset'
+require 'rom/solr/dataset'
+require 'rom/solr/documents_dataset'
+require 'rom/solr/schema_info_dataset'
 
 # Gateway
-require_relative 'solr/gateway'
+require 'rom/solr/gateway'
 
 # Schemas
-require_relative 'solr/schema'
+require 'rom/solr/schema'
 
 # Relations
-require_relative 'solr/relation'
+require 'rom/solr/relation'
 
 # Repositories
-require_relative 'solr/repository'
-require_relative 'solr/schema_info_repo'
-require_relative 'solr/document_repo'
+require 'rom/solr/repository'
+require 'rom/solr/schema_info_repo'
+require 'rom/solr/document_repo'
 
 # Commands
-require_relative 'solr/commands'
+require 'rom/solr/commands'
 
 ROM.register_adapter(:solr, ROM::Solr)

data/lib/rom/solr/commands/create_documents.rb

@@ -6,7 +6,7 @@ module ROM
         relation :documents
 
         def execute(docs)
-          relation.insert(docs)
+          relation.insert(docs).response
         end
 
       end

data/lib/rom/solr/commands/delete_documents.rb

@@ -6,7 +6,7 @@ module ROM
         relation :documents
 
         def execute(docs)
-          relation.delete(docs)
+          relation.delete(docs).response
         end
 
       end

data/lib/rom/solr/commands/update_documents.rb

@@ -6,7 +6,7 @@ module ROM
         relation :documents
 
         def execute(docs)
-          relation.update(docs)
+          relation.update(docs).response
         end
 
       end

data/lib/rom/solr/dataset.rb

@@ -2,44 +2,32 @@ module ROM
   module Solr
     class Dataset < ROM::HTTP::Dataset
 
-      setting :default_response_key, reader: true
-      setting :default_content_type, reader: true
-      setting :default_base_path,    reader: true
+      setting :default_base_path, reader: true
 
       configure do |config|
         config.default_response_handler = ResponseHandler
         config.default_request_handler  = RequestHandler
       end
 
-      option :response_key, default: proc { self.class.default_response_key }
-      option :request_data, type: Types::String, default: proc { EMPTY_STRING }
-      option :content_type, type: Types::String, default: proc { self.class.default_content_type }
-      option :base_path,    type: Types::Path,   default: proc { self.class.default_base_path || EMPTY_STRING }
+      option :request_data, type: Types::String, optional: true
+      option :content_type, type: Types::String, optional: true
+
+      # @override
+      option :base_path, type: Types::Path, default: proc { self.class.default_base_path || EMPTY_STRING }
 
       # @override Query parameters are valid with POST, too.
       def uri
         uri_s = [options[:uri], path].compact.reject(&:empty?).join('/')
 
         URI(uri_s).tap do |u|
-          u.query = param_encoder.call(params) if has_params?
+          u.query = param_encoder.call(params) if params?
         end
       end
 
-      # @override
-      def each(&block)
-        return to_enum unless block_given?
-
-        enumerable_data.each(&block)
-      end
-
       def with_request_data(data)
         with_options(request_data: data)
       end
 
-      def with_response_key(*path)
-        with_options(response_key: path)
-      end
-
       # Copies and makes private superclass #response method
       alias_method :__response__, :response
       private :__response__
@@ -49,20 +37,28 @@ module ROM
         cache.fetch_or_store(:response) { __response__ }
       end
 
-      def has_request_data?
-        !request_data.nil? && !request_data.empty?
+      def response_header(key)
+        response.dig(:responseHeader, key)
+      end
+
+      def request_data?
+        !request_data.nil?
       end
 
-      def has_params?
+      def params?
         params.any?
       end
 
-      private
+      def status
+        response_header(:status)
+      end
 
-      def enumerable_data
-        Array.wrap(response_key ? response.dig(*response_key) : response)
+      def qtime
+        response_header(:QTime)
       end
 
+      private
+
       def cache
         @cache ||= Concurrent::Map.new
       end

data/lib/rom/solr/document_repo.rb

@@ -1,3 +1,5 @@
+require 'rom/solr/query_builder'
+
 module ROM
   module Solr
     class DocumentRepo < Repository[:documents]
@@ -8,24 +10,34 @@ module ROM
         documents.by_unique_key(id).one!
       end
 
-      def search
-        documents
-      end
-
       def all
         documents.all
       end
 
-      def create(docs)
-        documents.command(:create_documents).call(docs)
+      def create(docs, **opts)
+        docs_command(:create_documents, docs, **opts)
+      end
+
+      def delete(docs, **opts)
+        docs_command(:delete_documents, docs, **opts)
+      end
+
+      def delete_by_query(query, **opts)
+        docs_command(:delete_documents_by_query, query, **opts)
       end
 
-      def delete(docs)
-        documents.command(:delete_documents).call(docs)
+      def update(docs, **opts)
+        docs_command(:update_documents, docs, **opts)
       end
 
-      def update(docs)
-        documents.command(:update_documents).call(docs)
+      private
+
+      def docs_command(command, data, commit: false, commit_within: nil)
+        documents
+          .commit(commit)
+          .commit_within(commit_within)
+          .command(command)
+          .call(data)
       end
 
     end

data/lib/rom/solr/documents_dataset.rb

@@ -3,8 +3,58 @@ module ROM
     class DocumentsDataset < Dataset
 
       configure do |config|
-        config.default_response_key = [:response, :docs]
-        config.default_base_path    = 'select'
+        config.default_base_path = 'select'
+      end
+
+      # @override
+      def each(&block)
+        return to_enum unless block_given?
+
+        docs.each(&block)
+      end
+
+      def docs
+        search_response(:docs)
+      end
+
+      def cursor_mark
+        params[:cursorMark]
+      end
+
+      def next_cursor_mark
+        response[:nextCursorMark]
+      end
+
+      def num_found
+        search_response(:numFound)
+      end
+
+      def num_found_exact
+        search_response(:numFoundExact)
+      end
+
+      def num_found_exact?
+        num_found_exact === true
+      end
+
+      def search_response(key)
+        response.dig(:response, key)
+      end
+
+      def partial_results
+        response_header(:partialResults)
+      end
+
+      def partial_results?
+        partial_results === true
+      end
+
+      def response_params
+        response_header(:params)
+      end
+
+      def response_params?
+        !response_params.nil? && !response_params.empty?
       end
 
     end

data/lib/rom/solr/documents_paginator.rb

@@ -0,0 +1,21 @@
+require 'delegate'
+
+module ROM
+  module Solr
+    #
+    # Wraps a DocumentsDataset to provide pagination with a cursor.
+    #
+    class DocumentsPaginator < SimpleDelegator
+
+      def each(&block)
+        while true
+          super
+          break if cursor_mark == next_cursor_mark
+          next_page = __getobj__.add_params(cursorMark: next_cursor_mark)
+          __setobj__(next_page)
+        end
+      end
+
+    end
+  end
+end

data/lib/rom/solr/query.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module ROM
+  module Solr
+    module Query
+      include Utils
+
+      ANY_VALUE = '[* TO *]'
+      OR        = ' OR '
+      AND       = ' AND '
+
+      # Templates
+      DISJUNCTION = '{!lucene q.op=OR df=%{field}}%{value}'
+      JOIN        = '{!join from=%{from} to=%{to}}%{field}:%{value}'
+      NEGATION    = '-%{field}:%{value}'
+      REGEXP      = '%{field}:/%{value}/'
+      STANDARD    = '%{field}:%{value}'
+      TERM        = '{!term f=%{field}}%{value}'
+
+      # Value transformers
+      NOOP          = ->(v) { v }
+      ESCAPE        = ->(v) { escape(v) }
+      INTEGER       = ->(v) { v.to_i }
+      BEFORE_DATE   = ->(v) { '[* TO %s]' % solr_date(v) }
+      AFTER_DATE    = ->(v) { '[%s TO NOW]' % solr_date(v) }
+      BETWEEN_DATES = ->(a, b) { '[%s TO %s]' % [solr_date(a), solr_date(b)] }
+      EXACT_DATE    = ->(v) { escape(solr_date(v)) }
+
+      # Build standard query clause(s) -- i.e., field:value --
+      # and disjunction clauses (i.e., when value is an array).
+      #
+      # @param mapping [Hash] field=>value mapping
+      # @return [Array<String>] queries
+      def where(mapping)
+        render(STANDARD, mapping, ->(v) { Array.wrap(v).join(OR) })
+      end
+
+      # Builds negation clause(s) -- i.e., -field:value
+      #
+      # @param mapping [Hash] field=>value mapping
+      # @return [Array<String>] queries
+      def where_not(mapping)
+        render(NEGATION, mapping)
+      end
+
+      # Builds query clause(s) to filter where field is present
+      # (i.e., has one or more values)
+      #
+      # @param fields [Array<String>] on or more fields
+      # @return [Array<String>] queries
+      def exist(*fields)
+        mapping = fields.map { |field| {field: field, value: ANY_VALUE} }
+
+        render(STANDARD, mapping)
+      end
+
+      # Builds query clause(s) to filter where field is NOT present
+      # (i.e., no values)
+      #
+      # @param fields [Array<Symbol, String>] one or more fields
+      # @return [Array<String>] queries
+      def not_exist(*fields)
+        mapping = fields.map { |field| {field: "-#{field}", value: ANY_VALUE} }
+
+        render(STANDARD, mapping)
+      end
+
+      # Builds a Solr join clause
+      #
+      # @see https://wiki.apache.org/solr/Join
+      # @param from [String]
+      # @param to [String]
+      # @param field [String]
+      # @param value [String]
+      # @return [Array<String>] queries
+      def join(from:, to:, field:, value:)
+        [ JOIN % { from: from, to: to, field: field, value: value } ]
+      end
+
+      # Builds query clause(s) to filter where date field value
+      # is earlier than a date/time value.
+      #
+      # @param mapping [Hash] field=>value mapping
+      #   Values (coerced to strings) must be parseable by `DateTime.parse`.
+      # @return [Array<String>] queries
+      def before(mapping)
+        render(STANDARD, mapping, BEFORE_DATE)
+      end
+
+      # Builds query clause(s) to filter where date field value
+      # is later than a date/time value.
+      #
+      # @param mapping [Hash] field=>value mapping
+      #   Values (coerced to strings) must be parseable by `DateTime.parse`.
+      # @return [Array<String>] queries
+      def after(mapping)
+        render(STANDARD, mapping, AFTER_DATE)
+      end
+
+      def between_dates(mapping)
+        render(STANDARD, mapping, BETWEEN_DATES)
+      end
+
+      def exact_date(mapping)
+        render(STANDARD, mapping, EXACT_DATE)
+      end
+
+      # Builds term query clause(s) to filter where field contains value.
+      #
+      # @param mapping [Hash] field=>value mapping
+      # @return [Array<String>] queries
+      def term(mapping)
+        render(TERM, mapping)
+      end
+
+      # Builds regular expression query clause(s).
+      #
+      # @param mapping [Hash] field=>value mapping
+      # @return [Array<String>] queries
+      def regexp(mapping)
+        render(REGEXP, mapping, ESCAPE_SLASHE)
+      end
+
+      private
+
+      def render(template, mapping, transformer = NOOP)
+        mapping.transform_values(&transformer).map do |field, value|
+          template % {field: field, value: value}
+        end
+      end
+
+      extend self
+    end
+  end
+end

data/lib/rom/solr/query_builder.rb

@@ -0,0 +1,36 @@
+require 'rom/solr/query'
+
+module ROM
+  module Solr
+    class QueryBuilder
+      include Utils
+
+      attr_accessor :queries
+
+      def initialize(queries = [])
+        @queries = queries
+      end
+
+      def to_a
+        queries
+      end
+
+      def raw(*queries)
+        self.queries += queries
+      end
+
+      def respond_to_missing?(name, include_private = false)
+        Query.public_method_defined?(name, false) || super
+      end
+
+      def method_missing(name, *args)
+        if Query.respond_to?(name, false)
+          self.queries += Query.send(name, *args)
+        else
+          super
+        end
+      end
+
+    end
+  end
+end

data/lib/rom/solr/query_templates.rb

@@ -0,0 +1,34 @@
+require 'delegate'
+
+module ROM
+  module Solr
+    module QueryTemplates
+
+      #
+      # Simple template object with a `#render` method.
+      #
+      # N.B. Values must be properly escaped and/or
+      # formatted for Solr prior to rendering!
+      #
+      class Template < SimpleDelegator
+        # @param data [Hash]
+        def render(data)
+          __getobj__ % data
+        end
+      end
+
+      STANDARD    = Template.new('%{field}:%{value}')
+
+      ABSENT      = Template.new('-%{field}:[* TO *]')
+      BEFORE_DATE = Template.new('%{field}:[* TO %{value}]')
+      BEFORE_DAYS = Template.new('%{field}:[* TO NOW-%{value}DAYS]')
+      DISJUNCTION = Template.new('{!lucene q.op=OR df=%{field}}%{value}')
+      JOIN        = Template.new('{!join from=%{from} to=%{to}}%{field}:%{value}')
+      NEGATION    = Template.new('-%{field}:%{value}')
+      PRESENT     = Template.new('%{field}:[* TO *]')
+      REGEXP      = Template.new('%{field}:/%{value}/')
+      TERM        = Template.new('{!term f=%{field}}%{value}')
+
+    end
+  end
+end

data/lib/rom/solr/relation.rb

@@ -1,37 +1,37 @@
+require 'forwardable'
+
 module ROM
   module Solr
     class Relation < ROM::HTTP::Relation
+      extend Forwardable
+
+      RESPONSE_WRITERS = %w[ csv geojson javabin json php phps python ruby smile velocity xlsx xml xslt ]
+
+      def_delegators :dataset, :response, :params
 
       adapter     :solr
       auto_struct false
       auto_map    false
 
-      forward :with_response_key
-
+      # Need this?
       option :output_schema, default: ->{ NOOP_OUTPUT_SCHEMA }
 
-      def wt(format)
-        add_params(wt: Types::Coercible::String[format])
+      def wt(writer)
+        add_params(wt: Types::Coercible::String.enum(*RESPONSE_WRITERS)[writer])
       end
-      alias_method :format, :wt
-
-      def log_params_list(log_params)
-        lplist = log_params.nil? ? nil : Array.wrap(log_params).join(',')
 
-        add_params(logParamsList: lplist)
-      end
-      alias_method :log_params, :log_params_list
+      def log_params_list(*log_params)
+        new_log_params = Types::Array.of(Types::String)[log_params]
 
-      def count
-        to_enum.count
+        add_params(logParamsList: new_log_params.join(','))
       end
 
-      def response
-        dataset.response
+      def omit_header(omit = true)
+        add_params(omitHeader: Types::Bool[omit])
       end
 
-      def params
-        dataset.params.dup
+      def count
+        to_enum.count
       end
 
     end

data/lib/rom/solr/relations/documents_relation.rb

@@ -1,16 +1,21 @@
-require 'rom/solr/select_cursor'
+require 'rom/solr/documents_paginator'
+require 'rom/solr/query_builder'
 
 module ROM
   module Solr
     class DocumentsRelation < Relation
 
+      def_delegators :dataset, :num_found, :num_found_exact?
+
       schema(:documents) { }
 
       # @override
       def each(&block)
+        return super unless cursor?
+
         return to_enum unless block_given?
 
-        SelectCursor.new(dataset).each(&block)
+        DocumentsPaginator.new(dataset).each(&block)
       end
 
       # @override FIXME: Get from Solr schema unique key
@@ -28,36 +33,74 @@ module ROM
 
       # @override
       def count
-        num_found_exact ? num_found : super
+        num_found_exact? ? num_found : super
+      end
+
+      # Set a cursor on the relation for pagination
+      def cursor
+        relation = add_params(cursorMark: '*')
+
+        # Sort must include a sort on unique key (id).
+        if /\bid\b/ =~ params[:sort]
+          relation
+        else
+          relation.sort(params[:sort], 'id ASC')
+        end
       end
 
-      def num_found
-        response.dig(:response, :numFound)
+      def cursor?
+        params.key?(:cursorMark)
       end
 
-      def num_found_exact
-        response.dig(:response, :numFoundExact)
+      def query(&block)
+        queries = QueryBuilder.new.instance_eval(&block).to_a
+
+        q(*queries)
+      end
+
+      def filter(&block)
+        queries = QueryBuilder.new.instance_eval(&block).to_a
+
+        fq(*queries)
       end
 
+      #
+      # Commands
+      #
+
       def insert(docs)
+        # FIXME: use input schema
         data = Array.wrap(docs).map do |doc|
           doc.transform_keys!(&:to_sym)
           doc[:id] ||= UUID[]
+          doc
         end
 
-        update(data)
+        with_options(
+          base_path: 'update/json/docs',
+          content_type: 'application/json',
+          request_data: JSON.dump(data)
+        )
       end
 
       def update(docs)
+        # FIXME: use input schema
+        data = Array.wrap(docs)
+                 .map    { |doc| doc.transform_keys(&:to_sym) }
+                 .select { |doc| doc.key?(:id) }
+
         with_options(
           base_path: 'update/json/docs',
           content_type: 'application/json',
-          request_data: JSON.dump(docs)
+          request_data: JSON.dump(data)
         )
       end
 
       def delete(docs)
-        ids = Array.wrap(docs).map { |doc| doc.transform_keys(&:to_sym) }.map(&:id)
+        # FIXME: use input schema
+        ids = Array.wrap(docs)
+                .map { |doc| doc.transform_keys(&:to_sym) }
+                .map { |doc| doc.fetch(:id) }
 
         with_options(
           base_path: 'update',
@@ -66,93 +109,105 @@ module ROM
         )
       end
 
+      def delete_by_query(query)
+        with_options(
+          base_path: 'update',
+          content_type: 'application/json',
+          request_data: JSON.dump(delete: {query: query})
+        )
+      end
+
       #
-      # Params
+      # Common Query Parameters
       #
-      def q(query)
-        add_params(q: Types::String[query])
+
+      def q(*queries)
+        old_queries = Array.wrap(params[:q])
+        new_queries = Array.wrap(queries).flatten
+
+        add_params q: (old_queries + new_queries).join(' ')
       end
-      alias_method :query, :q
 
-      def fq(*filter)
-        add_params(fq: filter)
+      def fq(*queries)
+        old_queries = Array.wrap(params[:fq])
+        new_queries = Array.wrap(queries).flatten
+
+        add_params fq: old_queries + new_queries
       end
-      alias_method :filter, :fq
 
       def fl(*fields)
-        add_params(fl: fields.join(','))
+        new_fields = Types::Array.of(Types::Coercible::String)[fields]
+
+        add_params fl: new_fields.join(',')
       end
+
       alias_method :fields, :fl
 
       def cache(enabled = true)
-        add_params(cache: Types::Bool[enabled])
+        add_params cache: Types::Bool[enabled]
       end
 
       def segment_terminate_early(enabled = true)
-        add_params(segmentTerminateEarly: Types::Bool[enabled])
+        add_params segmentTerminateEarly: Types::Bool[enabled]
       end
 
       def time_allowed(millis)
-        add_params(timeAllowed: Types::Coercible::Integer[millis])
+        add_params timeAllowed: Types::Coercible::Integer[millis]
       end
 
       def explain_other(query)
-        add_params(explainOther: Types::String[query])
-      end
-
-      def omit_header(omit = true)
-        add_params(omitHeader: Types::Bool[omit])
+        add_params explainOther: Types::String[query]
       end
 
       def start(offset)
-        add_params(start: Types::Coercible::Integer[offset])
+        add_params start: Types::Coercible::Integer[offset]
       end
 
       def sort(*criteria)
-        add_params(sort: criteria.join(','))
+        new_sort = Types::Array.of(Types::String)[criteria]
+
+        add_params sort: new_sort.join(',')
       end
 
       def rows(num)
-        add_params(rows: Types::Coercible::Integer[num])
+        add_params rows: Types::Coercible::Integer[num]
       end
+
       alias_method :limit, :rows
 
       def def_type(value)
-        add_params(defType: Types::Coercible::String[value])
+        add_params defType: Types::Coercible::String[value]
       end
 
       def debug(setting)
-        type = Types::Coercible::String
-                 .enum('query', 'timing', 'results', 'all', 'true')
-
-        add_params(debug: type[setting])
+        add_params debug: Types::Coercible::String.enum('query', 'timing', 'results', 'all', 'true')[setting]
       end
 
       def echo_params(setting)
-        type = Types::Coercible::String.enum('explicit', 'all', 'none')
-        add_params(echoParams: type[setting])
+        add_params echoParams: Types::Coercible::String.enum('explicit', 'all', 'none')[setting]
       end
 
       def min_exact_count(num)
-        add_params(minExactCount: Types::Coercible::Integer[num])
+        add_params minExactCount: Types::Coercible::Integer[num]
       end
 
+      #
+      # Commit parameters
+      #
       def commit(value = true)
-        add_params(commit: Types::Bool[value])
+        add_params commit: Types::Bool[value]
       end
 
       def commit_within(millis)
-        return self if millis.nil?
-
-        add_params(commitWithin: Types::Coercible::Integer[millis])
+        add_params commitWithin: Types::Coercible::Integer.optional[millis]
       end
 
       def overwrite(value = true)
-        add_params(overwrite: Types::Bool[value])
+        add_params overwrite: Types::Bool[value]
       end
 
       def expunge_deletes(value = true)
-        add_params(expungeDeletes: Types::Bool[value])
+        add_params expungeDeletes: Types::Bool[value]
       end
 
     end

data/lib/rom/solr/relations/schema_info_relation.rb

@@ -15,84 +15,62 @@ module ROM
       end
 
       def info
-        with_response_key(:schema)
+        self
       end
 
-      def copy_fields
-        with_options(
-          path: :copyfields,
-          response_key: :copyFields
-        )
+      def copy_fields(source_fields: nil, dest_fields: nil)
+        source_fl = Array.wrap(source_fields).join(',') unless source_fields.nil?
+        dest_fl   = Array.wrap(dest_fields).join(',') unless dest_fields.nil?
+
+        with_path(:copyfields)
+          .add_params('source.fl'=>source_fl, 'dest.fl'=>dest_fl)
       end
 
-      def dynamic_fields
-        with_options(
-          path: :dynamicfields,
-          response_key: :dynamicFields
-        )
+      def dynamic_fields(defaults: true)
+        with_path(:dynamicfields)
+          .show_defaults(defaults)
       end
 
-      def dynamic_field(name)
-        with_options(
-          path: "dynamicfields/#{name}",
-          response_key: :dynamicField
-        )
+      def dynamic_field(name, defaults: true)
+        with_path("dynamicfields/#{name}")
+          .show_defaults(defaults)
       end
 
       def similarity
-        with_options(
-          path: :similarity,
-          response_key: :similarity
-        )
+        with_path :similarity
       end
 
       def unique_key
-        with_options(
-          path: :uniquekey,
-          response_key: :uniqueKey
-        )
+        with_path :uniquekey
       end
 
       def version
-        with_options(
-          path: :version,
-          response_key: :version
-        )
+        with_path :version
       end
 
       def schema_name
-        with_options(
-          path: :name,
-          response_key: :name
-        )
+        with_path :name
       end
 
-      def fields
-        with_options(
-          path: :fields,
-          response_key: :fields
-        )
+      def fields(dynamic: true, defaults: true)
+        with_path(:fields)
+          .include_dynamic(dynamic)
+          .show_defaults(defaults)
       end
 
-      def field(name)
-        with_options(
-          path: "fields/#{name}",
-          response_key: :field
-        )
+      def field(name, defaults: true)
+        with_path("fields/#{name}")
+          .show_defaults(defaults)
       end
 
-      def field_types
-        with_options(
-          path: :fieldtypes,
-          response_key: :fieldTypes
-        )
+      def field_types(defaults: true)
+        with_path(:fieldtypes)
+          .show_defaults(defaults)
       end
 
-      def field_type(name)
-        with_options(
-          path: "fieldtypes/#{name}",
-          response_key: :fieldType
-        )
+      def field_type(name, defaults: true)
+        with_path("fieldtypes/#{name}")
+          .show_defaults(defaults)
       end
 
     end

data/lib/rom/solr/request_handler.rb

@@ -20,7 +20,7 @@ module ROM
 
       def request
         request_class.new(uri.request_uri, headers).tap do |req|
-          if dataset.has_request_data?
+          if dataset.request_data?
             req.body = dataset.request_data
             req.content_type = dataset.content_type
           end
@@ -33,14 +33,14 @@ module ROM
 
       def uri
         @uri ||= URI(dataset.uri).tap do |u|
-          if dataset.has_params?
+          if dataset.params?
             u.query ||= URI.encode_www_form(dataset.params)
           end
         end
       end
 
       def request_class
-        if dataset.has_request_data?
+        if dataset.request_data?
           Net::HTTP::Post
         else
           Net::HTTP::Get

data/lib/rom/solr/schema_info_dataset.rb

@@ -4,6 +4,14 @@ module ROM
 
       configure do |config|
         config.default_base_path = 'schema'
+
+        config.default_response_handler = Proc.new do |*args|
+          ResponseHandler.call(*args).values.flatten
+        end
+
+        config.default_request_handler = Proc.new do |dataset|
+          RequestHandler.call(dataset.add_params(omitHeader: true))
+        end
       end
 
     end

data/lib/rom/solr/schema_info_repo.rb

@@ -1,43 +1,27 @@
+require 'forwardable'
+
 module ROM
   module Solr
     class SchemaInfoRepo < Repository[:schema_info]
+      extend Forwardable
 
       auto_struct false
 
-      %i[ schema_name similarity unique_key version ].each do |name|
-        define_method name, ->{ schema_info.send(name).one! }
-      end
-
-      def info
-        schema_info.info.one!
-      end
-
-      def fields(dynamic: true, defaults: true)
-        schema_info.fields.show_defaults(defaults).include_dynamic(dynamic)
-      end
-
-      def field(name, defaults: true)
-        schema_info.field(name).show_defaults(defaults).one
-      end
-
-      def field_types(defaults: true)
-        schema_info.field_types.show_defaults(defaults)
-      end
-
-      def field_type(name, defaults: true)
-        schema_info.field_type(name).show_defaults(defaults).one
-      end
-
-      def dynamic_fields
-        schema_info.dynamic_fields
-      end
-
-      def dynamic_field(name, defaults: true)
-        schema_info.dynamic_field(name).show_defaults(defaults).one
-      end
-
-      def copy_fields
-        schema_info.copy_fields
+      VALUES = %i[ schema_name
+                   similarity
+                   unique_key
+                   version
+                   info
+                   field
+                   field_type
+                   dynamic_field
+                   copy_field
+                   ]
+
+      def_delegators :schema_info, :fields, :field_types, :dynamic_fields, :copy_fields
+
+      VALUES.each do |name|
+        define_method name, proc { |*args| schema_info.send(name, *args).one! }
       end
 
     end

data/lib/rom/solr/utils.rb

@@ -0,0 +1,36 @@
+require 'date'
+require 'time'
+
+module ROM
+  module Solr
+    module Utils
+
+      def phrase(value)
+        if value.match?(/ /)
+          '"%s"' % value.gsub(/"/, '\"')
+        else
+          value
+        end
+      end
+
+      # Escape a Solr query value
+      #
+      # @param value [String] raw value
+      # @return [String] escaped value
+      def escape(value)
+        value
+          .gsub(ESCAPE_CHARS, '\\1')
+          .gsub(DOUBLE_AMPERSAND, '\&\&')
+          .gsub(DOUBLE_PIPE, '\|\|')
+      end
+
+      # Formats a value as a Solr date.
+      def solr_date(value)
+        DateTime.parse(value.to_s).to_time.utc.iso8601
+      end
+
+      extend self
+
+    end
+  end
+end

data/lib/solrbee.rb

@@ -1,6 +1,7 @@
-require "solrbee/version"
+require 'solrbee/version'
 
-require "rom/solr"
+require 'dry-types'
+require 'rom/solr'
 
 module Solrbee
 
@@ -25,4 +26,8 @@ module Solrbee
     end
   end
 
+  module Types
+    include Dry.Types()
+  end
+
 end

data/lib/solrbee/version.rb

@@ -1,3 +1,3 @@
 module Solrbee
-  VERSION = "0.4.0"
+  VERSION = "0.5.0"
 end

data/solrbee.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "rom"
   spec.add_dependency "rom-http"
+  spec.add_dependency "dry-types"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solrbee
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - David Chandek-Stark
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-31 00:00:00.000000000 Z
+date: 2021-01-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rom
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: dry-types
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -121,7 +135,11 @@ files:
 - lib/rom/solr/dataset.rb
 - lib/rom/solr/document_repo.rb
 - lib/rom/solr/documents_dataset.rb
+- lib/rom/solr/documents_paginator.rb
 - lib/rom/solr/gateway.rb
+- lib/rom/solr/query.rb
+- lib/rom/solr/query_builder.rb
+- lib/rom/solr/query_templates.rb
 - lib/rom/solr/relation.rb
 - lib/rom/solr/relations/documents_relation.rb
 - lib/rom/solr/relations/schema_info_relation.rb
@@ -131,7 +149,7 @@ files:
 - lib/rom/solr/schema.rb
 - lib/rom/solr/schema_info_dataset.rb
 - lib/rom/solr/schema_info_repo.rb
-- lib/rom/solr/select_cursor.rb
+- lib/rom/solr/utils.rb
 - lib/solrbee.rb
 - lib/solrbee/version.rb
 - solrbee.gemspec

data/lib/rom/solr/select_cursor.rb

@@ -1,56 +0,0 @@
-require 'delegate'
-
-module ROM
-  module Solr
-    #
-    # Wraps a DocumentsDataset to provide pagination with a cursor.
-    #
-    class SelectCursor < SimpleDelegator
-
-      def initialize(dataset)
-        params = { cursorMark: '*' }
-
-        # Sort must include a sort on unique key (id).
-        sort = dataset.params[:sort]
-        unless /\bid\b/ =~ sort
-          params[:sort] = Array.wrap(sort).append('id ASC').join(',')
-        end
-
-        super dataset.add_params(params)
-      end
-
-      def each(&block)
-        return to_enum unless block_given?
-
-        while true
-          __getobj__.each(&block)
-
-          break if last_page?
-
-          move_cursor
-        end
-      end
-
-      def cursor_mark
-        params[:cursorMark]
-      end
-
-      def next_cursor_mark
-        response[:nextCursorMark]
-      end
-
-      def last_page?
-        cursor_mark == next_cursor_mark
-      end
-
-      def move_cursor
-        __setobj__(next_page)
-      end
-
-      def next_page
-        __getobj__.add_params(cursorMark: next_cursor_mark)
-      end
-
-    end
-  end
-end