solrbee 0.1.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 77127390eb03bfbd53eec6916f7873fab49b6436f4acb94c528f2cec7ed5f76b
-  data.tar.gz: '08ab2300881e0fdacaafa0007d1a17031a2b11bebfe2ade9cbf533a02a7b2b42'
+  metadata.gz: 11deb067a219ff325c0aa6dfaeb14422674cfd2a30338d14a1f00fa3f2081550
+  data.tar.gz: b6566f900e8a437feb379dba1e7f8de64e9c5a4b821cc501256ce0ee58da52e1
 SHA512:
-  metadata.gz: 5642a45f1013a4ddf33f4a339f0990ec218d7c3ebce3e6b3e1a0811c81256a6c155df333d7894618de9cb4a8b9e7c9eac5f178237474e96cd2de5ec7193cee83
-  data.tar.gz: bba5257728a581433cf72dbd4dce18ab5f8f7baea95afca7dca75c16f5fc17b509110c9e8ecb9a87713960f3eccf951d0bf11a0afe8b4ba01de2f331fcefd095
+  metadata.gz: aa65e21c6552dc4d4276ecfdc1a4089e69d3625af84d014cb6353183a9e145ed8adf34158b180e2c70d1718d211e35b32fbd545438bd13753d171484b1577010
+  data.tar.gz: 78fd833f50640f5f875be47160a87642f2b612c90906e3d349e68042f5d267b4b375727babcc8c2512c90006e7e858535e2382ecfc638d7dff333822f20e04c4

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,13 +2,4 @@ SHELL = /bin/bash
 
 .PHONY : test
 test:
-	bundle exec rake
-
-
-.PHONY : start-test-server
-start-test-server:
-	docker run --rm -d -p 8983:8983 --name solrbee-test solr:8 solr-precreate solrbee
-
-.PHONY : stop-test-server
-stop-test-server:
-	docker stop solrbee-test
+	./test.sh

data/README.md

@@ -25,7 +25,7 @@ Or install it yourself as:
 
 ## Usage
 
-
+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,51 @@
+require 'rom-http'
+require 'securerandom'
+
+module ROM
+  module Solr
+
+    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_relative 'solr/array'
+
+# Handlers
+require_relative 'solr/request_handler'
+require_relative 'solr/response_handler'
+
+# Datasets
+require_relative 'solr/dataset'
+require_relative 'solr/documents_dataset'
+require_relative 'solr/schema_info_dataset'
+
+# Gateway
+require_relative 'solr/gateway'
+
+# Schemas
+require_relative 'solr/schema'
+
+# Relations
+require_relative 'solr/relation'
+
+# Repositories
+require_relative 'solr/repository'
+require_relative 'solr/schema_info_repo'
+require_relative 'solr/document_repo'
+
+# Commands
+require_relative '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)
+        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)
+        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)
+        end
+
+      end
+    end
+  end
+end

data/lib/rom/solr/dataset.rb

@@ -0,0 +1,72 @@
+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
+
+      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 }
+
+      # @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?
+        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__
+
+      # @override Cache response by default
+      def response
+        cache.fetch_or_store(:response) { __response__ }
+      end
+
+      def has_request_data?
+        !request_data.nil? && !request_data.empty?
+      end
+
+      def has_params?
+        params.any?
+      end
+
+      private
+
+      def enumerable_data
+        Array.wrap(response_key ? response.dig(*response_key) : response)
+      end
+
+      def cache
+        @cache ||= Concurrent::Map.new
+      end
+
+    end
+  end
+end

data/lib/rom/solr/document_repo.rb

@@ -0,0 +1,33 @@
+module ROM
+  module Solr
+    class DocumentRepo < Repository[:documents]
+
+      auto_struct false
+
+      def find(id)
+        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)
+      end
+
+      def delete(docs)
+        documents.command(:delete_documents).call(docs)
+      end
+
+      def update(docs)
+        documents.command(:update_documents).call(docs)
+      end
+
+    end
+  end
+end

data/lib/rom/solr/documents_dataset.rb

