simple_solr_client 0.1.0

data/lib/simple_solr/core.rb

@@ -0,0 +1,50 @@
+# Pre-define the inheritance so Ruby doesn't complain
+# on import.
+require 'simple_solr/client'
+require 'simple_solr/schema'
+module SimpleSolrClient
+  class Core < Client
+  end
+end
+
+
+require 'simple_solr/core/admin'
+require 'simple_solr/core/core_data'
+require 'simple_solr/core/index'
+require 'simple_solr/core/search'
+
+class SimpleSolrClient::Core
+
+
+  include SimpleSolrClient::Core::Admin
+  include SimpleSolrClient::Core::CoreData
+  include SimpleSolrClient::Core::Index
+  include SimpleSolrClient::Core::Search
+
+
+  attr_reader :core
+  alias_method :name, :core
+
+  def initialize(url, core)
+    super(url)
+    @core = core
+  end
+
+
+  # Override #url so we're now talking to the core
+  def url(*args)
+    [@base_url, @core, *args].join('/').chomp('/')
+  end
+
+  # Send JSON to this core's update/json handler
+  def update(object_to_post, response_type = nil)
+    post_json('update/json', object_to_post, response_type)
+  end
+
+  def schema
+    @schema ||= SimpleSolrClient::Schema.new(self)
+  end
+
+end
+
+

data/lib/simple_solr/core/admin.rb

@@ -0,0 +1,47 @@
+module SimpleSolrClient::Core::Admin
+  def ping
+    get('admin/ping')
+  end
+
+  # Is the server up (and responding to a ping?)
+  # @return [Boolean]
+  def up?
+    begin
+      ping.status == 'OK'
+    rescue
+      false
+    end
+  end
+
+  # Send a commit command
+  # @return self
+  def commit
+    update({'commit' => {}})
+    self
+  end
+
+  # Send an optimize command
+  # @return self
+  def optimize
+    update({"optimize" => {}})
+    self
+  end
+
+  # Reload the core (for when you've changed the schema, solrconfig, synonyms, etc.)
+  # Make sure to mark the schema as dirty!
+  # @return self
+  def reload
+    get('admin/cores', {:force_top_level_url => true, :core => core, :action => 'RELOAD'})
+    @schema = nil
+    self
+  end
+
+  # Unload the current core and delete all its files
+  # @return The Solr response
+  def unload
+    get('admin/cores', {:force_top_level_url => true, :core => core, :action => 'UNLOAD', :deleteInstanceDir => true})
+  end
+
+
+end
+

data/lib/simple_solr/core/core_data.rb

@@ -0,0 +1,51 @@
+module SimpleSolrClient::Core::CoreData
+  attr_reader :raw_solr_hash
+
+
+  # Get the core data for this core
+  # This is weird in that while the data is about a specific
+  # core, we need to call it at the client_url level; hence
+  # all the screwing around with force_top_level_url
+  #
+  # It would make sense to cache this until, say, a commit or a
+  # reload, but the added complexity isn't yet worth it.
+  def core_data_hash
+    cdata = get('admin/cores', {:force_top_level_url => true})
+    cdata['status'][core]
+  end
+
+  def index
+    core_data_hash['index']
+  end
+
+  def default?
+    core_data_hash['isDefaultCore']
+  end
+
+  def last_modified
+    Time.parse index['lastModified']
+  end
+
+  def number_of_documents
+    index['numDocs']
+  end
+
+  def data_dir
+    core_data_hash['dataDir']
+  end
+
+  def instance_dir
+    core_data_hash['instanceDir']
+  end
+
+  def config_file
+    File.join(instance_dir, 'conf', core_data_hash['config'])
+  end
+
+  def schema_file
+    File.join(instance_dir, 'conf', core_data_hash['schema'])
+  end
+
+end
+
+

data/lib/simple_solr/core/index.rb

