solrbee 0.1.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 356cd5b312edac759a4090191b33a48282a49b379bf44aecdf224ec47ce73fd0
-  data.tar.gz: f0d399ed8c9eccfe86fffd3492ba248fe7b736407aee26a2465afa54962d89bd
+  metadata.gz: 32b15ba57c92024c22c90c365c673098bbc5031fb14e76ae62ea75868e0d1ec3
+  data.tar.gz: 7aa16b385b8ddff45506966c1fbbb9b3e6252cfff2053b4f29377f09b9c4b9a1
 SHA512:
-  metadata.gz: 7002601a792323c6533157152f92cab212e23fffd006f714f89b6f3610a20e4dfa35fab27451bb7a93b9e1f0e920e8b7081720e261143bb5568264a8d3817449
-  data.tar.gz: d29a32a7d00f985bf38bf1f7c36a044f78064739999b318ef4d3070eb1e411a04124c7c3e9140a6afce92ef28df018c6caa1554b82a5a44d307292d41d7af95f
+  metadata.gz: c20241f1f4ed8e31fee8aa383bcf1a643f3dd94f8a6435d2ba170efe2858b0215472c65434575d62dfe9b40fb3899050c9bf39eb1457443ad29ff744d926f87f
+  data.tar.gz: '023180eea1874e7d4c17caa61bf39b5b8d5163b5681b4d0356ee8b41c65de4d9a4b32ddc233645d38b780fc6a4ae8345bd3d808d241e2d108021c38e67f9ccc5'

data/Gemfile

@@ -1,3 +1,6 @@
 source "https://rubygems.org"
 
 gemspec
+
+gem 'rom', '5.2.4'
+gem 'rom-http', git: 'https://github.com/rom-rb/rom-http.git'

data/Makefile

@@ -2,7 +2,4 @@ SHELL = /bin/bash
 
 .PHONY : test
 test:
-	docker run --rm -d -p 8983:8983 --name solrbee-test solr:8 solr-precreate solrbee
-	while ! curl -fs http://localhost:8983/solr/solrbee/admin/ping 2>/dev/null ; do sleep 1 ; done
-	bundle exec rake
-	docker stop solrbee-test
+	./test.sh

data/README.md

@@ -25,17 +25,7 @@ Or install it yourself as:
 
 ## Usage
 
-```
-$ bundle console
-irb(main):001:0> client = Solrbee::Client.new('solrbee')
-=> #<Solrbee::Client:0x00007fd3410d7c50 @collection="solrbee", @uri=#<URI::HTTP http://localhost:8983/solr/solrbee>>
-irb(main):002:0> client.unique_key
-=> "id"
-irb(main):003:0> client.schema_version
-=> 1.6
-irb(main):004:0> client.schema_name
-=> "default-config"
-```
+TODO
 
 ## Development
 

data/config/api.yml

@@ -0,0 +1,22 @@
+    field_types:
+      path: fieldtypes
+      key: fieldTypes
+    field_type:
+      desc: GET /schema/fieldtype/[name]
+      path: fieldtypes/%{name}
+      args:
+        - name
+      key: fieldType
+    dynamic_fields:
+      desc: GET /schema/dynamicfields
+      path: dynamicfields
+      key: dynamicFields
+    dynamic_field:
+      desc: GET /schema/dynamicfields/[name]
+      args:
+        - name
+      path: dynamicfields/%{name}
+      key: dynamicField
+    copy_fields:
+      path: copyfields
+      key: copyFields

data/lib/rom/solr.rb

@@ -0,0 +1,56 @@
+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"
+      const_defined?(const_name, false) ? const_get(const_name, false) : Dataset
+    end
+
+    module Types
+      include ROM::HTTP::Types
+    end
+
+    UUID = Types::String.default { SecureRandom.uuid }
+
+  end
+end
+
+# Utilities
+require 'rom/solr/array'
+require 'rom/solr/utils'
+
+# Handlers
+require 'rom/solr/request_handler'
+require 'rom/solr/response_handler'
+
+# Datasets
+require 'rom/solr/dataset'
+require 'rom/solr/documents_dataset'
+require 'rom/solr/schema_info_dataset'
+
+# Gateway
+require 'rom/solr/gateway'
+
+# Schemas
+require 'rom/solr/schema'
+
+# Relations
+require 'rom/solr/relation'
+
+# Repositories
+require 'rom/solr/repository'
+require 'rom/solr/schema_info_repo'
+require 'rom/solr/document_repo'
+
+# Commands
+require 'rom/solr/commands'
+
+ROM.register_adapter(:solr, ROM::Solr)