@@ -0,0 +1,12 @@
+module ROM
+  module Solr
+    class DocumentsDataset < Dataset
+
+      configure do |config|
+        config.default_response_key = [:response, :docs]
+        config.default_base_path    = 'select'
+      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/relation.rb

@@ -0,0 +1,39 @@
+module ROM
+  module Solr
+    class Relation < ROM::HTTP::Relation
+
+      adapter     :solr
+      auto_struct false
+      auto_map    false
+
+      forward :with_response_key
+
+      option :output_schema, default: ->{ NOOP_OUTPUT_SCHEMA }
+
+      def wt(format)
+        add_params(wt: Types::Coercible::String[format])
+      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 count
+        to_enum.count
+      end
+
+      def response
+        dataset.response
+      end
+
+      def params
+        dataset.params.dup
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,160 @@
+require 'rom/solr/select_cursor'
+
+module ROM
+  module Solr
+    class DocumentsRelation < Relation
+
+      schema(:documents) { }
+
+      # @override
+      def each(&block)
+        return to_enum unless block_given?
+
+        SelectCursor.new(dataset).each(&block)
+      end
+
+      # @override FIXME: Get from Solr schema unique key
+      def primary_key
+        :id
+      end
+
+      def by_unique_key(id)
+        q('%s:%s' % [ primary_key, id ])
+      end
+
+      def all
+        q('*:*')
+      end
+
+      # @override
+      def count
+        num_found_exact ? num_found : super
+      end
+
+      def num_found
+        response.dig(:response, :numFound)
+      end
+
+      def num_found_exact
+        response.dig(:response, :numFoundExact)
+      end
+
+      def insert(docs)
+        data = Array.wrap(docs).map do |doc|
+          doc.transform_keys!(&:to_sym)
+          doc[:id] ||= UUID[]
+        end
+
+        update(data)
+      end
+
+      def update(docs)
+        with_options(
+          base_path: 'update/json/docs',
+          content_type: 'application/json',
+          request_data: JSON.dump(docs)
+        )
+      end
+
+      def delete(docs)
+        ids = Array.wrap(docs).map { |doc| doc.transform_keys(&:to_sym) }.map(&:id)
+
+        with_options(
+          base_path: 'update',
+          content_type: 'application/json',
+          request_data: JSON.dump(delete: ids)
+        )
+      end
+
+      #
+      # Params
+      #
+      def q(query)
+        add_params(q: Types::String[query])
+      end
+      alias_method :query, :q
+
+      def fq(*filter)
+        add_params(fq: filter)
+      end
+      alias_method :filter, :fq
+
+      def fl(*fields)
+        add_params(fl: fields.join(','))
+      end
+      alias_method :fields, :fl
+
+      def cache(enabled = true)
+        add_params(cache: Types::Bool[enabled])
+      end
+
+      def segment_terminate_early(enabled = true)
+        add_params(segmentTerminateEarly: Types::Bool[enabled])
+      end
+
+      def time_allowed(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])
+      end
+
+      def start(offset)
+        add_params(start: Types::Coercible::Integer[offset])
+      end
+
+      def sort(*criteria)
+        add_params(sort: criteria.join(','))
+      end
+
+      def rows(num)
+        add_params(rows: Types::Coercible::Integer[num])
+      end
+      alias_method :limit, :rows
+
+      def def_type(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])
+      end
+
+      def echo_params(setting)
+        type = Types::Coercible::String.enum('explicit', 'all', 'none')
+        add_params(echoParams: type[setting])
+      end
+
+      def min_exact_count(num)
+        add_params(minExactCount: Types::Coercible::Integer[num])
+      end
+
+      def commit(value = true)
+        add_params(commit: Types::Bool[value])
+      end
+
+      def commit_within(millis)
+        return self if millis.nil?
+
+        add_params(commitWithin: Types::Coercible::Integer[millis])
+      end
+
+      def overwrite(value = true)
+        add_params(overwrite: Types::Bool[value])
+      end
+
+      def expunge_deletes(value = true)
+        add_params(expungeDeletes: Types::Bool[value])
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+module ROM
+  module Solr
+    class SchemaInfoRelation < Relation
+
+      schema(:schema_info) do
+        # no-op
+      end
+
+      def show_defaults(show = true)
+        add_params(showDefaults: Types::Bool[show])
+      end
+
+      def include_dynamic(enabled = true)
+        add_params(includeDynamic: Types::Bool[enabled])
+      end
+
+      def info
+        with_response_key(:schema)
+      end
+
+      def copy_fields
+        with_options(
+          path: :copyfields,
+          response_key: :copyFields
+        )
+      end
+
+      def dynamic_fields
+        with_options(
+          path: :dynamicfields,
+          response_key: :dynamicFields
+        )
+      end
+
+      def dynamic_field(name)
+        with_options(
+          path: "dynamicfields/#{name}",
+          response_key: :dynamicField
+        )
+      end
+
+      def similarity
+        with_options(
+          path: :similarity,
+          response_key: :similarity
+        )
+      end
+
+      def unique_key
+        with_options(
+          path: :uniquekey,
+          response_key: :uniqueKey
+        )
+      end
+
+      def version
+        with_options(
+          path: :version,
+          response_key: :version
+        )
+      end
+
+      def schema_name
+        with_options(
+          path: :name,
+          response_key: :name
+        )
+      end
+
+      def fields
+        with_options(
+          path: :fields,
+          response_key: :fields
+        )
+      end
+
+      def field(name)
+        with_options(
+          path: "fields/#{name}",
+          response_key: :field
+        )
+      end
+
+      def field_types
+        with_options(
+          path: :fieldtypes,
+          response_key: :fieldTypes
+        )
+      end
+
+      def field_type(name)
+        with_options(
+          path: "fieldtypes/#{name}",
+          response_key: :fieldType
+        )
+      end
+
+    end
+  end
+end

