simple_solr_client 0.1.2 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f87cc6f04f52c248eb1e34ed32b7532963502081
-  data.tar.gz: 3218776c72babf7322c098ebf7b15b1d485090df
+  metadata.gz: 7bd1347fc6a4bdc8dd5cbf6fc240e8341cc1421c
+  data.tar.gz: 34cf45357e585520d46ebeab5756010eab14c0d0
 SHA512:
-  metadata.gz: 064e2606f8593af59d63877d47c3df46ddd303f1a454e2a222c484ae4a3f9e673e908fa0f6f931557e7c586abb15aef05d018d292884a6c08713e1ec6281fae2
-  data.tar.gz: a0add1a6aa0a1c4021a72e4cbf0426165f8e11def2d3700f0374cb4a2174a1c81f77df754ec9b1b6fa93396638b905479b43efd5ee9908d61756d2b9b300a0c1
+  metadata.gz: a10b32a6954ee985251d9d3386e0b9dca42bfb3efd677ef3469f4e6b82226efbfd1c70d0e1ceab691f5ce5f8aa293d3154558680918edd5fbd25b30887387e96
+  data.tar.gz: fd691d29fdbd45b255a024be57d89436a9fc2bd8a14177b23d449ff8dafb4c14613392e06229579e4aba60e235f6c17e90c118223d26dc970ef5a6cce35d4b34

data/CHANGES.md

@@ -0,0 +1,5 @@
+v0.2.0
+  * Add this CHANGE.md file
+  * Add `solr_shell` command-line executable.
+  * TODO: custom exception that includes response
+   

data/README.md

@@ -1,55 +1,24 @@
 # SimpleSolrClient
 
