solrbee 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba9c7b336f903632e73bba3dc8b7689a11581dbac82db1a5e766edc427f12a1d
-  data.tar.gz: 508e84b7cafb3e65a71eb95d6e8afe1a76df69cced60ad4d7f770685cd63caa4
+  metadata.gz: 77e7ebc45077bb8016d699124b9d4de397adba4d6166e0b3f64bb07693c51a3f
+  data.tar.gz: 846ea941962ac61ac49195bc0a05ef4356fbc0937a96055af43320c833b41b5d
 SHA512:
-  metadata.gz: 47e306541ae1e6551b3a45212045970533d4d6fee01f6ac70c291d08bc618f9a964d513c6517d534e66568c60605213a0a4aa33c3bd2dd20660f27f761dcb40f
-  data.tar.gz: 6cf7560f0015d0d564e0e6c897f34c4b90a1d76e962f729cdc4a565775589c456f1c15d2d17066f2e0b5f5c42b0b24c32ff9814040e353694e36680291751cea
+  metadata.gz: 278f91339f713389ab9858471f35f8a72d07ae1e00083e931cade7af50aee540ba8abf1bd42a79f1a1ffa11ab3b081f8a3231035642ff61091abc7f8f3306da5
+  data.tar.gz: a143efa02fed4ee7e10c063bf4c4db6df6df5f9bbf40ba820c004c4961e206545d980ed615f566b99c996f30db184a49fce7a005d990ebbca4b9028cddadaebf

data/Gemfile

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

data/config/api.yml

@@ -0,0 +1,45 @@
+v1:
+  ping:
+    path: /admin/ping
+    response_key: status
+
+  schema:
+    path: /schema
+    response_key: schema
+
+  schema_name:
+    path: /schema/name
+    response_key: name
+
+  schema_version:
+    path: /schema/version
+    response_key: version
+
+  fields:
+    path: /schema/fields
+    response_key: fields
+
+  field:
+    path: /schema/fields/%{name}
+    response_key: field
+
+  unique_key:
+    path: /schema/uniquekey
+    response_key: uniqueKey
+
+  field_types:
+    path: /schema/fieldtypes
+    response_key: fieldTypes
+
+  field_type:
+    path: /schema/fieldtypes/%{name}
+    response_key: fieldType
+
+  update:
+    path: /update
+
+  update_json:
+    path: /update/json
+
+  update_json_docs:
+    path: /update/json/docs

data/lib/rom/solr.rb

@@ -0,0 +1,22 @@
+require 'rom-http'
+
+require_relative 'solr/request'
+require_relative 'solr/response'
+
+require_relative 'solr/dataset'
+require_relative 'solr/datasets/select_dataset'
+
+require_relative 'solr/gateway'
+
+require_relative 'solr/schemaless'
+
+require_relative 'solr/relation'
+require_relative 'solr/relations/schema_relation'
+require_relative 'solr/relations/select_relation'
+
+module ROM
+  module Solr
+  end
+
+  register_adapter(:solr, ROM::Solr)
+end

data/lib/rom/solr/dataset.rb

@@ -0,0 +1,93 @@
+module ROM
+  module Solr
+    class Dataset < ROM::HTTP::Dataset
+
+      # Key or array of keys to pass to response.dig(*keys)
+      # for enumeration of the dataset values.
+      setting :default_enum_on, reader: true
+      option :enum_on, default: ->{ self.class.default_enum_on }
+
+      # Default query parameters
+      setting :default_params, EMPTY_HASH, reader: true
+      option :params, type: Types::Hash, default: ->{ self.class.default_params }
+
+      # Request and response handlers
+      config.default_response_handler = Response
+      config.default_request_handler = Request
+
+      # @override Handles multiple path segments and nils
+      def with_path(segments)
+        s = Array.wrap(segments)
+        return self if s.empty?
+        with_options(path: s.compact.join('/'))
+      end
+
+      def with_enum_on(keys)
+        k = Array.wrap(keys)
+        return self if k.empty?
+        with_options(enum_on: k)
+      end
+
+      # Coerce param value to an Array and set new value
+      # to set union with other Array of values.
+      def add_param_values(key, val)
+        new_val = Array.wrap(params[key]) | Array.wrap(val)
+        add_params(key => new_val)
+      end
+
+      # @override
+      def add_params(new_params = {})
+        return self if new_params.nil? || new_params.empty?
+        with_params params.merge(new_params).compact
+      end
+
+      def default_params(defaults = {})
+        with_params defaults.merge(params)
+      end
+
+      # @override Seems good to have no-op when params not changed?
+      def with_params(new_params)
+        if params == new_params
+          self
+        else
+          with_options(params: new_params)
+        end
+      end
+
+      def param?(key)
+        params.key?(key)
+      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
+
+      # @override
+      def each(&block)
+        return to_enum unless block_given?
+        enumerable_response.each(&block)
+      end
+
+      def enumerable_response
+        if options[:enum_on].nil?
+          Array.wrap(response)
+        else
+          keys = Array.wrap options[:enum_on]
+          Array.wrap response.dig(*keys)
+        end
+      end
+
+      private
+
+      def cache
+        @cache ||= Concurrent::Map.new
+      end
+
+    end
+  end
+end