data/lib/rom/solr/repository.rb

@@ -0,0 +1,9 @@
+module ROM
+  module Solr
+    class Repository < ROM::Repository
+
+      auto_struct false
+
+    end
+  end
+end

data/lib/rom/solr/request_handler.rb

@@ -0,0 +1,52 @@
+module ROM
+  module Solr
+    class RequestHandler
+
+      def self.call(dataset)
+        new(dataset).execute
+      end
+
+      attr_reader :dataset
+
+      def initialize(dataset)
+        @dataset = dataset
+      end
+
+      def execute
+        Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme.eql?('https')) do |http|
+          http.request(request)
+        end
+      end
+
+      def request
+        request_class.new(uri.request_uri, headers).tap do |req|
+          if dataset.has_request_data?
+            req.body = dataset.request_data
+            req.content_type = dataset.content_type
+          end
+        end
+      end
+
+      def headers
+        dataset.headers.transform_keys(&:to_s)
+      end
+
+      def uri
+        @uri ||= URI(dataset.uri).tap do |u|
+          if dataset.has_params?
+            u.query ||= URI.encode_www_form(dataset.params)
+          end
+        end
+      end
+
+      def request_class
+        if dataset.has_request_data?
+          Net::HTTP::Post
+        else
+          Net::HTTP::Get
+        end
+      end
+
+    end
+  end
+end

data/lib/rom/solr/response_handler.rb

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

data/lib/rom/solr/schema.rb

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

data/lib/rom/solr/schema_info_dataset.rb

@@ -0,0 +1,11 @@
+module ROM
+  module Solr
+    class SchemaInfoDataset < Dataset
+
+      configure do |config|
+        config.default_base_path = 'schema'
+      end
+
+    end
+  end
+end

data/lib/rom/solr/schema_info_repo.rb

@@ -0,0 +1,45 @@
+module ROM
+  module Solr
+    class SchemaInfoRepo < Repository[:schema_info]
+
+      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
+      end
+
+    end
+  end
+end

data/lib/rom/solr/select_cursor.rb

@@ -0,0 +1,56 @@
+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

data/lib/solrbee.rb

@@ -1,31 +1,28 @@
 require "solrbee/version"