-[Note: still woefully incomplete, but in the spirit of "release early,
-even if it's bad", here it is.]
+A simple client and accompanying shell to help test and give simple
+commands to a solr instance.
 
-A Solr client specifically designed to try to help you test what the heck
-solr is actually doing.
-
-Most useful when running on the same machine as the solr install, but
-still useful even when you're not.
-
-
-## Motivation
-
-Solr is complex.
-
-It's complex enough, and fuddles with enough edge cases, that reading
-the documentation and/or the code doesn't get me the understanding
-that I feel I need.
-
-If I were smarter, maybe I wouldn't need something like this.
-
-I wanted a way to test what solr is actually doing, and
-this library is a way for me to start to do that in a fashion that's
-more convenient that doing everything "by hand" in the admin dashboard
-or running queries via URLs in my browser or using curl.
-
-I wanted a way to figure out what fields (of what types) are being created,
-how things were being  tokenized, etc., but all within the comfort of a test
-suite that I could run against solr configurations to make sure things
-weren't breaking when I made changes. I wanted to build up a structure around relevance
-ranking tests (still coming, sadly) and quickly swap out different
-configs to make sure it all works as I expect.
-
-So: a simple solr library, with more exposure than most of what's out there
-to the solr administration API and the introspection/analysis it affords.
 
 # Features:
 
-  * Basic add/delete/query
-  * Commit/optimize/clear an index
-  * Reload a core after editing/adjusting a config file
+  * Get basic info about cores (size, number of docs, etc.)
+  * Basic (*very basic) add/delete/query
+  * Commit/optimize/clear (empty) an index
+  * Reload a core (presumably after editing a `schema.xml` or `solrconfig.xml`)
   * Inspect lists of fields, dynamicFields, copyFields, and
     fieldTypes
-  * Determine which fields (and their properties) would be
-    created when a given field name is indexed, taking into
-    account dynamicField and copyField directives.
   * Get list of the tokens that would be created if you
     send a string to a paricular fieldType (like in the
     solr admin analysis page)
-  * Spit a modified schema object back out as xml for
-    saving somewhere if you'd like
+  * Determine (usually) which fields (and their properties) would be
+    created when a given field name is indexed, taking into
+    account dynamicField and copyField directives.
+
 
 Additional features when running against a localhost solr:
   * Spin up a temporary core to play with
@@ -83,12 +52,14 @@ core.schema_file #=> <path>/<to>/<schema.xml>
 # Remove all the indexed documents and (automatically) commit
 core.clear
 
+core.number_of_documents #=> 0. Automatic commit for #clear
+
 # Add documents
 #
 # name_t is a text_general, multiValued, indexed, stored field
-h1 = {:id => 'b', :name_t=>"Bill Dueber"}
-h2 = {:id => 'd', :name_t=>"Danit Brown"}
-h3 = {:id => 'z', :name_t=>"Ziv Brown Dueber"}
+h1 = {:id => '1', :name_t=>"Bill Dueber"}
+h2 = {:id => '2', :name_t=>"Danit Brown"}
+h3 = {:id => '3', :name_t=>"Ziv Brown Dueber"}
 
 core.add_docs(h1)
 
@@ -112,10 +83,10 @@ docs = core.fv_search(:name_t, 'Brown')
 docs.class #=>  SimpleSolrClient::Response::QueryResponse
 
 docs.size #=> 2
-docs..map{|d| d['name_t']} #=> [['Danit Brown'], ['Ziv Brown Dueber']]
+docs.map{|d| d['name_t']} #=> [['Danit Brown'], ['Ziv Brown Dueber']]
 
 # Special-case id/score as regular methods
-docs.first.id #=> 'd'
+docs.first.id #=> '2'
 docs.first.score #=> 0.625
 
 # Figure out where documents fall. "Ziv Brown Dueber" contains both
@@ -123,8 +94,8 @@ docs.first.score #=> 0.625
 docs = core.fv_search(:name_t, 'Brown Dueber')
 docs.size #=> 3
 
-docs.rank('z') #=> 1 (check by id)
-docs.rank('z') < docs.rank('b') #=> true
+docs.rank('3') #=> 1 (check by id)
+docs.rank('3') < docs.rank('b') #=> true
 
 # Of course, we can do it by score
 docs.score('z') > docs.score('d')
@@ -135,40 +106,116 @@ core.delete('name_t:Dueber').commit.number_of_documents #=> 1
 
 ```
 
-## The `schema` object
+## Field Types and analysis
 
-Each core exposes a `schema` object that allows you to find out about
-the fields, copyfields, and field types, and (on localhost) muck
-with the system on the fly.
+Field Types are created by getting data from the API and also
+parsing XML out of the schema.xml (for later creating a new
+schema.xml if you'd like).
+
+You can also ask a field type how it would tokenize an input
+string via indexing or querying.
+
+NOTE: FieldTypes _should_ be able to, say, report their XML serialization even
+when outside of a particular schema object, but right now that doesn't
+work. If you make changes to a field type, the only way to see the new
+serialization is to call `schema.to_xml` on whichever schema you added
+it to via `schema.add_field_type(ft)`
+
+
+
+```ruby
+
+core.schema.field_types.size #=> 23
+ft = schema.field_type('text') #=> SimpleSolrClient::Schema::FieldType
+ft.name #=> 'text'
+ft.solr_class #=> 'solr.TextField'
+ft.multi #=> true
+ft.stored #=> true
+ft.indexed #=> true
+# etc.
+
+newft = SimpleSolrClient::Schema::FieldType.new_from_xml(xmlstring)
+schema.add_field_type(newft)
+
+ft.name #=> text
+ft.query_tokens "Don't forget me when I'm getting H20"
+  #=> ["don't", "forget", "me", "when", "i'm", ["getting", "get"], "h20"]
+
+ft.index_tokens 'When it rains, it pours'
+  #=> ["when", "it", ["rains", "rain"], "it", ["pours", "pour"]]
+
+
+# Check for validity
+
+int_type = core.schema.field_type('int')
+int_type.index_tokens("33") => ["33"]
+int_type.index_token_valid?("33") #=> true
+
+int_type.index_token_valid?("33.3") #=> false
+int_type.index_tokens('33.3') #=>   RuntimeError
+ 
+
+```
+
+
+
+## Saving/reloading a changed configuration
+
+Whether you change a solr install via editing a text file or
+by using `schema.write`, you can always reload a core.
+
+```ruby
+core.reload
+```
+
+If you're working on localhost, you can make programmatic changes
+to the schema and then ask for a write/reload cycle. It uses the API
+to find the path to the schema.xml file and overwrites it.
+
+```ruby
 
-The schema object is initially created by using the admin api to
-get lists of fields and field types, and the XML for the field types
-is derived by parsing out the schema.xml returned by the api call. Solr
-does *not* expand entities in the returned XML, so if you have `system`
-entities (e.g., you're including stuff off of disk), SimpleSolrClient won't
-get that text and things will likely blow up.
+schema = core.schema
+core.add_field Field.new(:name=>'price', :type_name=>'float')
+schema.write
+schema = core.reload.schema
+```
+
+
+
+## The `schema` object
 
+Each core exposes a `schema` object that allows you to find out about
+the fields, copyfields, and field types, and how they interact with 
+query and index calls (like the analysis screen in the admin interface)
 
 ```ruby
 
 # Get a list of cores
-client.cores #=> ['core1']
+client.cores #=> ['core1', 'core2']
 core = client.core('core1')
 
 # Get an object representing the schema.xml file
 schema = core.schema #=> SimpleSolrClient::Schema object
 
-# Get lists of field, dynamicFields, copyFields, and fieldTypes
+# Get lists of field, dynamicFields, and copyFields
 # all as SimpleSolrClient::Schema::XXX objects
 
 explicit_fields = schema.fields
 dynamic_fields  = schema.dynamic_fields
 copy_fields     = schema.copy_fields
+
+# Get a list of FieldType object
 field_types     = schema.field_types
+field_type_names = schema.field_types.map(&:name) 
+
+# Check out a specific field type and how it parses stuff 
+mytexttype = schema.field_type('mytexttype') 
+mytexttype.index_tokens('bill dueber solr-stuff') #=> ['bill', 'dueber', 'solr', 'stuff']
+mytexttype.query_tokens('bill dueber solr-stuff') #=> ['bill', 'dueber', 'solr', 'stuff']
 
 ```
 
-### Regular fields
+### Regular (non-dynamic) fields
 
 Internally I call these "explicit_fields" as opposed to dynamic fields.
 
@@ -245,48 +292,6 @@ schema.add_copy_field(cf)
 ```
 
 
-### Field Types
-
-Field Types are created by getting data from the API and also
-parsing XML out of the schema.xml (for later creating a new
-schema.xml if you'd like).
-
-You can also ask a field type how it would tokenize an input
-string via indexing or querying.
-
-
-FieldTypes _should_ be able to, say, report their XML serialization even
-when outside of a particular schema object, but right now that doesn't
-work. If you make changes to a field type, the only way to see the new
-serialization is to call `schema.to_xml` on whichever schema you added
-it to via `schema.add_field_type(ft)`
-
-
-
-```ruby
-
-schema.field_types.size #=> 23
-ft = schema.field_type('text') #=> SimpleSolrClient::Schema::FieldType
-ft.name #=> 'text'
-ft.solr_class #=> 'solr.TextField'
-ft.multi #=> true
-ft.stored #=> true
-ft.indexed #=> true
-# etc.
-
-newft = SimpleSolrClient::Schema::FieldType.new_from_xml(xmlstring)
-schema.add_field_type(newft)
-
-ft.name #=> text
-ft.query_tokens "Don't forget me when I'm getting H20"
-  #=> ["don't", "forget", "me", "when", "i'm", ["getting", "get"], "h20"]
-
-ft.index_tokens 'When it rains, it pours'
-  #=> ["when", "it", ["rains", "rain"], "it", ["pours", "pour"]]
-
-```
-
-
 ## What will I get if I index a field named `str`?
 
 Dynamic- and copy-fields are very convenient, but it can make it hard to
@@ -313,28 +318,6 @@ rs.find_all{|f| f.indexed}.map(&:name) #=> ['name_t']
 ```
 
 
-## Saving/reloading a changed schema
-
-Whether you change a solr install via editing a text file or
-by using `schema.write`, you can always reload a core.
-
-```ruby
-core.reload
-```
-
-If you're working on localhost, you can make programmatic changes
-to the schema and then ask for a write/reload cycle. It uses the API
-to find the path to the schema.xml file and overwrites it.
-
-```ruby
-
-schema = core.schema
-core.add_field Field.new(:name=>'price', :type_name=>'float')
-schema.write
-schema = core.reload.schema
-```
-
-
 ## Installation
 
     $ gem install simple_solr

data/bin/solr_shell

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+
+# If we're loading from source instead of a gem, we need to
+# set the load path directly
+self_load_path = File.expand_path("../lib", File.dirname(__FILE__))
+unless $LOAD_PATH.include? self_load_path
+  $LOAD_PATH << self_load_path
+end
+
+require 'simple_solr_client'
+
+require 'pry'
+
+solr_url = ARGV[0]
+
+client = SimpleSolrClient::Client.new(solr_url)
+
+
+
+
+pry = Pry.new
+cb = pry.current_binding
+puts "
+     Connected to #{client.url}
+
+"
+
+cb.local_variable_set(:solr, client)
+puts "       * Created variable 'solr' for the main solr client"
+
+client.cores.each do |core|
+  cb.local_variable_set :"#{core}", client.core(core)
+  puts "       * Created variable '#{core}' pointing to its core"
+end
+
+puts "\n\n"
+
+
+cb.pry

data/lib/simple_solr_client/client/system.rb

@@ -0,0 +1,39 @@
+module SimpleSolrClient
+  # Attributes of the solr process itself
+  class System
+
+    def initialize(sysresp)
+      @resp = sysresp
+    end
+
+    # @return [String] Full lucene version, with release data and everything
+    def lucene_full_version
+      @resp['lucene']['lucene-impl-version']
+    end
+
+    # @return [String] Lucene version as M.m.p
+    def lucene_semver_version
+      @resp['lucene']['lucene-spec-version']
+    end
+
+    # @return [Integer] The major lucene version (e.g., 7)
+    def lucene_major_version
+      lucene_full_version.split('.').first.to_i
+    end
+
+    # @return [String] Full lucene version, with release data and everything
+    def solr_full_version
+      @resp['lucene']['solr-impl-version']
+    end
+
+    # @return [String] Lucene version as M.m.p
+    def solr_semver_version
+      @resp['lucene']['solr-spec-version']
+    end
+
+    # @return [Integer] The major lucene version (e.g., 7)
+    def solr_major_version
+      solr_semver_version.split('.').first.to_i
+    end
+  end
+end

data/lib/simple_solr_client/client.rb

@@ -3,6 +3,7 @@ require 'simple_solr_client/response/generic_response'
 require 'securerandom'
 
 require 'simple_solr_client/core'
+require 'simple_solr_client/client/system'
 
 module SimpleSolrClient
 
@@ -13,10 +14,18 @@ module SimpleSolrClient
 
     attr_reader :base_url, :rawclient
 
-    def initialize(url)
-      @base_url  = url.chomp('/')
+    def initialize(url_or_port)
+      url = if url_or_port.is_a?(Integer)
+              "http://localhost:#{url_or_port}/solr"
+            else
+              url_or_port
+            end
+
+      @base_url   = url.chomp('/')
       @client_url = @base_url
-      @rawclient = HTTPClient.new
+      @rawclient  = HTTPClient.new
+
+      # raise "Can't connect to Solr at #{url}" unless self.up?
     end
 
     # Construct a URL for the given arguments that hit the configured solr
@@ -31,12 +40,45 @@ module SimpleSolrClient
       [@client_url, *args].join('/').chomp('/')
     end
 
+    def ping
+      get('admin/ping')
+    end
+
+    # Get info about the solr system itself
+    def system
+      @system ||= SimpleSolrClient::System.new(get('admin/info/system'))
+    end
+
+    # @return [String] The solr semver version
+    def version
+      system.solr_semver_version
+    end
+
+    # @return [Integer] the solr major version
+    def major_version
+      system.solr_major_version
+    end
+
+    # Is the server up (and responding to a ping?)
+    # @return [Boolean]
+    def up?
+      begin
+        ping.status == 'OK'
+      rescue
+        false
+      end
+    end
+
+
 
-    # Call a get on the underlying http client and return the content
-    # You can pass in :force_top_level=>true for those cases wehn
-    # you absolutely have to use the client-level url and not a
+    # Call a 'get' on the underlying http client and return the content
+    # Will use whatever the URL is for the current context ("client" or
+    # "core"), although you can pass in :force_top_level=>true for those
+    # cases when you absolutely have to use the client-level url and not a
     # core level URL
-    def raw_get_content(path, args={})
+    #
+    # Error handling? What error handling???
+    def raw_get_content(path, args = {})
       if args.delete(:force_top_level_url)
         u = top_level_url(path)
       else
@@ -50,10 +92,10 @@ module SimpleSolrClient
     # @param [String] path The parts of the URL that comes after the core
     # @param [Hash] args The url arguments
     # @return [Hash] the parsed-out response
-    def _get(path, args={})
+    def _get(path, args = {})
       path.sub! /\A\//, ''
       args['wt'] = 'json'
-      res = JSON.parse(raw_get_content(path, args))
+      res        = JSON.parse(raw_get_content(path, args))
       if res['error']
         raise RuntimeError.new, res['error']
       end
@@ -89,25 +131,27 @@ module SimpleSolrClient
     # @param [String] corename The name of the core (which must already exist!)
     # @return [SimpleSolrClient::Core]
     def core(corename)
-      SimpleSolrClient::Core.new(@base_url, corename)
+      raise "Core #{corename} not found" unless cores.include? corename.to_s
+      SimpleSolrClient::Core.new(@base_url, corename.to_s)
     end
 
 
+    # Get all the cores
     def cores
-      cdata = get('admin/cores', {:force_top_level_url=>true}).status.keys
+      cdata = get('admin/cores', {:force_top_level_url => true}).status.keys
     end
 
 
     # Create a new, temporary core
     #noinspection RubyWrongHash
     def new_core(corename)
-      dir      = temp_core_dir_setup(corename)
+      dir = temp_core_dir_setup(corename)
 
       args = {
-          :wt          => 'json',
-          :action      => 'CREATE',
-          :name        => corename,
-          :instanceDir => dir
+        :wt          => 'json',
+        :action      => 'CREATE',
+        :name        => corename,
+        :instanceDir => dir
       }
 
       get('admin/cores', args)
@@ -121,7 +165,7 @@ module SimpleSolrClient
 
     # Set up files for a temp core
     def temp_core_dir_setup(corename)
-      dest = Dir.mktmpdir("simple_solr_#{corename}")
+      dest = Dir.mktmpdir("simple_solr_#{corename}_#{SecureRandom.uuid}")
       src  = SAMPLE_CORE_DIR
       FileUtils.cp_r File.join(src, '.'), dest
       dest

data/lib/simple_solr_client/core/admin.rb

@@ -1,17 +1,4 @@
 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

data/lib/simple_solr_client/core/core_data.rb

@@ -18,22 +18,38 @@ module SimpleSolrClient::Core::CoreData
     core_data_hash['index']
   end
 
-  def default?
-    core_data_hash['isDefaultCore']
-  end
-
+  # Time of last modification
   def last_modified
     Time.parse index['lastModified']
   end
 
+  # Total documents
   def number_of_documents
     index['numDocs']
   end
 
+  alias_method :numDocs, :number_of_documents
+  alias_method :num_docs, :number_of_documents
+
+  # The (local to the server) data directory
   def data_dir
     core_data_hash['dataDir']
   end
 
+
+  # Get the index size in megabytes
+  def size
+    str = index['size']
+    num, unit = str.split(/\s+/).compact.map(&:strip)
+    num = num.to_f
+    case unit
+    when "MB"
+      num * 1
+    when "GB"
+      num * 1000
+    end
+  end
+
   def instance_dir
     core_data_hash['instanceDir']
   end
@@ -45,7 +61,6 @@ module SimpleSolrClient::Core::CoreData
   def schema_file
     File.join(instance_dir, 'conf', core_data_hash['schema'])
   end
-
 end
 
 

data/lib/simple_solr_client/core.rb

@@ -25,7 +25,12 @@ class SimpleSolrClient::Core
   attr_reader :core
   alias_method :name, :core
 
-  def initialize(url, core)
+  def initialize(url, core=nil)
+    if core.nil?
+      components = url.gsub(%r[/\Z], '').split('/')
+      core = components.last
+      url = components[0..-2].join('/')
+    end
     super(url)
     @core = core
   end

data/lib/simple_solr_client/schema/analysis.rb

@@ -1,4 +1,3 @@
-
 # Figure out how the field type will parse out tokens
 # and change them in the analysis chain. Just calls the
 # provided solr analysis endpoints
@@ -6,6 +5,17 @@
 # To be mixed into FieldType
 
 class SimpleSolrClient::Schema
+
+  class InvalidTokenError < RuntimeError
+    attr_accessor :resp
+
+
+    def initialize(msg, resp)
+      super(msg)
+      @resp = resp
+    end
+  end
+
   module Analysis
 
     #https://lucene.apache.org/solr/4_1_0/solr-core/org/apache/solr/handler/FieldAnalysisRequestHandler.html
@@ -16,6 +26,7 @@ class SimpleSolrClient::Schema
                 'analysis.query'      => val,
       }
       resp   = @core.get(target, h)
+
       ftdata = resp['analysis']['field_types'][name][type]
       rv     = []
       ftdata.last.each do |t|
@@ -30,6 +41,7 @@ class SimpleSolrClient::Schema
       rv
     end
 
+
     private :fieldtype_tokens
 
     # Get an array of tokens as analyzed/transformed at index time
@@ -47,6 +59,15 @@ class SimpleSolrClient::Schema
       fieldtype_tokens(val, 'index')
     end
 
+
+    def index_input_valid?(val)
+      index_tokens(val)
+    rescue SimpleSolrClient::Schema::InvalidTokenError, RuntimeError => e
+      puts "IN HERE"
+      require 'pry'; binding.pry
+    end
+
+
     # Get an array of tokens as analyzed/transformed at query time
     # See #fieldtype_index_tokens
     def query_tokens(val)

data/lib/simple_solr_client/schema/field.rb

@@ -12,11 +12,22 @@ class SimpleSolrClient::Schema
       @dynamic = false
     end
 
-    def xml_node(doc)
-      Nokogiri::XML::Element.new('field', doc)
+    # 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
+
+
+        # 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)

data/lib/simple_solr_client/schema/field_or_type.rb

@@ -2,61 +2,52 @@
 module SimpleSolrClient
   class Schema
     class Field_or_Type
+
+      include Comparable
       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
+      # Sloppy from a data point of view, but make for easy
       # duplication and creation from xml/json
 
-      def initialize(h={})
+      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'
+        :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'
+        :stored            => 'stored',
+        :indexed           => 'indexed',
+        :multi             => 'multiValued',
+        :multivalued       => 'multiValued',
+        :multiValued       => 'multiValued',
+        :multi_valued      => 'multiValued',
+        :sort_missing_last => 'sortMissingLast',
+        :docvalues         => 'docValues',
+        :docValues         => 'docvalues',
+        :doc_values        => 'docvalues',
       }
 
-      # 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
+          name == other.name and type_name == other.type_name
         else
           name == other
         end
@@ -67,44 +58,53 @@ module SimpleSolrClient
         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 = nil)
+      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)
+          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)
-        self.send(k.to_sym)
+        @attributes[k.to_sym]
       end
 
       def []=(k, v)
-        self.send("#{k}=".to_sym, 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
-        h = {}
-        instance_variables.each do |iv|
-          h[iv.to_s.sub('@', '')] = instance_variable_get(iv)
-        end
-        h
+        @attributes
       end
 
     end

data/lib/simple_solr_client/schema/field_type.rb

@@ -27,21 +27,6 @@ class SimpleSolrClient::Schema
       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

data/lib/simple_solr_client/schema.rb

@@ -10,8 +10,6 @@ class SimpleSolrClient::Schema
   # A simplistic representation of a schema
 
 
-  attr_reader :xmldoc
-
   def initialize(core)
     @core           = core
     @fields         = {}
@@ -103,11 +101,7 @@ class SimpleSolrClient::Schema
 
 
   # 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
@@ -144,48 +138,10 @@ class SimpleSolrClient::Schema
     @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

data/lib/simple_solr_client/version.rb

@@ -1,3 +1,3 @@
 module SimpleSolrClient
-  VERSION = "0.1.2"
+  VERSION = "0.2.0"
 end

data/simple_solr_client.gemspec

@@ -29,4 +29,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "minitest"
   spec.add_development_dependency 'minitest-reporters'
+  spec.add_dependency 'pry'
 end

data/spec/minitest_helper.rb

@@ -8,14 +8,14 @@ Minitest::Reporters.use! Minitest::Reporters::SpecReporter.new
 require 'singleton'
 
 ENV['TEST_SOLR_URL'] ||= 'http://localhost:8983/solr'
-ENV['TEST_SOLR_CORE'] ||= 'core1'
+ENV['TEST_SOLR_CORE_NAME'] ||= 'core1'
 
 class TestClient
   include Singleton
   attr_reader :client, :core
   def initialize
     @client = SimpleSolrClient::Client.new ENV['TEST_SOLR_URL']
-    @core = @client.core ENV['TEST_SOLR_CORE']
+    @core = @client.core ENV['TEST_SOLR_CORE_NAME'] || 'simple_solr_test'
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: simple_solr_client
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.2.0
 platform: ruby
 authors:
 - Bill Dueber
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-23 00:00:00.000000000 Z
+date: 2018-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httpclient
@@ -94,20 +94,38 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - bill@dueber.com
-executables: []
+executables:
+- solr_shell
 extensions: []
 extra_rdoc_files: []
 files:
+- CHANGES.md
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/solr_shell
 - lib/simple_solr_client.rb
 - lib/simple_solr_client/client.rb
 - lib/simple_solr_client/client/core_admin.rb
+- lib/simple_solr_client/client/system.rb
 - lib/simple_solr_client/core.rb
 - lib/simple_solr_client/core/admin.rb
 - lib/simple_solr_client/core/core_data.rb
@@ -255,7 +273,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.6.13
 signing_key: 
 specification_version: 4
 summary: Interact with a Solr API via JSON
@@ -267,4 +285,3 @@ test_files:
 - spec/load_spec.rb
 - spec/minitest_helper.rb
 - spec/schema_spec.rb
-has_rdoc: