solrbee 0.1.2 → 0.5.0

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

@@ -0,0 +1,39 @@
+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
+
+      # Need this?
+      option :output_schema, default: ->{ NOOP_OUTPUT_SCHEMA }
+
+      def wt(writer)
+        add_params(wt: Types::Coercible::String.enum(*RESPONSE_WRITERS)[writer])
+      end
+
+      def log_params_list(*log_params)
+        new_log_params = Types::Array.of(Types::String)[log_params]
+
+        add_params(logParamsList: new_log_params.join(','))
+      end
+
+      def omit_header(omit = true)
+        add_params(omitHeader: Types::Bool[omit])
+      end
+
+      def count
+        to_enum.count
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,215 @@
+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?
+
+        DocumentsPaginator.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
+
+      # 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 cursor?
+        params.key?(:cursorMark)
+      end
+
+      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
+
+        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(data)
+        )
+      end
+
+      def delete(docs)
+        # 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',
+          content_type: 'application/json',
+          request_data: JSON.dump(delete: ids)
+        )
+      end
+
+      def delete_by_query(query)
+        with_options(
+          base_path: 'update',
+          content_type: 'application/json',
+          request_data: JSON.dump(delete: {query: query})
+        )
+      end
+
+      #
+      # Common Query Parameters
+      #
+
+      def q(*queries)
+        old_queries = Array.wrap(params[:q])
+        new_queries = Array.wrap(queries).flatten
+
+        add_params q: (old_queries + new_queries).join(' ')
+      end
+
+      def fq(*queries)
+        old_queries = Array.wrap(params[:fq])
+        new_queries = Array.wrap(queries).flatten
+
+        add_params fq: old_queries + new_queries
+      end
+
+      def fl(*fields)
+        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]
+      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 start(offset)
+        add_params start: Types::Coercible::Integer[offset]
+      end
+
+      def sort(*criteria)
+        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]
+      end
+
+      alias_method :limit, :rows
+
+      def def_type(value)
+        add_params defType: Types::Coercible::String[value]
+      end
+
+      def debug(setting)
+        add_params debug: Types::Coercible::String.enum('query', 'timing', 'results', 'all', 'true')[setting]
+      end
+
+      def echo_params(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]
+      end
+
+      #
+      # Commit parameters
+      #
+      def commit(value = true)
+        add_params commit: Types::Bool[value]
+      end
+
+      def commit_within(millis)
+        add_params commitWithin: Types::Coercible::Integer.optional[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,78 @@
+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
+        self
+      end
+
+      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(defaults: true)
+        with_path(:dynamicfields)
+          .show_defaults(defaults)
+      end
+
+      def dynamic_field(name, defaults: true)
+        with_path("dynamicfields/#{name}")
+          .show_defaults(defaults)
+      end
+
+      def similarity
+        with_path :similarity
+      end
+
+      def unique_key
+        with_path :uniquekey
+      end
+
+      def version
+        with_path :version
+      end
+
+      def schema_name
+        with_path :name
+      end
+
+      def fields(dynamic: true, defaults: true)
+        with_path(:fields)
+          .include_dynamic(dynamic)
+          .show_defaults(defaults)
+      end
+
+      def field(name, defaults: true)
+        with_path("fields/#{name}")
+          .show_defaults(defaults)
+      end
+
+      def field_types(defaults: true)
+        with_path(:fieldtypes)
+          .show_defaults(defaults)
+      end
+
+      def field_type(name, defaults: true)
+        with_path("fieldtypes/#{name}")
+          .show_defaults(defaults)
+      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.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.params?
+            u.query ||= URI.encode_www_form(dataset.params)
+          end
+        end
+      end
+
+      def request_class
+        if dataset.request_data?
+          Net::HTTP::Post
+        else
+          Net::HTTP::Get
+        end
+      end
+
+    end
+  end
+end