-require "solrbee/response"
-require "solrbee/request_params"
-require "solrbee/query"
-require "solrbee/client"
-require "solrbee/cursor"
+
+require "rom/solr"
 
 module Solrbee
 
-  class Error < StandardError; end
-
-  # Single-valued field types
-  STRING  = "string"
-  LONG    = "plong"
-  INT     = "pint"
-  DATE    = "pdate"
-  BOOLEAN = "boolean"
-
-  # Multi-valued field types
-  MSTRING  = "strings"
-  MLONG    = "plongs"
-  MINT     = "pints"
-  MDATE    = "pdates"
-  MBOOLEAN = "booleans"
-
-  # Base URL
-  def self.solr_url
-    ENV.fetch('SOLR_URL', 'http://localhost:8983/solr').sub(/\/\z/, '')
+  DEFAULT_URI = ENV.fetch('SOLR_URL', 'http://localhost:8983/solr').freeze
+
+  def self.documents
+    ROM::Solr::DocumentRepo.new(container)
+  end
+
+  def self.schema_info
+    ROM::Solr::SchemaInfoRepo.new(container)
+  end
+
+  def self.container(uri: DEFAULT_URI)
+    ROM.container(:solr, uri: uri) do |config|
+      config.auto_registration(
+        File.expand_path('../rom/solr/', __FILE__),
+        namespace: 'ROM::Solr'
+      )
+
+      yield config if block_given?
+    end
   end
 
 end

data/lib/solrbee/version.rb

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

data/solrbee.gemspec

@@ -22,7 +22,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   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"

data/test.sh

@@ -0,0 +1,14 @@
+#!/bin/bash
+
+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
+
+SOLR_URL=http://localhost:8983/solr/solrbee bundle exec rake
+code=$?
+
+docker stop solrbee-test
+
+exit $code

metadata

@@ -1,17 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: solrbee
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.4.0
 platform: ruby
 authors:
 - David Chandek-Stark
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-04 00:00:00.000000000 Z
+date: 2020-12-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: hashie
+  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:
     - - ">="
@@ -96,15 +110,32 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- config/api.yml
+- lib/rom/solr.rb
+- lib/rom/solr/array.rb
+- lib/rom/solr/commands.rb
+- lib/rom/solr/commands/create_documents.rb
+- lib/rom/solr/commands/delete_documents.rb
+- lib/rom/solr/commands/delete_documents_by_query.rb
+- lib/rom/solr/commands/update_documents.rb
+- lib/rom/solr/dataset.rb
+- lib/rom/solr/document_repo.rb
+- lib/rom/solr/documents_dataset.rb
+- lib/rom/solr/gateway.rb
+- lib/rom/solr/relation.rb
+- lib/rom/solr/relations/documents_relation.rb
+- lib/rom/solr/relations/schema_info_relation.rb
+- lib/rom/solr/repository.rb
+- lib/rom/solr/request_handler.rb
+- lib/rom/solr/response_handler.rb
+- 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/solrbee.rb
-- lib/solrbee/api_methods.rb
-- lib/solrbee/client.rb
-- lib/solrbee/cursor.rb
-- lib/solrbee/query.rb
-- lib/solrbee/request_params.rb
-- lib/solrbee/response.rb
 - lib/solrbee/version.rb
 - solrbee.gemspec
+- test.sh
 homepage: https://github.com/dchandekstark/solrbee
 licenses:
 - MIT

data/lib/solrbee/api_methods.rb

