solrbee 0.3.0 → 0.4.0

data/lib/rom/solr/relation.rb

@@ -1,23 +1,37 @@
 module ROM
   module Solr
     class Relation < ROM::HTTP::Relation
-      extend Schemaless
 
-      adapter :solr
+      adapter     :solr
+      auto_struct false
+      auto_map    false
 
-      forward :add_param_values, :default_params, :with_enum_on
+      forward :with_response_key
 
-      def fetch(key, default = nil)
-        return self if key.nil?
-        dataset.response.fetch(key, default)
+      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 all
-        self
+      def response
+        dataset.response
+      end
+
+      def params
+        dataset.params.dup
       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.rb → response_handler.rb}

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

data/lib/rom/solr/schema.rb

@@ -1,8 +1,6 @@
 module ROM
   module Solr
-    class Schema < ROM::HTTP::Schema
-
-
+    class Schema < ROM::Schema
 
     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