simple_solr_client 0.1.0

data/lib/simple_solr/schema/analysis.rb

@@ -0,0 +1,58 @@
+
+# Figure out how the field type will parse out tokens
+# and change them in the analysis chain. Just calls the
+# provided solr analysis endpoints
+#
+# To be mixed into FieldType
+
+class SimpleSolrClient::Schema
+  module Analysis
+
+    #https://lucene.apache.org/solr/4_1_0/solr-core/org/apache/solr/handler/FieldAnalysisRequestHandler.html
+    def fieldtype_tokens(val, type)
+      target = 'analysis/field'
+      h      = {'analysis.fieldtype'  => name,
+                'analysis.fieldvalue' => val,
+                'analysis.query'      => val,
+      }
+      resp   = @core.get(target, h)
+      ftdata = resp['analysis']['field_types'][name][type]
+      rv     = []
+      ftdata.last.each do |t|
+        pos  = t['position'] - 1
+        text = t['text']
+        if rv[pos]
+          rv[pos] = Array[rv[pos]] << text
+        else
+          rv[pos] = text
+        end
+      end
+      rv
+    end
+
+    private :fieldtype_tokens
+
+    # Get an array of tokens as analyzed/transformed at index time
+    # Note that you may have multiple values at each token position if
+    # you use a synonym filter or a stemmer
+    # @param [String] ft the name of the fieldType (*not* the field)
+    # @param [String] val the search string to parse
+    # @return [Array] An array of tokens as produced by that index analysis chain
+    #
+    # @example Results when there's a stemmer
+    #   c.fieldtype_index_tokens 'text', "That's Life"
+    #     => [["that's", "that"], "life"]
+    #
+    def index_tokens(val)
+      fieldtype_tokens(val, 'index')
+    end
+
+    # Get an array of tokens as analyzed/transformed at query time
+    # See #fieldtype_index_tokens
+    def query_tokens(val)
+      fieldtype_tokens(val, 'query')
+    end
+
+
+  end
+end

data/lib/simple_solr/schema/copyfield.rb

@@ -0,0 +1,42 @@
+require 'simple_solr/schema/matcher'
+
+class SimpleSolrClient::Schema::CopyField
+  include SimpleSolrClient::Schema::Matcher
+
+  attr_accessor :source, :dest
+
+  def initialize(source, dest)
+    self.source   = source
+    @dest         = dest
+    @matcher      = derive_matcher(source)
+    @dest_matcher = derive_matcher(dest)
+  end
+
+# What name will we get from a matching thing?
+  def dynamic_name(s)
+    return @dest unless @dest =~ /\*/
+
+    m = @matcher.match(s)
+    if m
+      prefix = m[1]
+      return @dest.sub(/\*/, prefix)
+    end
+    nil
+
+  end
+
+  def source=(s)
+    @matcher = derive_matcher(s)
+    @source  = s
+  end
+
+  def to_xml_node(doc = nil)
+    doc          ||= Nokogiri::XML::Document.new
+    cf           = Nokogiri::XML::Element.new('copyField', doc)
+    cf['source'] = source
+    cf['dest']   = dest
+    cf
+  end
+
+
+end

data/lib/simple_solr/schema/dynamic_field.rb

@@ -0,0 +1,23 @@
+require 'simple_solr/schema/field'
+class SimpleSolrClient::Schema
+  class DynamicField < Field
+
+    def initialize(*args)
+      super
+      @dynamic = true
+    end
+
+    def xml_node(doc)
+      Nokogiri::XML::Element.new('dynamicField', doc)
+    end
+
+    # What name will we get from a matching thing?
+    def dynamic_name(s)
+      m = @matcher.match(s)
+      if m
+        m[1] << m[2]
+      end
+    end
+
+  end
+end

data/lib/simple_solr/schema/field.rb

@@ -0,0 +1,35 @@
+require 'simple_solr/schema/field_or_type'
+class SimpleSolrClient::Schema
+  class Field < Field_or_Type
+    include Matcher
+
+    attr_accessor :type_name, :type
+    attr_reader :matcher
+
+
+    def initialize(*args)
+      super
+      @dynamic = false
+    end
+
+    def xml_node(doc)
+      Nokogiri::XML::Element.new('field', doc)
+    end
+
+    # We can only resolve the actual type in the presence of a
+    # particular schema
+    def resolve_type(schema)
+      self.type = schema.field_type(self.type_name)
+      self
+    end
+
+
+    # When we reset the name, make sure to re-derive the matcher
+    # object
+    def name=(n)
+      @name    = n
+      @matcher = derive_matcher(n)
+    end
+
+  end
+end

data/lib/simple_solr/schema/field_or_type.rb

@@ -0,0 +1,112 @@
+# Base class for Field/DynamicField/FieldType
+module SimpleSolrClient
+  class Schema
+    class Field_or_Type
+      attr_accessor :name,
+                    :type_name
+      attr_writer :indexed,
+                  :stored,
+                  :multi,
+                  :sort_missing_last,
+                  :precision_step,
+                  :position_increment_gap
+
+      # Take in a hash, and set anything in it that we recognize.
+      # Sloppy from a data point of view, but make fore easy
+      # duplication and creation from xml/json
+
+      def initialize(h={})
+        h.each_pair do |k, v|
+          begin
+            self[k] = v
+          rescue
+          end
+
+        end
+      end
+
+
+      TEXT_ATTR_MAP = {
+          :name                   => 'name',
+          :type_name              => 'type',
+          :precision_step         => 'precisionStep',
+          :position_increment_gap => 'positionIncrementGap'
+      }
+
+      BOOL_ATTR_MAP = {
+          :stored            => 'stored',
+          :indexed           => 'indexed',
+          :multi             => 'multiValued',
+          :sort_missing_last => 'sortMissingLast'
+      }
+
+      # Do this little bit of screwing around to forward unknown attributes to
+      # the assigned type, if it exists. Will just use regular old methods
+      # once I get the mappings nailed down.
+      [TEXT_ATTR_MAP.keys, BOOL_ATTR_MAP.keys].flatten.delete_if { |x| [:type_name].include? x }.each do |x|
+        define_method(x) do
+          local = instance_variable_get("@#{x}".to_sym)
+          if local.nil?
+            self.type[x] if self.type
+          else
+            local
+          end
+        end
+      end
+
+      def ==(other)
+        if other.respond_to? :name
+          name == other.name
+        else
+          name == other
+        end
+      end
+
+
+      def self.new_from_solr_hash(h)
+        f = self.new
+
+        TEXT_ATTR_MAP.merge(BOOL_ATTR_MAP).each_pair do |field, xmlattr|
+          f[field] = h[xmlattr]
+        end
+        # Set the name "manually" to force the
+        # matcher
+        f.name = h['name']
+
+        f
+      end
+
+
+      # Reverse the process to get XML
+      def to_xml_node(doc = nil)
+        doc ||= Nokogiri::XML::Document.new
+        xml = xml_node(doc)
+        TEXT_ATTR_MAP.merge(BOOL_ATTR_MAP).each_pair do |field, xmlattr|
+          iv = instance_variable_get("@#{field}".to_sym)
+          xml[xmlattr] = iv unless iv.nil?
+        end
+        xml
+      end
+
+      # Allow access to methods via [], for easy looping
+      def [](k)
+        self.send(k.to_sym)
+      end
+
+      def []=(k, v)
+        self.send("#{k}=".to_sym, v)
+      end
+
+
+      # Make a hash out of it, for easy feeding back into another call to #new
+      def to_h
+        h = {}
+        instance_variables.each do |iv|
+          h[iv.to_s.sub('@', '')] = instance_variable_get(iv)
+        end
+        h
+      end
+
+    end
+  end
+end

data/lib/simple_solr/schema/field_type.rb

@@ -0,0 +1,62 @@
+require 'simple_solr/schema/analysis'
+
+# A basic field type
+#
+# We don't even try to represent the analysis chain; just store the raw
+# xml
+#
+# We also, in blatent disregard for separation of concerns and encapsulation,
+# put in a place to store a core. This is filled when the fieldtype is added
+# to the schema via add_field_type, so we can have access to the
+# analysis chain.
+
+class SimpleSolrClient::Schema
+  class FieldType < Field_or_Type
+    include SimpleSolrClient::Schema::Analysis
+
+    attr_accessor :xml, :solr_class, :core
+
+    def initialize(*args)
+      super
+      @xml = nil
+    end
+
+    # Make sure the type is never set, so we don't get stuck
+    # trying to find a type's "type"
+    def type
+      nil
+    end
+
+    # Create a Nokogiri node out of the currently-set
+    # element attributes (indexed, stored, etc.) and the
+    # XML
+    def xml_node(doc)
+      ft          = Nokogiri::XML::Element.new('fieldType', doc)
+      ft['class'] = self.solr_class
+      xmldoc      = Nokogiri.XML(xml)
+      unless xmldoc.children.empty?
+        xmldoc.children.first.children.each do |c|
+          ft.add_child(c)
+        end
+      end
+
+      ft
+    end
+
+    def self.new_from_solr_hash(h)
+      ft            = super
+      ft.solr_class = h['class']
+      ft
+    end
+
+    # Luckily, a nokogiri node can act like a hash, so we can
+    # just re-use #new_from_solr_hash
+    def self.new_from_xml(xml)
+      ft     = new_from_solr_hash(Nokogiri.XML(xml).children.first)
+      ft.xml = xml
+      ft
+    end
+  end
+end
+
+

data/lib/simple_solr/schema/matcher.rb

@@ -0,0 +1,16 @@
+# Figure out how to match a field name to a copyfield/dynamicfield
+class SimpleSolrClient::Schema
+  module Matcher
+    def derive_matcher(src)
+      if src =~ /\A\*(.*)/
+        Regexp.new("\\A(.*)(#{Regexp.escape($1)})\\Z")
+      else
+        src
+      end
+    end
+
+    def matches(s)
+      @matcher === s
+    end
+  end
+end

data/lib/simple_solr/version.rb

@@ -0,0 +1,3 @@
+module SimpleSolrClient
+  VERSION = "0.1.0"
+end

data/simple_solr_client.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'simple_solr/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "simple_solr_client"
+  spec.version       = SimpleSolrClient::VERSION
+  spec.authors       = ["Bill Dueber"]
+  spec.email         = ["bill@dueber.com"]
+  spec.summary       = %q{Interact with a Solr API via JSON}
+  spec.homepage      = "https://github.com/billdueber/simple_solr"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+
+  # Thread-safe, cross-platform http client
+  spec.add_dependency "httpclient"
+
+  # XML parsing. Slower, but less screwy than Nokogiri
+  spec.add_dependency 'nokogiri'
+
+  # Only require Oj for MRI/rbx. We'll use stock JSON on jruby
+  if defined? JRUBY
+    spec.platform = "java"
+  else
+    spec.add_dependency 'oj'
+  end
+
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency 'minitest-reporters'
+end

data/solr_sample_core/conf/_schema_analysis_stopwords_english.json

@@ -0,0 +1,38 @@
+{
+  "initArgs":{"ignoreCase":true},
+  "managedList":[
+    "a",
+    "an",
+    "and",
+    "are",
+    "as",
+    "at",
+    "be",
+    "but",
+    "by",
+    "for",
+    "if",
+    "in",
+    "into",
+    "is",
+    "it",
+    "no",
+    "not",
+    "of",
+    "on",
+    "or",
+    "stopworda",
+    "stopwordb",
+    "such",
+    "that",
+    "the",
+    "their",
+    "then",
+    "there",
+    "these",
+    "they",
+    "this",
+    "to",
+    "was",
+    "will",
+    "with"]}

data/solr_sample_core/conf/_schema_analysis_synonyms_english.json

@@ -0,0 +1,11 @@
+{
+  "initArgs":{
+    "ignoreCase":true,
+    "format":"solr"
+  },
+  "managedMap":{
+    "GB":["GiB","Gigabyte"],
+    "happy":["glad","joyful"],
+    "TV":["Television"]
+  }
+}