data/lib/rom/solr/datasets/select_dataset.rb

@@ -0,0 +1,53 @@
+module ROM
+  module Solr
+    class SelectDataset < Dataset
+
+      config.default_enum_on = [ 'response', 'docs' ]
+      config.default_params  = { q: '*:*', start: 0, rows: 20, cursorMark: '*', sort: 'id ASC' }
+
+      # @override
+      def each
+        while true
+          enumerable_response.each { |doc| yield(doc) }
+          break if last_page?
+          update_cursor_mark
+        end
+      end
+
+      def num_found
+        response.dig('response', 'numFound')
+      end
+
+      def cursor_mark
+        params[:cursorMark]
+      end
+
+      def next_cursor_mark
+        response['nextCursorMark']
+      end
+
+      def page_size
+        params[:rows]
+      end
+
+      def last_cursor?
+        cursor_mark == next_cursor_mark
+      end
+
+      def one_page?
+        num_found <= page_size
+      end
+
+      def last_page?
+        one_page? || last_cursor?
+      end
+
+      private
+
+      def update_cursor_mark
+        add_params(cursorMark: next_cursor_mark)
+      end
+
+    end
+  end
+end

data/lib/rom/solr/gateway.rb

@@ -0,0 +1,25 @@
+module ROM
+  module Solr
+    class Gateway < ROM::HTTP::Gateway
+
+      adapter :solr
+
+      def initialize(config = {})
+        config[:uri]     ||= ENV.fetch('SOLR_URL', 'http://localhost:8983/solr')
+        config[:headers] ||= { Accept: 'application/json' }
+        super
+      end
+
+      def dataset(name)
+        dataset_class(name).new config.merge(base_path: name)
+      end
+
+      def dataset_class(name)
+        prefix = name.to_s.split(/_/).map(&:capitalize).join('')
+        const_name = "#{prefix}Dataset"
+        ROM::Solr.const_defined?(const_name, false) ? ROM::Solr.const_get(const_name, false) : Dataset
+      end
+
+    end
+  end
+end

data/lib/rom/solr/paginated_dataset.rb

@@ -0,0 +1,62 @@
+module ROM
+  module Solr
+    class PaginatedDataset
+
+      attr_reader :dataset
+
+      def initialize(dataset)
+        ds = dataset
+               .default_params(rows: 20)
+               .remove_params(:start)
+               .add_params(cursorMark: '*')
+
+        if ds.param?(:sort)
+          unless ds.params[:sort] =~ /\bid\b/
+            ds = ds.sort('%{sort},id ASC' % ds.params)
+          end
+        else
+          ds = ds.sort('id ASC')
+        end
+
+        @dataset = ds
+      end
+
+      def each
+        while true
+          yield dataset
+          break if last_page?
+          @dataset = dataset.add_params(cursorMark: next_cursor_mark)
+        end
+      end
+
+      def cursor_mark
+        dataset.params[:cursorMark]
+      end
+
+      def next_cursor_mark
+        dataset.response['nextCursorMark']
+      end
+
+      def page_size
+        dataset.params[:rows]
+      end
+
+      def total_size
+        dataset.num_found
+      end
+
+      def last_cursor?
+        cursor_mark == next_cursor_mark
+      end
+
+      def one_page?
+        total_size <= page_size
+      end
+
+      def last_page?
+        one_page? || last_cursor?
+      end
+
+    end
+  end
+end

data/lib/rom/solr/relation.rb

@@ -0,0 +1,25 @@
+module ROM
+  module Solr
+    class Relation < ROM::HTTP::Relation
+      extend Schemaless
+
+      adapter :solr
+
+      forward :add_param_values, :default_params, :with_enum_on
+
+      def fetch(key, default = nil)
+        return self if key.nil?
+        dataset.response.fetch(key, default)
+      end
+
+      def count
+        to_enum.count
+      end
+
+      def all
+        self
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module ROM
+  module Solr
+    class SchemaRelation < Relation
+
+      schemaless(:schema, as: :schema_info)
+
+      # GET /schema
+      def info
+        fetch('schema')
+      end
+
+      def schema_name
+        with_path(:name).fetch(:name)
+      end
+
+      def version
+        with_path('version').fetch('version')
+      end
+
+      def unique_key
+        with_path('uniquekey').fetch('uniqueKey')
+      end
+
+      def similarity
+        with_path('similarity').fetch('similarity')
+      end
+
+      # @param opts [Hash]
+      def fields(**opts)
+        default_opts = { showDefaults: true }
+        with_path('fields')
+          .with_enum_on('fields')
+          .add_params(default_opts.merge(opts))
+      end
+
+      # @param name [String, Symbol] field name
+      # @param opts [Hash]
+      def field(name, **opts)
+        with_path('fields', name)
+          .add_params(opts)
+          .fetch('field')
+      end
+
+      # @param opts [Hash]
+      def field_types(**opts)
+        with_path('fieldtypes')
+          .with_enum_on('fieldTypes')
+          .add_params(opts)
+      end
+
+      # @param name [String, Symbol] field type name
+      # @param opts [Hash]
+      def field_type(name, **opts)
+        with_path('fieldtypes', name).add_params(opts).fetch('fieldType')
+      end
+
+      # @param opts [Hash]
+      def dynamic_fields(**opts)
+        with_path('dynamicfields').with_enum_on('dynamicFields').add_params(opts)
+      end
+
+      # @param name [String, Symbol] dynamic field name
+      # @param opts [Hash]
+      def dynamic_field(name, **opts)
+        with_path('dynamicfields', name).add_params(opts).fetch('dynamicField')
+      end
+
+      # @param opts [Hash]
+      def copy_fields(**opts)
+        with_path('copyfields').with_enum_on('copyFields').add_params(opts)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module ROM
+  module Solr
+    class SelectRelation < Relation
+
+      schemaless :select, as: :search
+
+      def filter(*fq)
+        add_param_values(:fq, fq)
+      end
+      alias_method :fq, :filter
+
+      def query(q)
+        add_params(q: q)
+      end
+      alias_method :q, :query
+
+      def fields(*fl)
+        add_params(fl: fl)
+      end
+      alias_method :fl, :fields
+
+      def start(offset)
+        add_params(start: offset.to_i)
+      end
+      alias_method :offset, :start
+
+      def rows(limit)
+        add_params(rows: limit.to_i)
+      end
+      alias_method :limit, :rows
+
+      def sort(crit)
+        add_params(sort: crit)
+      end
+
+      # @override Don't have to enumerate to get count (may not be exact)
+      def count
+        dataset.num_found
+      end
+
+    end
+  end
+end

data/lib/rom/solr/request.rb

@@ -0,0 +1,24 @@
+module ROM
+  module Solr
+    class Request
+
+      def self.call(dataset)
+        uri = URI(dataset.uri)
+        uri.query = URI.encode_www_form(dataset.params)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.scheme.eql?('https')
+
+        request_class = Net::HTTP.const_get(ROM::Inflector.classify(dataset.request_method))
+        request = request_class.new(uri.request_uri)
+
+        dataset.headers.each_with_object(request) do |(header, value), request|
+          request[header.to_s] = value
+        end
+
+        http.request(request)
+      end
+
+    end
+  end
+end

data/lib/rom/solr/response.rb

@@ -0,0 +1,12 @@
+module ROM
+  module Solr
+    class Response
+
+      # @return [Hash] Parsed JSON object from Solr response body
+      def self.call(response, dataset)
+        JSON.parse(response.body)
+      end
+
+    end
+  end
+end

data/lib/rom/solr/schema.rb

@@ -0,0 +1,9 @@
+module ROM
+  module Solr
+    class Schema < ROM::HTTP::Schema
+
+
+
+    end
+  end
+end

data/lib/rom/solr/schemaless.rb

@@ -0,0 +1,24 @@
+require "hashie"
+
+module ROM
+  module Solr
+    module Schemaless
+
+      def self.extended(base)
+        schemaless_output = Class.new(Hashie::Mash) do
+          include Hashie::Extensions::Mash::SymbolizeKeys
+          disable_warnings
+        end
+        base.const_set(:SchemalessOutput, schemaless_output)
+        base.option :output_schema, default: ->{ self.class.const_get(:SchemalessOutput) }
+      end
+
+      def schemaless(*args)
+        schema(*args) do
+          # no schema :)
+        end
+      end
+
+    end
+  end
+end

