solrbee 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca8f6d8f901268390057453075d0c39306b2362cb1216ec4dbcdb168b6d5bb18
-  data.tar.gz: b17d0b604e4276a47c2e54d17fc92f9b9cc173fb1c2b283cc4d15f6f506c99d8
+  metadata.gz: 77e7ebc45077bb8016d699124b9d4de397adba4d6166e0b3f64bb07693c51a3f
+  data.tar.gz: 846ea941962ac61ac49195bc0a05ef4356fbc0937a96055af43320c833b41b5d
 SHA512:
-  metadata.gz: 3967982e1454c5659be6716eaf2e3a1a215046b6c3bfbe383c09810b519391017ddb4febedc861235d97b44253fd4950ad75f88dbcddc5378e33d5e37d822c59
-  data.tar.gz: 9cd90db400ec1a2ec23daa227e6e22afb23da39328fb66384bd2cf18c52a01ee4c5db1f2620079a4a63d19096edc706de5320be3e93e67f8da5c2fb600948c61
+  metadata.gz: 278f91339f713389ab9858471f35f8a72d07ae1e00083e931cade7af50aee540ba8abf1bd42a79f1a1ffa11ab3b081f8a3231035642ff61091abc7f8f3306da5
+  data.tar.gz: a143efa02fed4ee7e10c063bf4c4db6df6df5f9bbf40ba820c004c4961e206545d980ed615f566b99c996f30db184a49fce7a005d990ebbca4b9028cddadaebf

data/Gemfile

@@ -1,3 +1,5 @@
 source "https://rubygems.org"
 
 gemspec
+
+gem "rom-http", git: "https://github.com/rom-rb/rom-http.git"

data/Makefile

@@ -1,7 +1,10 @@
 SHELL = /bin/bash
 
+SOLR_URL = http://localhost:8983/solr/solrbee
+
 .PHONY : test
 test:
-	docker run --rm -d --name solrbee-test solr:8 solr-precreate solrbee
-	bundle exec rake
+	docker run --rm -d -p 8983:8983 --name solrbee-test solr:8 solr-precreate solrbee
+	while ! curl -fs http://localhost:8983/solr/solrbee/admin/ping 2>/dev/null ; do sleep 1 ; done
+	SOLR_URL=$(SOLR_URL) bundle exec rake
 	docker stop solrbee-test

data/README.md

@@ -1,8 +1,11 @@
 # Solrbee
 
