simple_solr_client 0.2.0 → 0.2.1

data/lib/simple_solr_client/schema/copyfield.rb

@@ -1,42 +0,0 @@
-require 'simple_solr_client/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_client/schema/dynamic_field.rb

@@ -1,23 +0,0 @@
-require 'simple_solr_client/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_client/schema/field.rb

@@ -1,46 +0,0 @@
-require 'simple_solr_client/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
-
-    # We'll defer to the field type when calling any of the attribute
-    # methods
-    ([TEXT_ATTR_MAP.keys, BOOL_ATTR_MAP.keys].flatten - [:type_name]).each do |x|
-      define_method(x) do
-        rv = super()
-        if rv.nil?
-          self.type[x]
-        else
-          rv
-        end
-      end
-    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_client/schema/field_or_type.rb

@@ -1,112 +0,0 @@
-# Base class for Field/DynamicField/FieldType
-module SimpleSolrClient
-  class Schema
-    class Field_or_Type
-
-      include Comparable
-      attr_accessor :name,
-                    :type_name
-
-
-      # Take in a hash, and set anything in it that we recognize.
-      # Sloppy from a data point of view, but make for easy
-      # duplication and creation from xml/json
-
-      def initialize(h = {})
-        @attributes = {}
-        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',
-        :multivalued       => 'multiValued',
-        :multiValued       => 'multiValued',
-        :multi_valued      => 'multiValued',
-        :sort_missing_last => 'sortMissingLast',
-        :docvalues         => 'docValues',
-        :docValues         => 'docvalues',
-        :doc_values        => 'docvalues',
-      }
-
-
-
-
-      def ==(other)
-        if other.respond_to? :name
-          name == other.name and type_name == other.type_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|
-          define_method(field.to_sym) do
-            self[field.to_sym]
-          end
-          f[field] = h[xmlattr]
-        end
-
-        # Make some "method?" for the boolean attributes
-        BOOL_ATTR_MAP.keys.each do |methname|
-          q_methname = ((methname.to_s) + '?').to_sym
-          alias_method q_methname, methname
-        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 ||= 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
-
-      def to_xml
-        to_xml_node.to_xml
-      end
-
-      # Allow access to methods via [], for easy looping
-      def [](k)
-        @attributes[k.to_sym]
-      end
-
-      def []=(k, v)
-        @attributes[k.to_sym]  = v
-      end
-
-
-      # Make a hash out of it, for easy feeding back into another call to #new
-      def to_h
-        @attributes
-      end
-
-    end
-  end
-end

data/lib/simple_solr_client/schema/field_type.rb

@@ -1,47 +0,0 @@
-require 'simple_solr_client/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
-
-
-    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_client/schema/matcher.rb

@@ -1,16 +0,0 @@
-# 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/spec/core_basics.rb

@@ -1,21 +0,0 @@
-require 'minitest_helper'
-
-describe SimpleSolrClient::Client do
-
-  before do
-    @core = TempCore.instance.core('core_basics')
-  end
-  it "creates a new object" do
-    @core.base_url.must_equal "http://localhost:8983/solr"
-  end
-
-  it "constructs a url with no args" do
-    @core.url.must_equal "http://localhost:8983/solr/#{@core.name}"
-  end
-
-  it "constructs a URL with args" do
-    @core.url('admin', 'ping').must_equal "http://localhost:8983/solr/#{@core.name}/admin/ping"
-  end
-
-
-end

data/spec/schema_spec.rb

@@ -1,113 +0,0 @@
-require 'minitest_helper'
-
-describe "Schema" do
-
-  SS = SimpleSolrClient::Schema # convenience
-
-  before do
-    @core   = TempCore.instance.core('schema_spec')
-    @schema = @core.schema
-  end
-
-  describe "the id field" do
-    it "finds it" do
-      @schema.field('id').name.must_equal 'id'
-    end
-
-    it "has a type name of string" do
-      @schema.field('id').type_name.must_equal 'string'
-    end
-
-    it "has the string type" do
-      @schema.field('id').type.must_equal @schema.field_type('string')
-    end
-
-    it "matches on exact match" do
-      @schema.field('id').matches('id').must_equal true
-    end
-
-    it "doesn't match on inexact match" do
-      @schema.field('id').matches('testid').must_equal false
-    end
-
-  end
-
-  describe "the _i dynamic field" do
-    it "finds it" do
-      @schema.dynamic_field('*_i').wont_be_nil
-    end
-
-    it "has type int" do
-      @schema.dynamic_field("*_i").type.must_equal @schema.field_type('int')
-    end
-
-    it 'matches appropriates' do
-      dfield  = @schema.dynamic_field('*_i')
-      dfield.matches('test_i').must_equal true
-      dfield.matches('test_s_i').must_equal true
-      dfield.matches('test_i_s').must_equal false
-    end
-
-    it "is found when looking for a match" do
-      dfield  = @schema.dynamic_field('*_i')
-      results = @schema.resulting_fields("year_i")
-      results.size.must_equal 1
-      results.first.type.must_equal dfield.type
-    end
-
-  end
-
-  describe "add/delete field" do
-    it "allows us to add a field" do
-      @schema.add_field SS::Field.new(:name => 'new_field', :type_name => 'string')
-      @schema.write
-      @core.reload
-      @schema.field('new_field').wont_be_nil
-    end
-
-    it "allows us to drop a field" do
-      @schema.add_field SS::Field.new(:name => 'new_field', :type_name => 'string')
-      @schema.write
-      @core.reload
-      @schema.field('new_field').wont_be_nil
-      @schema.drop_field('new_field')
-      @schema.write
-      @schema = @core.reload.schema
-      @schema.fields.map(&:name).wont_include 'new_field'
-    end
-
-
-  end
-
-  describe 'Dynamic Fields' do
-    it "adds a dfield" do
-      @schema.add_dynamic_field SS::DynamicField.new(:name => '*_test_i', :type_name => 'string', :stored => true)
-      @schema.write
-      @schema = @core.reload.schema
-      @schema.dynamic_field('*_test_i').wont_be_nil
-    end
-
-    it "prefers longer dfield names when determining resulting_fields" do
-      @schema.add_dynamic_field SS::DynamicField.new(:name => '*_test_i', :type_name => 'string', :stored => true)
-      @schema.write
-      @schema = @core.reload.schema
-      rf = @schema.resulting_fields('bill_test_i')
-      rf.size.must_equal 1
-      rf.first.type.name.must_equal 'string'
-    end
-
-    it "prefers explicity-defined fields to dynamic fields" do
-      @schema.add_field SS::Field.new(:name=>'explicit_i', :type_name=>'string')
-      @schema.write
-      @schema = @core.reload.schema
-      rf = @schema.resulting_fields('explicit_i')
-      rf.size.must_equal 1
-      rf.first.type.name.must_equal 'string'
-    end
-
-
-  end
-
-
-end
-