data/lib/solrbee.rb

@@ -1,32 +1,39 @@
 require "solrbee/version"
-require "solrbee/api_methods"
-require "solrbee/query"
-require "solrbee/cursor"
-require "solrbee/client"
+require "solrbee/array"
+require "rom/solr"
 
 module Solrbee
 
-  class Error < StandardError; end
+  # Factory method
+  #
+  # @return [ROM::Solr::Gateway] a gateway instance
+  def self.gateway
+    ROM::Gateway.setup(:solr)
+  end
 
-  API_VERSION = 'V1'
+  # Factory method
+  #
+  # @return [Solrbee::Documents] a ROM relation for searching
+  def self.documents
+    container.relations[:search]
+  end
 
-  # Single-valued field types
-  STRING  = "string"
-  LONG    = "plong"
-  INT     = "pint"
-  DATE    = "pdate"
-  BOOLEAN = "boolean"
+  def self.schema
+    container.relations[:schema_info]
+  end
 
-  # Multi-valued field types
-  MSTRING  = "strings"
-  MLONG    = "plongs"
-  MINT     = "pints"
-  MDATE    = "pdates"
-  MBOOLEAN = "booleans"
+  # @return [ROM::Configuration] configuration
+  def self.config
+    @config ||= ROM::Configuration.new(:solr) do |config|
+      config.register_relation(
+        ROM::Solr::SelectRelation,
+        ROM::Solr::SchemaRelation
+      )
+    end
+  end
 
-  # Base URL
-  def self.solr_url
-    ENV.fetch('SOLR_URL', 'http://localhost:8983/solr').sub(/\/\z/, '')
+  def self.container
+    ROM.container(config)
   end
 
 end

data/lib/solrbee/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/solrbee/version.rb

@@ -1,3 +1,3 @@
 module Solrbee
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/solrbee.gemspec

@@ -23,6 +23,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "hashie"
+  spec.add_dependency "rom"
+  spec.add_dependency "rom-http"
 
   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.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - David Chandek-Stark
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-14 00:00:00.000000000 Z
+date: 2020-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -24,6 +24,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rom
+  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: rom-http
+  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
@@ -96,11 +124,21 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- config/api.yml
+- lib/rom/solr.rb
+- lib/rom/solr/dataset.rb
+- lib/rom/solr/datasets/select_dataset.rb
+- lib/rom/solr/gateway.rb
+- lib/rom/solr/paginated_dataset.rb
+- lib/rom/solr/relation.rb
+- lib/rom/solr/relations/schema_relation.rb
+- lib/rom/solr/relations/select_relation.rb
+- lib/rom/solr/request.rb
+- lib/rom/solr/response.rb
+- lib/rom/solr/schema.rb
+- lib/rom/solr/schemaless.rb
 - lib/solrbee.rb
-- lib/solrbee/api_methods.rb
-- lib/solrbee/client.rb
-- lib/solrbee/cursor.rb
-- lib/solrbee/query.rb
+- lib/solrbee/array.rb
 - lib/solrbee/version.rb
 - solrbee.gemspec
 homepage: https://github.com/dchandekstark/solrbee

data/lib/solrbee/api_methods.rb

@@ -1,94 +0,0 @@
-module Solrbee
-  module ApiMethods
-
-    def ping
-      response = request(path: '/admin/ping')
-      response['status']
-    end
-
-    def schema
-      response = request(path: '/schema')
-      response['schema']
-    end
-
-    def schema_name
-      response = request(path: '/schema/name')
-      response['name']
-    end
-
-    def schema_version
-      response = request(path: '/schema/version')
-      response['version']
-    end
-
-    def fields(**params)
-      response = request(path: '/schema/fields', params: params)
-      response['fields']
-    end
-
-    def field(field_name, **params)
-      response = request(path: '/schema/fields/%s' % field_name, params: params)
-      response['field']
-    end
-
-    def unique_key
-      response = request(path: '/schema/uniquekey')
-      response['uniqueKey']
-    end
-
-    def field_types(**params)
-      response = request(path: '/schema/fieldtypes', params: params)
-      response['fieldTypes']
-    end
-
-    def field_type(field_name, **params)
-      response = request(path: '/schema/fieldtypes/%s' % field_name, params: params)
-      response['fieldType']
-    end
-
-    def field_names
-      fields.map { |f| f['name'] }
-    end
-
-    def field_type_names
-      field_types.map { |f| f['name'] }
-    end
-
-    def modify_schema(commands)
-      request(path: '/schema', data: commands)
-    end
-
-    def add_field(field)
-      modify_schema("add-field"=>field)
-    end
-
-    def delete_field(field_name)
-      modify_schema("delete-field"=>{"name"=>field_name})
-    end
-
-    def replace_field(field)
-      modify_schema("replace-field"=>field)
-    end
-
-    # "real-time get"
-    def get_by_id(*ids, **params)
-      response = request(path: '/get', params: params.merge(id: ids.join(',')))
-      response['response']['doc'] || response['response']['docs']
-    end
-
-    def index(*docs, **params)
-      request(path: '/update/json/docs', data: docs, params: params)
-    end
-    alias_method :add, :index
-    alias_method :update, :index
-
-    def delete(*ids)
-      request(path: '/update', data: { delete: ids })
-    end
-
-    def query(**params)
-      request(path: '/query', data: params)
-    end
-
-  end
-end