+![Bee photo (c) David Chandek-Stark](https://raw.githubusercontent.com/dchandekstark/images/main/solrbee.jpg)
+
 Solrbee is intended as a lightweight library for interacting with a modern Solr instance
-using a managed schema.  Our intestest is primarily in using Solr as data store, for example,
-as an alterative to an RDBMS.
+as NoSQL data store.
+
+We are currently building on the JSON APIs (V1).
 
 ## Installation
 
@@ -22,7 +25,17 @@ Or install it yourself as:
 
 ## Usage
 
-
+```
+$ bundle console
+irb(main):001:0> client = Solrbee::Client.new('solrbee')
+=> #<Solrbee::Client:0x00007fd3410d7c50 @collection="solrbee", @uri=#<URI::HTTP http://localhost:8983/solr/solrbee>>
+irb(main):002:0> client.unique_key
+=> "id"
+irb(main):003:0> client.schema_version
+=> 1.6
+irb(main):004:0> client.schema_name
+=> "default-config"
+```
 
 ## Development
 

data/config/api.yml

@@ -0,0 +1,45 @@
+v1:
+  ping:
+    path: /admin/ping
+    response_key: status
+
+  schema:
+    path: /schema
+    response_key: schema
+
+  schema_name:
+    path: /schema/name
+    response_key: name
+
+  schema_version:
+    path: /schema/version
+    response_key: version
+
+  fields:
+    path: /schema/fields
+    response_key: fields
+
+  field:
+    path: /schema/fields/%{name}
+    response_key: field
+
+  unique_key:
+    path: /schema/uniquekey
+    response_key: uniqueKey
+
+  field_types:
+    path: /schema/fieldtypes
+    response_key: fieldTypes
+
+  field_type:
+    path: /schema/fieldtypes/%{name}
+    response_key: fieldType
+
+  update:
+    path: /update
+
+  update_json:
+    path: /update/json
+
+  update_json_docs:
+    path: /update/json/docs

data/lib/rom/solr.rb

@@ -0,0 +1,22 @@
+require 'rom-http'
+
+require_relative 'solr/request'
+require_relative 'solr/response'
+
+require_relative 'solr/dataset'
+require_relative 'solr/datasets/select_dataset'
+
+require_relative 'solr/gateway'
+
+require_relative 'solr/schemaless'
+
+require_relative 'solr/relation'
+require_relative 'solr/relations/schema_relation'
+require_relative 'solr/relations/select_relation'
+
+module ROM
+  module Solr
+  end
+
+  register_adapter(:solr, ROM::Solr)
+end

data/lib/rom/solr/dataset.rb

@@ -0,0 +1,93 @@
+module ROM
+  module Solr
+    class Dataset < ROM::HTTP::Dataset
+
+      # Key or array of keys to pass to response.dig(*keys)
+      # for enumeration of the dataset values.
+      setting :default_enum_on, reader: true
+      option :enum_on, default: ->{ self.class.default_enum_on }
+
+      # Default query parameters
+      setting :default_params, EMPTY_HASH, reader: true
+      option :params, type: Types::Hash, default: ->{ self.class.default_params }
+
+      # Request and response handlers
+      config.default_response_handler = Response
+      config.default_request_handler = Request
+
+      # @override Handles multiple path segments and nils
+      def with_path(segments)
+        s = Array.wrap(segments)
+        return self if s.empty?
+        with_options(path: s.compact.join('/'))
+      end
+
+      def with_enum_on(keys)
+        k = Array.wrap(keys)
+        return self if k.empty?
+        with_options(enum_on: k)
+      end
+
+      # Coerce param value to an Array and set new value
+      # to set union with other Array of values.
+      def add_param_values(key, val)
+        new_val = Array.wrap(params[key]) | Array.wrap(val)
+        add_params(key => new_val)
+      end
+
+      # @override
+      def add_params(new_params = {})
+        return self if new_params.nil? || new_params.empty?
+        with_params params.merge(new_params).compact
+      end
+
+      def default_params(defaults = {})
+        with_params defaults.merge(params)
+      end
+
+      # @override Seems good to have no-op when params not changed?
+      def with_params(new_params)
+        if params == new_params
+          self
+        else
+          with_options(params: new_params)
+        end
+      end
+
+      def param?(key)
+        params.key?(key)
+      end
+
+      # Copies and makes private superclass #response method
+      alias_method :__response__, :response
+      private :__response__
+
+      # @override Cache response by default
+      def response
+        cache.fetch_or_store(:response) { __response__ }
+      end
+
+      # @override
+      def each(&block)
+        return to_enum unless block_given?
+        enumerable_response.each(&block)
+      end
+
+      def enumerable_response
+        if options[:enum_on].nil?
+          Array.wrap(response)
+        else
+          keys = Array.wrap options[:enum_on]
+          Array.wrap response.dig(*keys)
+        end
+      end
+
+      private
+
+      def cache
+        @cache ||= Concurrent::Map.new
+      end
+
+    end
+  end
+end

data/lib/rom/solr/datasets/select_dataset.rb

@@ -0,0 +1,53 @@
+module ROM
+  module Solr
+    class SelectDataset < Dataset
+
+      config.default_enum_on = [ 'response', 'docs' ]
+      config.default_params  = { q: '*:*', start: 0, rows: 20, cursorMark: '*', sort: 'id ASC' }
+
+      # @override
+      def each
+        while true
+          enumerable_response.each { |doc| yield(doc) }
+          break if last_page?
+          update_cursor_mark
+        end
+      end
+
+      def num_found
+        response.dig('response', 'numFound')
+      end
+
+      def cursor_mark
+        params[:cursorMark]
+      end
+
+      def next_cursor_mark
+        response['nextCursorMark']
+      end
+
+      def page_size
+        params[:rows]
+      end
+
+      def last_cursor?
+        cursor_mark == next_cursor_mark
+      end
+
+      def one_page?
+        num_found <= page_size
+      end
+
+      def last_page?
+        one_page? || last_cursor?
+      end
+
+      private
+
+      def update_cursor_mark
+        add_params(cursorMark: next_cursor_mark)
+      end
+
+    end
+  end
+end

data/lib/rom/solr/gateway.rb

@@ -0,0 +1,25 @@
+module ROM
+  module Solr
+    class Gateway < ROM::HTTP::Gateway
+
+      adapter :solr
+
+      def initialize(config = {})
+        config[:uri]     ||= ENV.fetch('SOLR_URL', 'http://localhost:8983/solr')
+        config[:headers] ||= { Accept: 'application/json' }
+        super
+      end
+
+      def dataset(name)
+        dataset_class(name).new config.merge(base_path: name)
+      end
+
+      def dataset_class(name)
+        prefix = name.to_s.split(/_/).map(&:capitalize).join('')
+        const_name = "#{prefix}Dataset"
+        ROM::Solr.const_defined?(const_name, false) ? ROM::Solr.const_get(const_name, false) : Dataset
+      end
+
+    end
+  end
+end

data/lib/rom/solr/paginated_dataset.rb

@@ -0,0 +1,62 @@
+module ROM
+  module Solr
+    class PaginatedDataset
+
+      attr_reader :dataset
+
+      def initialize(dataset)
+        ds = dataset
+               .default_params(rows: 20)
+               .remove_params(:start)
+               .add_params(cursorMark: '*')
+
+        if ds.param?(:sort)
+          unless ds.params[:sort] =~ /\bid\b/
+            ds = ds.sort('%{sort},id ASC' % ds.params)
+          end
+        else
+          ds = ds.sort('id ASC')
+        end
+
+        @dataset = ds
+      end
+
+      def each
+        while true
+          yield dataset
+          break if last_page?
+          @dataset = dataset.add_params(cursorMark: next_cursor_mark)
+        end
+      end
+
+      def cursor_mark
+        dataset.params[:cursorMark]
+      end
+
+      def next_cursor_mark
+        dataset.response['nextCursorMark']
+      end
+
+      def page_size
+        dataset.params[:rows]
+      end
+
+      def total_size
+        dataset.num_found
+      end
+
+      def last_cursor?
+        cursor_mark == next_cursor_mark
+      end
+
+      def one_page?
+        total_size <= page_size
+      end
+
+      def last_page?
+        one_page? || last_cursor?
+      end
+
+    end
+  end
+end

data/lib/rom/solr/relation.rb

@@ -0,0 +1,25 @@
+module ROM
+  module Solr
+    class Relation < ROM::HTTP::Relation
+      extend Schemaless
+
+      adapter :solr
+
+      forward :add_param_values, :default_params, :with_enum_on
+
+      def fetch(key, default = nil)
+        return self if key.nil?
+        dataset.response.fetch(key, default)
+      end
+
+      def count
+        to_enum.count
+      end
+
+      def all
+        self
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+module ROM
+  module Solr
+    class SchemaRelation < Relation
+
+      schemaless(:schema, as: :schema_info)
+
+      # GET /schema
+      def info
+        fetch('schema')
+      end
+
+      def schema_name
+        with_path(:name).fetch(:name)
+      end
+
+      def version
+        with_path('version').fetch('version')
+      end
+
+      def unique_key
+        with_path('uniquekey').fetch('uniqueKey')
+      end
+
+      def similarity
+        with_path('similarity').fetch('similarity')
+      end
+
+      # @param opts [Hash]
+      def fields(**opts)
+        default_opts = { showDefaults: true }
+        with_path('fields')
+          .with_enum_on('fields')
+          .add_params(default_opts.merge(opts))
+      end
+
+      # @param name [String, Symbol] field name
+      # @param opts [Hash]
+      def field(name, **opts)
+        with_path('fields', name)
+          .add_params(opts)
+          .fetch('field')
+      end
+
+      # @param opts [Hash]
+      def field_types(**opts)
+        with_path('fieldtypes')
+          .with_enum_on('fieldTypes')
+          .add_params(opts)
+      end
+
+      # @param name [String, Symbol] field type name
+      # @param opts [Hash]
+      def field_type(name, **opts)
+        with_path('fieldtypes', name).add_params(opts).fetch('fieldType')
+      end
+
+      # @param opts [Hash]
+      def dynamic_fields(**opts)
+        with_path('dynamicfields').with_enum_on('dynamicFields').add_params(opts)
+      end
+
+      # @param name [String, Symbol] dynamic field name
+      # @param opts [Hash]
+      def dynamic_field(name, **opts)
+        with_path('dynamicfields', name).add_params(opts).fetch('dynamicField')
+      end
+
+      # @param opts [Hash]
+      def copy_fields(**opts)
+        with_path('copyfields').with_enum_on('copyFields').add_params(opts)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,43 @@
+module ROM
+  module Solr
+    class SelectRelation < Relation
+
+      schemaless :select, as: :search
+
+      def filter(*fq)
+        add_param_values(:fq, fq)
+      end
+      alias_method :fq, :filter
+
+      def query(q)
+        add_params(q: q)
+      end
+      alias_method :q, :query
+
+      def fields(*fl)
+        add_params(fl: fl)
+      end
+      alias_method :fl, :fields
+
+      def start(offset)
+        add_params(start: offset.to_i)
+      end
+      alias_method :offset, :start
+
+      def rows(limit)
+        add_params(rows: limit.to_i)
+      end
+      alias_method :limit, :rows
+
+      def sort(crit)
+        add_params(sort: crit)
+      end
+
+      # @override Don't have to enumerate to get count (may not be exact)
+      def count
+        dataset.num_found
+      end
+
+    end
+  end
+end

data/lib/rom/solr/request.rb

@@ -0,0 +1,24 @@
+module ROM
+  module Solr
+    class Request
+
+      def self.call(dataset)
+        uri = URI(dataset.uri)
+        uri.query = URI.encode_www_form(dataset.params)
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true if uri.scheme.eql?('https')
+
+        request_class = Net::HTTP.const_get(ROM::Inflector.classify(dataset.request_method))
+        request = request_class.new(uri.request_uri)
+
+        dataset.headers.each_with_object(request) do |(header, value), request|
+          request[header.to_s] = value
+        end
+
+        http.request(request)
+      end
+
+    end
+  end
+end

data/lib/rom/solr/response.rb

@@ -0,0 +1,12 @@
+module ROM
+  module Solr
+    class Response
+
+      # @return [Hash] Parsed JSON object from Solr response body
+      def self.call(response, dataset)
+        JSON.parse(response.body)
+      end
+
+    end
+  end
+end

data/lib/rom/solr/schema.rb

@@ -0,0 +1,9 @@
+module ROM
+  module Solr
+    class Schema < ROM::HTTP::Schema
+
+
+
+    end
+  end
+end

data/lib/rom/solr/schemaless.rb

@@ -0,0 +1,24 @@
+require "hashie"
+
+module ROM
+  module Solr
+    module Schemaless
+
+      def self.extended(base)
+        schemaless_output = Class.new(Hashie::Mash) do
+          include Hashie::Extensions::Mash::SymbolizeKeys
+          disable_warnings
+        end
+        base.const_set(:SchemalessOutput, schemaless_output)
+        base.option :output_schema, default: ->{ self.class.const_get(:SchemalessOutput) }
+      end
+
+      def schemaless(*args)
+        schema(*args) do
+          # no schema :)
+        end
+      end
+
+    end
+  end
+end

data/lib/solrbee.rb

@@ -1,65 +1,39 @@
-require "net/http"
-require "uri"
-require "json"
-
 require "solrbee/version"
-require "solrbee/base"
-require "solrbee/response"
-require "solrbee/collection"
-require "solrbee/schema_api"
+require "solrbee/array"
+require "rom/solr"
 
 module Solrbee
-  class Error < StandardError; end
-
-  # Single-valued field types
-  STRING  = "string"
-  LONG    = "plong"
-  INT     = "pint"
-  DATE    = "pdate"
-  BOOLEAN = "boolean"
-
-  # Multi-valued field types
-  MSTRING  = "strings"
-  MLONG    = "plongs"
-  MINT     = "pints"
-  MDATE    = "pdates"
-  MBOOLEAN = "booleans"
-
-  def self.solr_url
-    ENV.fetch('SOLR_URL', 'http://localhost:8983/solr/')
-  end
 
-  def self.solr_uri
-    URI(solr_url)
+  # Factory method
+  #
+  # @return [ROM::Solr::Gateway] a gateway instance
+  def self.gateway
+    ROM::Gateway.setup(:solr)
   end
 
-  def self.connection
-    Net::HTTP.new(solr_uri.host, solr_uri.port).tap do |http|
-      http.use_ssl = true if solr_uri.scheme == 'https'
-    end
-  end
-
-  def self.request_class(method)
-    Net::HTTP.const_get(method.to_s.downcase.capitalize)
+  # Factory method
+  #
+  # @return [Solrbee::Documents] a ROM relation for searching
+  def self.documents
+    container.relations[:search]
   end
 
-  def self.request(method, path)
-    u = URI.join(solr_url, path)
-    req = request_class(method).new(u, {'Accept'=>'application/json'})
-    yield req if block_given?
-    res = connection.request(req)
-    Response.handle(res)
+  def self.schema
+    container.relations[:schema_info]
   end
 
-  def self.get(path)
-    request(:get, path)
+  # @return [ROM::Configuration] configuration
+  def self.config
+    @config ||= ROM::Configuration.new(:solr) do |config|
+      config.register_relation(
+        ROM::Solr::SelectRelation,
+        ROM::Solr::SchemaRelation
+      )
+    end
   end
 
-  def self.post(path, data)
-    request(:post, path) do |req|
-      req['Content-Type'] = 'application/json'
-      req.body = JSON.dump(data)
-    end
+  def self.container
+    ROM.container(config)
   end
 
 end

data/lib/solrbee/array.rb

@@ -0,0 +1,10 @@
+Array.class_eval do
+
+  # Inspired by Rails's Array.wrap
+  def self.wrap(obj)
+    return [] if obj.nil?
+    return obj.to_ary if obj.respond_to?(:to_ary)
+    Array.new(1, obj)
+  end
+
+end

data/lib/solrbee/version.rb

@@ -1,3 +1,3 @@
 module Solrbee
-  VERSION = "0.1.0"
+  VERSION = "0.3.0"
 end

data/solrbee.gemspec

@@ -23,6 +23,8 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_dependency "hashie"
+  spec.add_dependency "rom"
+  spec.add_dependency "rom-http"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: solrbee
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - David Chandek-Stark
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-12-02 00:00:00.000000000 Z
+date: 2020-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: hashie
@@ -24,6 +24,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rom
+  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'
+- !ruby/object:Gem::Dependency
+  name: rom-http
+  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'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -96,11 +124,21 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- config/api.yml
+- lib/rom/solr.rb
+- lib/rom/solr/dataset.rb
+- lib/rom/solr/datasets/select_dataset.rb
+- lib/rom/solr/gateway.rb
+- lib/rom/solr/paginated_dataset.rb
+- lib/rom/solr/relation.rb
+- lib/rom/solr/relations/schema_relation.rb
+- lib/rom/solr/relations/select_relation.rb
+- lib/rom/solr/request.rb
+- lib/rom/solr/response.rb
+- lib/rom/solr/schema.rb
+- lib/rom/solr/schemaless.rb
 - lib/solrbee.rb
-- lib/solrbee/base.rb
-- lib/solrbee/collection.rb
-- lib/solrbee/response.rb
-- lib/solrbee/schema_api.rb
+- lib/solrbee/array.rb
 - lib/solrbee/version.rb
 - solrbee.gemspec
 homepage: https://github.com/dchandekstark/solrbee

data/lib/solrbee/base.rb

@@ -1,14 +0,0 @@
-require 'hashie'
-
-module Solrbee
-  class Base < Hashie::Hash
-    include Hashie::Extensions::Coercion
-    include Hashie::Extensions::MergeInitializer
-    include Hashie::Extensions::MethodAccess
-  end
-
-  Field     = Class.new(Base)
-  FieldType = Class.new(Base)
-  Header    = Class.new(Base)
-  Schema    = Class.new(Base)
-end

data/lib/solrbee/collection.rb

@@ -1,19 +0,0 @@
-module Solrbee
-  class Collection
-
-    attr_reader :name
-
-    def initialize(name)
-      @name = name
-    end
-
-    def to_s
-      name
-    end
-
-    def schema
-      @schema ||= SchemaApi.new(self)
-    end
-
-  end
-end

data/lib/solrbee/response.rb

@@ -1,22 +0,0 @@
-module Solrbee
-  class Response < Base
-
-    coerce_key :schema,         Schema
-    coerce_key :fields,         Array[Field]
-    coerce_key :field,          Field
-    coerce_key :responseHeader, Header
-    coerce_key :fieldTypes,     Array[FieldType]
-    coerce_key :fieldType,      FieldType
-
-    def self.handle(http_response)
-      http_response.value # raises Net::HTTPServerException
-      parsed = JSON.parse(http_response.body, symbolize_names: true, object_class: Solrbee::Base)
-      new(parsed)
-    end
-
-    def status
-      responseHeader.status
-    end
-
-  end
-end

data/lib/solrbee/schema_api.rb

@@ -1,86 +0,0 @@
-module Solrbee
-  class SchemaApi
-
-    attr_reader :collection
-
-    def initialize(collection)
-      @collection = collection
-    end
-
-    def to_h
-      content
-    end
-
-    def name
-      response = Solrbee.get('%s/schema/name' % collection)
-      response.name
-    end
-
-    def version
-      response = Solrbee.get('%s/schema/version' % collection)
-      response.version
-    end
-
-    def content
-      response = Solrbee.get('%s/schema' % collection)
-      response.schema
-    end
-
-    def fields(show_defaults: true)
-      response = Solrbee.get('%s/schema/fields?showDefaults=%s' % [collection, show_defaults])
-      response.fields
-    end
-
-    def field(field_name, show_defaults: true)
-      response = Solrbee.get('%s/schema/fields/%s?showDefaults=%s' % [collection, field_name, show_defaults])
-      response.field
-    end
-
-    def unique_key
-      response = Solrbee.get('%s/schema/uniquekey' % collection)
-      response.uniqueKey
-    end
-
-    def field_types(show_defaults: true)
-      response = Solrbee.get('%s/schema/fieldtypes?showDefaults=%s' % [collection, show_defaults])
-      response.fieldTypes
-    end
-
-    def field_type(field_name, show_defaults: true)
-      response = Solrbee.get('%s/schema/fieldtypes/%s?showDefaults=%s' % [collection, field_name, show_defaults])
-      response.fieldType
-    end
-
-    def field_names
-      fields.map(&:name)
-    end
-
-    def field_type_names
-      field_types.map(&:name)
-    end
-
-    def index(*docs, commit: true)
-      Solrbee.post('%s/update/json/docs?commit=%s' % [collection, commit], docs)
-    end
-
-    def add_field(field)
-      data = { "add-field" => field }
-      Solrbee.post('%s/schema' % collection, data)
-    end
-
-    def delete_field(field)
-      data = {
-        "delete-field" => {
-          "name" => field.name
-        }
-      }
-      Solrbee.post('%s/schema' % collection, data)
-    end
-
-    def replace_field(field)
-      data = { "replace-field" => field }
-      Solrbee.post('%s/schema' % collection, data)
-    end
-
-  end
-end