@@ -0,0 +1,25 @@
+module SimpleSolrClient::Core::Index
+  # Add the given hash or array of hashes
+  # @return self
+  def add_docs(*hash_or_hashes)
+    update(hash_or_hashes.flatten)
+    self
+  end
+
+  # A raw delete. Your query needs to be legal (e.g., escaped) already
+  # @param [String] q The query to identify items to delete
+  # @return self
+  def delete(q)
+    update({:delete => {:query => q}})
+    self
+  end
+
+  # Delete all document in the index and immdiately commit
+  # @return self
+  def clear
+    delete('*:*').commit
+    self
+  end
+
+
+end

data/lib/simple_solr/core/search.rb

@@ -0,0 +1,21 @@
+require 'simple_solr/response/query_response'
+
+module SimpleSolrClient::Core::Search
+
+  def fv_search(field, value)
+    v = value
+    v = SimpleSolrClient.lucene_escape Array(value).join(' ') unless v == '*'
+    kv = "#{field}:(#{v})"
+    get('select', {:q => kv}, SimpleSolrClient::Response::QueryResponse)
+  end
+
+  def all
+    fv_search('*', '*')
+  end
+
+  def id(i)
+    fv_search('id', i).first
+  end
+
+
+end

data/lib/simple_solr/response/document.rb

@@ -0,0 +1,45 @@
+class SimpleSolrClient::Response::Document
+  extend Forwardable
+  include Comparable
+
+  attr_accessor :rank
+
+  def <=>(other)
+    other = other.score if other.respond_to? :score,
+                                             self.score <=> other
+  end
+
+  # @!method [](key)
+  # @param [String] key The name of the stored field
+  # @return [String, Array<String>] the value(s) of the requested field
+  def_delegators :@solr_doc_hash, :[], :keys, :values, :to_s
+
+  # !@attribute solr_doc_hash
+  #   @return [Hash] the original, un-munged solr data for this document passed into the initializer
+  attr_accessor :solr_doc_hash, :rank
+
+
+  # Create a single document from a Hash representation of the solr return value
+  # @param solrdochash [Hash] The ruby-hash representation of a Solr document
+  # as returned by a solr query
+  def initialize(solrdochash)
+    @solr_doc_hash = solrdochash
+  end
+
+
+  # The value of the 'id' field of this document
+  def id
+    @solr_doc_hash['id']
+  end
+
+  # The score of this document on thsi query
+  def score
+    @solr_doc_hash['score']
+  end
+
+
+  def to_h
+    @solr_doc_hash.merge({'_rank' => @rank})
+  end
+
+end

data/lib/simple_solr/response/generic_response.rb

@@ -0,0 +1,19 @@
+require 'forwardable'
+
+module SimpleSolrClient
+  module Response
+    class GenericResponse
+      extend Forwardable
+      def_delegators :@solr_response, :[]
+
+      def initialize(solr_response_hash)
+        @solr_response = solr_response_hash
+      end
+
+      def status
+        @solr_response['status']
+      end
+
+    end
+  end
+end

data/lib/simple_solr/response/query_response.rb

@@ -0,0 +1,54 @@
+require 'simple_solr/response/generic_response'
+require 'simple_solr/response/document'
+
+class SimpleSolrClient::Response::QueryResponse < SimpleSolrClient::Response::GenericResponse
+  extend Forwardable
+  include Enumerable
+
+  attr_reader :num_found, :docs, :first_index, :docs, :params, :page
+
+  def_delegators :@docs, :each, :count, :size
+  def_delegators :@indexed_docs, :[]
+
+  def initialize(solr_response)
+    super
+    resp         = @solr_response['response']
+    @num_found   = resp['numFound']
+    @first_index = resp['start'] + 1
+
+    @docs         = []
+    @indexed_docs = {}
+    resp['docs'].each_with_index do |d, i|
+      doc_rank = i + @first_index
+      doc      = SimpleSolrClient::Response::Document.new(d)
+      doc.rank = doc_rank
+      @docs << doc
+      @indexed_docs[doc.id] = doc
+    end
+  end
+
+  def last_index
+    @first_index + @num_found
+  end
+
+  def rank(id)
+    @indexed_docs[id.to_s].rank
+  end
+
+  def score(id)
+    @indexed_docs[id.to_s].score
+  end
+
+  # @return [Boolean] True if there are no documents
+  def empty?
+    @docs.empty?
+  end
+
+
+  def each_with_rank
+    return self.enum_for(:each_with_rank) unless block_given?
+    @docs.each { |x| yield x, x.rank }
+  end
+
+end
+