data/lib/solrbee/client.rb

@@ -1,50 +0,0 @@
-require "net/http"
-require "uri"
-require "json"
-
-module Solrbee
-  class Client
-    include ApiMethods
-
-    attr_reader :uri
-
-    def self.cursor(url: nil)
-      new(url: url).cursor
-    end
-
-    def initialize(url: nil)
-      @uri = URI(url || ENV['SOLR_URL'])
-    end
-
-    def connection
-      Net::HTTP.new(uri.host, uri.port).tap do |http|
-        http.use_ssl = true if uri.scheme == 'https'
-      end
-    end
-
-    def cursor
-      Cursor.new(self)
-    end
-
-    def request(path:, data: nil, params: {})
-      req_class = data ? Net::HTTP::Post : Net::HTTP::Get
-
-      req_uri = uri.dup.tap do |u|
-        u.path += path
-        u.query = URI.encode_www_form(params) unless params.empty?
-      end
-
-      req = req_class.new(req_uri)
-      req['Accept'] = 'application/json'
-
-      if data
-        req['Content-Type'] = 'application/json'
-        req.body = JSON.dump(data)
-      end
-
-      http_response = connection.request(req)
-      JSON.parse(http_response.body)
-    end
-
-  end
-end

data/lib/solrbee/cursor.rb

@@ -1,37 +0,0 @@
-module Solrbee
-  #
-  # SUMMARY
-  #
-  # > client = Solrbee::Client.new
-  # > cursor = Solrbee::Cursor.new(client)
-  # > query = { query: 'foo:bar', sort: 'title ASC', limit: 10 }
-  # > results = cursor.execute(query)
-  # > results.each do |doc|
-  #   ...
-  # > end
-  #
-  class Cursor
-
-    attr_reader :client
-
-    def initialize(client)
-      @client = client
-    end
-
-    # @return [Enumerator] an enumerator of query results
-    def execute(query)
-      Enumerator.new do |yielder|
-        q = Query.cursor(query, client.unique_key)
-
-        while true
-          response = client.query(q)
-          break if response['response']['numFound'] == 0
-          break if response['nextCursorMark'] == q.params.cursorMark
-          response['response']['docs'].each { |doc| yielder << doc }
-          q.params.cursorMark = response['nextCursorMark']
-        end
-      end
-    end
-
-  end
-end

data/lib/solrbee/query.rb

@@ -1,35 +0,0 @@
-require 'hashie'
-
-module Solrbee
-  #
-  # A query targeting the JSON Request API.
-  #
-  class Query < Hashie::Trash
-    property :query,  from: :q,    default: '*:*'
-    property :filter, from: :fq
-    property :limit,  from: :rows, default: 10
-    property :fields, from: :fl
-    property :sort
-    property :offset, from: :start
-    property :facet
-    property :queries
-    property :params,              default: {}
-
-    # Build a query for a Cursor
-    def self.cursor(params, unique_key)
-      Query.new(params).tap do |q|
-        q.delete(:offset)           # incompatible with cursor
-        q.params[:cursorMark] = '*' # initial cursor mark
-
-        # Sort on unique key is required for cursor
-        q.sort = "#{unique_key} ASC" unless q.sort
-        unless q.sort =~ /\b#{unique_key}\b/
-          clauses = q.sort.split(/,/)
-          clauses << "#{unique_key} ASC"
-          q.sort = clauses.join(',')
-        end
-      end
-    end
-
-  end
-end