@@ -1,85 +0,0 @@
-module Solrbee
-  module ApiMethods
-
-    def schema_name
-      response = get('/schema/name')
-      response.name
-    end
-
-    def schema_version
-      response = get('/schema/version')
-      response.version
-    end
-
-    def schema
-      response = get('/schema')
-      response.schema
-    end
-
-    def fields(**params)
-      response = get('/schema/fields', **params)
-      response.fields
-    end
-
-    def field(field_name, **params)
-      response = get('/schema/fields/%s' % field_name, **params)
-      response.field
-    end
-
-    def unique_key
-      @unique_key ||= get('/schema/uniquekey').uniqueKey
-    end
-
-    def field_types(**params)
-      response = get('/schema/fieldtypes', **params)
-      response.fieldTypes
-    end
-
-    def field_type(field_name, **params)
-      response = get('/schema/fieldtypes/%s' % field_name, **params)
-      response.fieldType
-    end
-
-    def field_names
-      fields.map(&:name)
-    end
-
-    def field_type_names
-      field_types.map(&:name)
-    end
-
-    def add_field(field)
-      post('/schema', {"add-field"=>field})
-    end
-
-    def delete_field(field)
-      post('/schema', {"delete-field"=>{"name"=>field.name}})
-    end
-
-    def replace_field(field)
-      post('/schema', {"replace-field"=>field})
-    end
-
-    # "real-time get"
-    # Note: Using POST here for simpler params.
-    def get_by_id(*ids)
-      response = post('/get', params: { id: ids })
-      response.doc || response.docs
-    end
-
-    def index(*docs, **params)
-      post('/update/json/docs', docs, **params)
-    end
-    alias_method :add, :index
-    alias_method :update, :index
-
-    def delete(*ids)
-      post('/update', delete: ids)
-    end
-
-    def query(params)
-      post('/query', Query.new(params))
-    end
-
-  end
-end

data/lib/solrbee/client.rb

@@ -1,59 +0,0 @@
-require "net/http"
-require "uri"
-require "json"
-
-require "solrbee/api_methods"
-
-module Solrbee
-  class Client
-    include ApiMethods
-
-    attr_reader :collection, :uri
-
-    def initialize(collection)
-      @collection = collection
-      @uri = URI(Solrbee.solr_url).tap do |u|
-        u.path += '/%s' % URI.encode_www_form_component(collection)
-      end
-    end
-
-    def connection
-      Net::HTTP.new(uri.host, uri.port).tap do |http|
-        http.use_ssl = true if uri.scheme == 'https'
-      end
-    end
-
-    # :get -> Net::HTTP::Get
-    def request_class(method)
-      Net::HTTP.const_get(method.to_s.downcase.capitalize)
-    end
-
-    def request(method, path, **params)
-      req_uri = uri.dup
-      req_uri.path += path
-      unless params.empty?
-        req_uri.query = URI.encode_www_form RequestParams.new(params)
-      end
-      req = request_class(method).new(req_uri, {'Accept'=>'application/json'})
-      yield req if block_given?
-      res = connection.request(req)
-      Response.new JSON.parse(res.body)
-    end
-
-    def get(path, **params)
-      request(:get, path, **params)
-    end
-
-    def post(path, data, **params)
-      request(:post, path, **params) do |req|
-        req['Content-Type'] = 'application/json'
-        req.body = JSON.dump(data)
-      end
-    end
-
-    def cursor
-      Cursor.new(self)
-    end
-
-  end
-end

data/lib/solrbee/cursor.rb

@@ -1,37 +0,0 @@
-module Solrbee
-  #
-  # Summary
-  #
-  # > client = Solrbee::Client.new('mycollection'))
-  # > 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.num_found == 0
-          break if response.nextCursorMark == q.params.cursorMark
-          response.docs.each { |doc| yielder << doc }
-          q.params.cursorMark = response.nextCursorMark
-        end
-      end
-    end
-
-  end
-end

data/lib/solrbee/query.rb

@@ -1,36 +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

data/lib/solrbee/request_params.rb

@@ -1,13 +0,0 @@
-require 'hashie'
-
-module Solrbee
-  #
-  # For marshalling various API request query parameters
-  #
-  class RequestParams < Hashie::Trash
-    property :showDefaults,   from: :show_defaults
-    property :includeDynamic, from: :include_dynamic
-    property :fl
-    property :commit
-  end
-end

data/lib/solrbee/response.rb

@@ -1,25 +0,0 @@
-require 'hashie'
-
-module Solrbee
-  class Response < Hashie::Mash
-
-    disable_warnings
-
-    def header
-      responseHeader
-    end
-
-    def num_found
-      response.numFound
-    end
-
-    def docs
-      response.docs
-    end
-
-    def doc
-      response.doc
-    end
-
-  end
-end