data/lib/simple_solr/schema.rb

@@ -0,0 +1,261 @@
+require 'nokogiri'
+
+require 'simple_solr/schema/matcher'
+require 'simple_solr/schema/copyfield'
+require 'simple_solr/schema/field'
+require 'simple_solr/schema/dynamic_field'
+require 'simple_solr/schema/field_type'
+
+class SimpleSolrClient::Schema
+  # A simplistic representation of a schema
+
+
+  attr_reader :xmldoc
+
+  def initialize(core)
+    @core           = core
+    @fields         = {}
+    @dynamic_fields = {}
+    @copy_fields    = Hash.new { |h, k| h[k] = [] }
+    @field_types    = {}
+    self.load
+  end
+
+
+  def fields
+    @fields.values.map { |x| x.resolve_type(self) }
+  end
+
+  def field(n)
+    @fields[n].resolve_type(self)
+  end
+
+  def dynamic_fields
+    @dynamic_fields.values.map { |x| x.resolve_type(self) }
+  end
+
+  def dynamic_field(n)
+    @dynamic_fields[n].resolve_type(self)
+  end
+
+  def copy_fields_for(n)
+    @copy_fields[n]
+  end
+
+  def copy_fields
+    @copy_fields.values.flatten
+  end
+
+  def add_field(f)
+    @fields[f.name] = f
+    field(f.name)
+  end
+
+  def drop_field(str)
+    @fields.delete(str)
+    self
+  end
+
+
+  def field_types
+    @field_types.values
+  end
+
+  def field_type(k)
+    @field_types[k]
+  end
+
+
+  # When we add dynamic fields, we need to keep them sorted by
+  # length of the key, since that's how they match
+  def add_dynamic_field(f)
+    raise "Dynamic field should be dynamic and have a '*' in it somewhere; '#{f.name}' does not" unless f.name =~ /\*/
+    @dynamic_fields[f.name] = f
+
+    @dynamic_fields = @dynamic_fields.sort { |a, b| b[0].size <=> a[0].size }.to_h
+
+  end
+
+  def drop_dynamic_field(str)
+    @dynamic_fields.delete(str)
+    self
+  end
+
+  def add_copy_field(f)
+    cf = @copy_fields[f.source]
+    cf << f
+  end
+
+  def drop_copy_field(str)
+    @copy_fields.delete(str)
+    self
+  end
+
+  def add_field_type(ft)
+    ft.core = @core
+    @field_types[ft.name] = ft
+  end
+
+  def drop_field_type(str)
+    @field_types.delete(str)
+    self
+  end
+
+
+  # For loading, we get the information about the fields via the API,
+  # but grab an XML document for modifying/writing
+  def load
+    @xmldoc = Nokogiri.XML(@core.raw_get_content('admin/file', {:file => 'schema.xml'})) do |config|
+      config.noent
+    end
+    load_explicit_fields
+    load_dynamic_fields
+    load_copy_fields
+    load_field_types
+  end
+
+
+  def load_explicit_fields
+    @fields = {}
+    @core.get('schema/fields')['fields'].each do |field_hash|
+      add_field(Field.new_from_solr_hash(field_hash))
+    end
+  end
+
+  def load_dynamic_fields
+    @dynamic_fields = {}
+    @core.get('schema/dynamicfields')['dynamicFields'].each do |field_hash|
+      f = DynamicField.new_from_solr_hash(field_hash)
+      if @dynamic_fields[f.name]
+        raise "Dynamic field '#{f.name}' defined more than once"
+      end
+      add_dynamic_field(f)
+    end
+  end
+
+  def load_copy_fields
+    @copy_fields = Hash.new { |h, k| h[k] = [] }
+    @core.get('schema/copyfields')['copyFields'].each do |cfield_hash|
+      add_copy_field(CopyField.new(cfield_hash['source'], cfield_hash['dest']))
+    end
+  end
+
+  def load_field_types
+    @field_types = {}
+    @core.get('schema/fieldtypes')['fieldTypes'].each do |fthash|
+      ft        = FieldType.new_from_solr_hash(fthash)
+      type_name = ft.name
+      attr      = "[@name=\"#{type_name}\"]"
+      node      = @xmldoc.css("fieldType#{attr}").first || @xmldoc.css("fieldtype#{attr}").first
+      unless node
+        puts "Failed for type #{type_name}"
+      end
+      ft.xml    = node.to_xml
+      add_field_type(ft)
+    end
+  end
+
+  def clean_schema_xml
+    d = @xmldoc.dup
+    d.xpath('//comment()').remove
+    d.css('field').remove
+    d.css('fieldType').remove
+    d.css('fieldtype').remove
+    d.css('dynamicField').remove
+    d.css('copyField').remove
+    d.css('dynamicfield').remove
+    d.css('copyfield').remove
+    d.css('schema').children.find_all { |x| x.name == 'text' }.each { |x| x.remove }
+    d
+  end
+
+  def to_xml
+    # Get a clean schema XML document
+    d = clean_schema_xml
+    s = d.css('schema').first
+    [fields, dynamic_fields, copy_fields, field_types].flatten.each do |f|
+      s.add_child f.to_xml_node
+    end
+    d.to_xml
+  end
+
+
+  def write
+    File.open(@core.schema_file, 'w:utf-8') do |out|
+      out.puts self.to_xml
+    end
+  end
+
+  def reload
+    @core.reload
+  end
+
+
+  # Figuring out which fields are actually produced can be hard:
+  #   * If a non-dynamic field name matches, no dynamic_fields will match
+  #   * The result of a copyField may match another dynamicField, but the
+  #     result of *that* will not match more copyFields
+  #   * dynamicFields are matched longest to shortest
+  #
+  # Suppose I have the following:
+  #  dynamic *_ts => string
+  #  dynamic *_t  => string
+  #  dynamic *_s  => string
+  #  dynamic *_ddd => string
+  #
+  #  copy    *_ts => *_t
+  #  copy    *_ts => *_s
+  #  copy    *_s  => *_ddd
+  #
+  # You might expect:
+  #  name_ts => string
+  #  name_ts copied to name_t => string
+  #  name_ts copied to name_s => string
+  #  name_s  copied to name_ddd => string
+  #
+  # ...giving us name_ts, name_t, name_s, and name_ddd
+  #
+  # What you'll find is that we don't get name_ddd, since
+  # name_s was generated by a wildcard-enabled copyField
+  # and that's where things stop.
+  #
+  # However, if you explicitly add a field called
+  # name_s, it *will* get copied to name_ddd.
+  #
+  # Yeah. It's confusing.
+
+
+  def first_matching_field(str)
+    f = fields.find { |x| x.matches str } or first_matching_dfield(str)
+  end
+
+  def first_matching_dfield(str)
+    df = dynamic_fields.find { |x| x.matches str }
+    if df
+      f        = Field.new(df.to_h)
+      f[:name] = df.dynamic_name str
+    end
+    f
+
+  end
+
+  def resulting_fields(str)
+    rv = []
+    f  = first_matching_field(str)
+    rv << f
+    copy_fields.each do |cf|
+      if cf.matches(f.name)
+        dname      = cf.dynamic_name(f.name)
+        fmf        = Field.new(first_matching_field(dname).to_h)
+        fmf[:name] = dname
+        rv << fmf
+      end
+    end
+    rv.uniq
+  end
+
+end
+
+
+
+