data/lib/rom/solr/array.rb

@@ -0,0 +1,10 @@
+Array.class_eval do
+
+  # Inspired by Rails's Array.wrap
+  def self.wrap(obj)
+    return [] if obj.nil?
+    return obj.to_ary if obj.respond_to?(:to_ary)
+    Array.new(1, obj)
+  end
+
+end

data/lib/rom/solr/commands.rb

@@ -0,0 +1,17 @@
+module ROM
+  module Solr
+    module Commands
+      class Create < ROM::Commands::Create
+        adapter :solr
+      end
+
+      class Update < ROM::Commands::Update
+        adapter :solr
+      end
+
+      class Delete < ROM::Commands::Delete
+        adapter :solr
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module ROM
+  module Solr
+    module Commands
+      class CreateDocuments < Create
+
+        relation :documents
+
+        def execute(docs)
+          relation.insert(docs).response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module ROM
+  module Solr
+    module Commands
+      class DeleteDocuments < Delete
+
+        relation :documents
+
+        def execute(docs)
+          relation.delete(docs).response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module ROM
+  module Solr
+    module Commands
+      class DeleteDocumentsByQuery < Delete
+
+        relation :documents
+
+        def execute(query)
+          relation.delete_by_query(query).response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module ROM
+  module Solr
+    module Commands
+      class UpdateDocuments < Update
+
+        relation :documents
+
+        def execute(docs)
+          relation.update(docs).response
+        end
+
+      end
+    end
+  end
+end

data/lib/rom/solr/dataset.rb

@@ -0,0 +1,68 @@
+module ROM
+  module Solr
+    class Dataset < ROM::HTTP::Dataset
+
+      setting :default_base_path, reader: true
+
+      configure do |config|
+        config.default_response_handler = ResponseHandler
+        config.default_request_handler  = RequestHandler
+      end
+
+      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 params?
+        end
+      end
+
+      def with_request_data(data)
+        with_options(request_data: data)
+      end
+
+      # Copies and makes private superclass #response method
+      alias_method :__response__, :response
+      private :__response__
+
+      # @override Cache response by default
+      def response
+        cache.fetch_or_store(:response) { __response__ }
+      end
+
+      def response_header(key)
+        response.dig(:responseHeader, key)
+      end
+
+      def request_data?
+        !request_data.nil?
+      end
+
+      def params?
+        params.any?
+      end
+
+      def status
+        response_header(:status)
+      end
+
+      def qtime
+        response_header(:QTime)
+      end
+
+      private
+
+      def cache
+        @cache ||= Concurrent::Map.new
+      end
+
+    end
+  end
+end

data/lib/rom/solr/document_repo.rb

@@ -0,0 +1,45 @@
+require 'rom/solr/query_builder'
+
+module ROM
+  module Solr
+    class DocumentRepo < Repository[:documents]
+
+      auto_struct false
+
+      def find(id)
+        documents.by_unique_key(id).one!
+      end
+
+      def all
+        documents.all
+      end
+
+      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 update(docs, **opts)
+        docs_command(:update_documents, docs, **opts)
+      end
+
+      private
+
+      def docs_command(command, data, commit: false, commit_within: nil)
+        documents
+          .commit(commit)
+          .commit_within(commit_within)
+          .command(command)
+          .call(data)
+      end
+
+    end
+  end
+end

data/lib/rom/solr/documents_dataset.rb

@@ -0,0 +1,62 @@
+module ROM
+  module Solr
+    class DocumentsDataset < Dataset
+
+      configure do |config|
+        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
+  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/gateway.rb

@@ -0,0 +1,14 @@
+module ROM
+  module Solr
+    class Gateway < ROM::HTTP::Gateway
+
+      adapter :solr
+
+      # @override
+      def dataset(name)
+        ROM::Solr.dataset_class(name).new(config)
+      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