marklogic 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ddad5d982939d5693742db6623e91f7d557de379
-  data.tar.gz: 77e4174a64065444b8a58408eeddfc3d7d23c879
+  metadata.gz: a18a7c658e56f1ad3d394de8120246955b35c90d
+  data.tar.gz: 5380d8f65f962dec8c958be996194ece2724e35e
 SHA512:
-  metadata.gz: ba515d4ec20bb8c9f22ff93749d2df9542d5803eb9622d7dea000de4edb6085c90da2a2cd4ecb8f24c0d1c2c2d7efdef62dcd1b56ab9f91bebc3dd5d99d25f30
-  data.tar.gz: 162f3f432d888b4ae47357c4345b68069a761b4c6fc14498922ecdbf4138d60c933c2a665602008eaa07a5ea33a9b0fd56dffd6864677f9961e3dd3d0acff16b
+  metadata.gz: 465d4b95d2cb7b89f62b29e9462d4f44f029fc45d2a73132b117aa1bbf326d9e05bb11094cc7701c073a22fa6ff05628655c0dec7fa6751c08fcd654837b9424
+  data.tar.gz: 01c5b4435cc0f35ed3d6c1a0e93f159b4b7c41f3ecac97d75f5db111783c0363025ddb6f0bddf48a6be0b3c6afb5ad51ffcd25fcdf3c583e79a69f49ebf5e9ec

data/.ruby-version

@@ -1 +1 @@
-2.2.0
+2.2.2

data/Rakefile

@@ -1,6 +1,26 @@
 require "bundler/gem_tasks"
 
 require 'rspec/core/rake_task'
+require File.expand_path('../lib/marklogic/version', __FILE__)
+
 RSpec::Core::RakeTask.new
 
 task :default => :spec
+
+desc 'Builds the gem'
+task :build do
+  sh "gem build marklogic.gemspec"
+end
+
+desc 'Builds and installs the gem'
+task :install => :build do
+  sh "gem install marklogic-#{MarkLogic::Version}"
+end
+
+desc 'Tags version, pushes to remote, and pushes gem'
+task :release => :build do
+  sh "git tag v#{MarkMapper::Version}"
+  sh "git push origin master"
+  sh "git push origin v#{MarkLogic::Version}"
+  sh "gem push marklogic-#{MarkLogic::Version}.gem"
+end

data/lib/marklogic.rb

@@ -1,3 +1,4 @@
+require 'oj'
 require 'active_support'
 require 'active_support/core_ext/object'
 require 'active_support/core_ext/string/inflections'
@@ -6,6 +7,7 @@ require "marklogic/consts"
 require 'marklogic/queries'
 require 'marklogic/exceptions'
 require 'marklogic/object_id'
+require 'marklogic/multipart_parser'
 
 module MarkLogic
   autoload :Application, 'marklogic/application'

data/lib/marklogic/app_server.rb

@@ -26,6 +26,31 @@ module MarkLogic
       }
     end
 
+    def self.load(server_name, group_name = "Default")
+      app_server = AppServer.new(server_name, 0, 'http', group_name)
+      app_server.load
+      app_server
+    end
+
+    def load
+      resp = manage_connection.get(%Q{/manage/v2/servers/#{server_name}/properties?group-id=#{group_name}&format=json})
+      if resp.code.to_i == 200
+        options = Oj.load(resp.body)
+        options.each do |key, value|
+          self[key] = value
+        end
+      end
+    end
+
+    def inspect
+      as_nice_string = [
+        "server_name: #{server_name}",
+        "server_type: #{server_type}",
+        "port: #{self['port']}"
+      ].join(",")
+      "#<#{self.class}#{as_nice_string}>"
+    end
+
     def []=(key, value)
       @options[key] = value
     end

data/lib/marklogic/application.rb

@@ -2,7 +2,7 @@ module MarkLogic
   class Application
     include MarkLogic::Persistence
 
-    attr_accessor :app_name
+    attr_accessor :app_name, :port
 
     def initialize(app_name, options = {})
       @app_name = app_name
@@ -157,10 +157,16 @@ module MarkLogic
       end
     end
 
+    def modules_databases
+      app_servers.values.map do |app_server|
+        databases[app_server['modules-database']]
+      end
+    end
+
     def database(name)
-      database = MarkLogic::Database.new(name)
+      database = MarkLogic::Database.new(name, self.connection)
       yield(database) if block_given?
-      logger.info("#{__LINE__}: db_name: #{name}")
+      database.application = self
       databases[name] = database
     end
 
@@ -170,8 +176,73 @@ module MarkLogic
       app_servers[name] = app_server
     end
 
+    def inspect
+      as_nice_string = [
+        " app_name: #{app_name.inspect}",
+        " port: #{port.inspect}",
+        " app_servers: #{app_servers.values.each { |app_server| app_server.inspect }}"
+      ].join(",")
+      "#<#{self.class}#{as_nice_string}>"
+    end
+
+    def self.load(app_name, options = {})
+      app = Application.new(app_name, options)
+      app.load
+      app
+    end
+
+    def load
+      app_servers[app_name] = MarkLogic::AppServer.load(app_name)
+      @port = app_servers[app_name]['port']
+      load_databases
+      build_indexes
+    end
+
     private
 
+    def load_database(db_name)
+      db = MarkLogic::Database.load(db_name, self.connection)
+      db.application = self
+      databases[db_name] = db
+
+      db['forest'].each do |forest_name|
+        forests[forest_name] = MarkLogic::Forest.load(forest_name, nil, self.connection) unless forests.has_key?(forest_name)
+        forests[forest_name].database = db
+      end
+    end
+
+    def load_databases
+      app_servers.each_value do |app_server|
+        db_name = app_server['content-database']
+        load_database(db_name) unless databases.has_key?(db_name)
+
+        modules_db_name = app_server['modules-database']
+        load_database(modules_db_name) unless databases.has_key?(modules_db_name)
+      end
+
+      triggers_database = nil
+      schema_database = nil
+      databases.each_value do |database|
+        if database.has_key?('triggers-database')
+          triggers_database = database['triggers-database']
+        end
+
+        if database.has_key?('schema-database')
+          schema_database = database['schema-database']
+        end
+      end
+
+      if triggers_database && !databases.has_key?(triggers_database)
+        load_database(triggers_database)
+        # databases[triggers_database] = MarkLogic::Database.new(triggers_database, self.connection)
+      end
+
+      if schema_database && !databases.has_key?(schema_database)
+        load_database(schema_database)
+        # databases[schema_database] = MarkLogic::Database.new(schema_database, self.connection)
+      end
+    end
+
     def indexes
       @indexes ||= {}
     end
@@ -213,7 +284,6 @@ module MarkLogic
       schema_database = nil
       databases.each_value do |database|
         if database.has_key?('triggers-database')
-          logger.info "has triggers: [#{database['triggers-database']}]"
           triggers_database = database['triggers-database']
         end
 
@@ -222,11 +292,11 @@ module MarkLogic
         end
       end
 
-      if triggers_database and !databases.has_key?(triggers_database)
+      if triggers_database && !databases.has_key?(triggers_database)
         databases[triggers_database] = MarkLogic::Database.new(triggers_database, self.connection)
       end
 
-      if schema_database and !databases.has_key?(schema_database)
+      if schema_database && !databases.has_key?(schema_database)
         databases[schema_database] = MarkLogic::Database.new(schema_database, self.connection)
       end
     end

data/lib/marklogic/collection.rb

@@ -21,7 +21,7 @@ module MarkLogic
       url = "/v1/documents?uri=#{gen_uri(id)}&format=json"
       response = @database.connection.get(url)
       raise Exception.new("Invalid response: #{response.code.to_i}, #{response.body}") unless response.code.to_i == 200
-      JSON.parse(response.body)
+      Oj.load(response.body)
     end
 
     def save(doc)
@@ -217,6 +217,18 @@ module MarkLogic
       end
     end
 
+    def to_s
+      %Q{collection: #{collection}}
+    end
+
+    def inspect
+      as_nice_string = [
+        " collection: #{collection.inspect}",
+        " database: #{database.database_name.inspect}"
+      ].join(",")
+      "#<#{self.class}#{as_nice_string}>"
+    end
+
     private
 
     def doc_uri(doc)

data/lib/marklogic/connection.rb

@@ -2,6 +2,7 @@ require 'net/http'
 require 'date'
 require 'json'
 require 'digest'
+require 'net/http/persistent'
 
 module Net
   module HTTPHeader
@@ -54,6 +55,11 @@ module Net
 
       @header['Authorization'] = ["Basic #{encoded}"]
     end
+
+    # diable header capitalization for a performance gain
+    def capitalize(name)
+      name
+    end
   end
 end
 
@@ -61,6 +67,14 @@ module MarkLogic
   class Connection
     include MarkLogic::Loggable
 
+    NEWLINE_SPLITTER = Regexp.new("\r\n", Regexp::MULTILINE)
+    DOUBLE_NEWLINE_SPLITTER = Regexp.new("\r\n\r\n", Regexp::MULTILINE)
+    START_BOUNDARY_REGEX = Regexp.new("^[\r\n]+--[^-].+?[\r\n]+", Regexp::MULTILINE)
+    END_BOUNDARY_REGEX = Regexp.new("[\r\n]+--[^-]+--[\r\n]+$", Regexp::MULTILINE)
+    BOUNDARY_SPLITTER_REGEX = Regexp.new(%Q{[\r\n]+--[^-]+[\r\n]+}, Regexp::MULTILINE)
+    CONTENT_TYPE_REGEX = /Content-Type:\s+(.*)$/
+    PRIMITIVE_REGEX = /X-Primitive:\s+(.*)$/
+
     attr_accessor :admin, :manage, :app_services, :username, :password, :host, :port, :request_retries
 
     def self.configure(options = {})
@@ -118,15 +132,19 @@ module MarkLogic
       @username = username || self.class.default_user
       @password = password || self.class.default_password
       @request_retries = options[:request_retries] || 3
-      @http = Net::HTTP.new(host, port)
+      @http = Net::HTTP::Persistent.new 'marklogic'
     end
 
     def run_query(query, type = "javascript", options = {})
-      params = {
-        type.to_sym => query
+      # manually building the params yielded a performance improvement
+      params = %Q{#{type}=#{URI.encode_www_form_component(query)}}
+      params += %Q{&dbname=#{options[:db]}} if options[:db]
+
+      headers = {
+        'content-type' => 'application/x-www-form-urlencoded'
       }
-      params[:dbname] = options[:db] if options[:db]
-      response = post('/eval', params)
+      response = request('/eval', 'post', headers, params)
+
         # :xquery => options[:query],
         # :locale => LOCALE,
         # :tzoffset => "-18000",
@@ -164,14 +182,14 @@ module MarkLogic
     end
 
     def wait_for_restart(body)
-      json = JSON.parse(body)
+      json = Oj.load(body)
       ts_value = json["restart"]["last-startup"][0]["value"]
       timestamp = DateTime.iso8601(ts_value).to_time
       new_timestamp = timestamp
 
       code = nil
       logger.debug "Waiting for restart"
-      until code == 200 and new_timestamp > timestamp
+      until code == 200 && new_timestamp > timestamp
         begin
           rr = get(%Q{/admin/v1/timestamp})
           code = rr.code.to_i
@@ -202,65 +220,61 @@ module MarkLogic
     end
 
     def split_multipart(response)
-      if response.read_body
-        body = response.body
+      body = response.body
 
-        if body.length == 0
-          response.body = nil
-          return
-        end
+      if body.nil? || body.length == 0
+        response.body = nil
+        return
+      end
+
+      content_type = response['Content-Type']
+      if (content_type && content_type.match(/multipart\/mixed.*/))
+        boundary = $1 if content_type =~ /^.*boundary=(.*)$/
 
-        content_type = response['Content-Type']
-        if (content_type and content_type.match(/multipart\/mixed.*/))
-          boundary = $1 if content_type =~ /^.*boundary=(.*)$/
-
-          body.sub!(Regexp.new("[\r\n]+--#{boundary}--[\r\n]+$", Regexp::MULTILINE), "")
-          body.sub!(Regexp.new("^[\r\n]+--#{boundary}.+?[\r\n]+", Regexp::MULTILINE), "")
-
-          values = []
-          body.split(Regexp.new(%Q{[\r\n]+--#{boundary}[\r\n]+}, Regexp::MULTILINE)).each do |item|
-            splits = item.split(/\r\n\r\n/m)
-            metas = splits[0]
-            raw_value = splits[1]
-
-            value_content_type = type = xpath = nil
-
-            metas.split(/\r\n/m).each do |meta|
-              if meta.match(/^Content-Type:.*/m)
-                value_content_type = $1 if meta =~ /Content-Type:\s+(.*)$/
-              elsif meta.match(/^X-Primitive:.*/)
-                type = $1 if meta =~ /X-Primitive:\s+(.*)$/
-              elsif meta.match(/^X-Path:.*/)
-                xpath = $1 if meta =~ /X-Path:\s+(.*)$/
-              end
+        body.sub!(END_BOUNDARY_REGEX, "")
+        body.sub!(START_BOUNDARY_REGEX, "")
+
+        values = []
+        body.split(BOUNDARY_SPLITTER_REGEX).each do |item|
+          splits = item.split(DOUBLE_NEWLINE_SPLITTER)
+          metas = splits[0]
+          raw_value = splits[1]
+
+          value_content_type = type = nil
+
+          metas.split(NEWLINE_SPLITTER).each do |meta|
+            if meta =~ CONTENT_TYPE_REGEX
+              value_content_type = $1
+            elsif meta =~ PRIMITIVE_REGEX
+              type = $1
             end
+          end
 
-            if (value_content_type == "application/json") then
-              value = JSON.parse(raw_value)
+          if (value_content_type == "application/json") then
+            value = Oj.load(raw_value)
+          else
+            case type
+            when "integer"
+              value = raw_value.to_i
+            when "boolean"
+              value = raw_value == "true"
+            when "decimal"
+              value = raw_value.to_f
             else
-              case type
-              when "integer"
-                value = raw_value.to_i
-              when "boolean"
-                value = raw_value == "true"
-              when "decimal"
-                value = raw_value.to_f
-              else
-                value = raw_value
-              end
+              value = raw_value
             end
-            values.push(value)
           end
+          values.push(value)
+        end
 
-          if (values.length == 1)
-            values = values[0]
-          end
-          output = values
-        else
-          output = body
+        if (values.length == 1)
+          values = values[0]
         end
-        response.body = output
+        output = values
+      else
+        output = body
       end
+      response.body = output
     end
 
     def request(url, verb = 'get', headers = {}, body = nil, params = nil)
@@ -281,12 +295,20 @@ module MarkLogic
         request.digest_auth(@username, @password, @auth)
       end
 
-      request.set_form_data(params) if (params)
-      request.body = body if (body)
+      if params
+        # query = URI.encode_www_form(params)
+        # query.gsub!(/&/, sep) if sep != '&'
+        # self.body = query
+        # request['content-type'] = 'application/x-www-form-urlencoded'
+        request.set_form_data(params) if (params)
+      elsif body
+        request.body = body if (body)
+      end
 
-      response = @http.request request
+      full_url = URI("http://#{@host}:#{@port}#{url}")
+      response = @http.request full_url, request
 
-      if (response.code.to_i == 401 and @username and @password)
+      if (response.code.to_i == 401 && @username && @password)
         auth_method = $1.downcase if response['www-authenticate'] =~ /^(\w+) (.*)/
         if (auth_method == "basic")
           request.basic_auth(@username, @password)
@@ -294,7 +316,7 @@ module MarkLogic
           @auth = request.create_digest_auth(@username, @password, response)
         end
 
-        response = @http.request request
+        response = @http.request full_url, request
       end
 
       # puts("#{response.code} : #{verb.upcase} => ://#{@host}:#{@port}#{url} :: #{body} #{params}")

data/lib/marklogic/cursor.rb

@@ -155,7 +155,7 @@ module MarkLogic
     end
 
     def has_sort?
-      @options.has_key?(:sort) or @options.has_key?(:order)
+      @options.has_key?(:sort) || @options.has_key?(:order)
     end
 
     def query
@@ -170,7 +170,7 @@ module MarkLogic
 
       sorters.map do |sorter|
         name = sorter[0].to_s
-        direction = (sorter[1] and (sorter[1] == -1)) ? "descending" : "ascending"
+        direction = (sorter[1] && (sorter[1] == -1)) ? "descending" : "ascending"
 
 
         if @collection.database.has_range_index?(name)
@@ -197,7 +197,7 @@ module MarkLogic
 
       sorters.map do |sorter|
         name = sorter[0].to_s
-        direction = (sorter[1] and (sorter[1] == -1)) ? "descending" : "ascending"
+        direction = (sorter[1] && (sorter[1] == -1)) ? "descending" : "ascending"
 
         unless @collection.database.has_range_index?(name)
           raise MissingIndexError.new("Missing index on #{name}")

data/lib/marklogic/database.rb

@@ -31,6 +31,29 @@ module MarkLogic
       reset_indexes
     end
 
+    def self.load(database_name, conn = nil)
+      db = Database.new(database_name, conn)
+      db.load
+      db
+    end
+
+    def load
+      resp = manage_connection.get(%Q{/manage/v2/databases/#{database_name}/properties?format=json})
+      if resp.code.to_i == 200
+        options = Oj.load(resp.body)
+        options.each do |key, value|
+          self[key] = value
+        end
+      end
+    end
+
+    def inspect
+      as_nice_string = @options.collect do |key, value|
+        " #{key}: #{value.inspect}"
+      end.sort.join(",")
+      "#<#{self.class}#{as_nice_string}>"
+    end
+
     def []=(key, value)
       @options[key] = value
     end
@@ -121,7 +144,7 @@ module MarkLogic
       response = manage_connection.get(%Q{/manage/v2/databases/#{database_name}/properties?format=json})
       raise Exception.new("Invalid response: #{response.code.to_i}: #{response.body}") if (response.code.to_i != 200)
 
-      props = JSON.parse(response.body)
+      props = Oj.load(response.body)
 
       INDEX_KEYS.each do |key|
         if props[key]
@@ -131,7 +154,7 @@ module MarkLogic
             logger.debug "#{database_name}: #{local} != #{remote}"
             return true
           end
-        elsif @options.has_key?(key) and @options[key] != []
+        elsif @options.has_key?(key) && @options[key] != []
           logger.debug "#{database_name}: #{key} is not on the remote end"
           return true
         end
@@ -199,7 +222,12 @@ module MarkLogic
     end
 
     def collections()
-      return connection.run_query('cts:collections()', "xquery").body || []
+      res = connection.run_query('cts:collections()', "xquery")
+      if res.code.to_i == 200
+        return res.body || []
+      else
+        raise MissingCollectionLexiconError.new if res.body =~ /XDMP-COLLXCNNOTFOUND/
+      end
     end
   end
 end

data/lib/marklogic/exceptions.rb

@@ -2,4 +2,5 @@
 module MarkLogic
   class MissingIndexError < StandardError; end
   class SearchError < StandardError; end
+  class MissingCollectionLexiconError < StandardError; end
 end

data/lib/marklogic/forest.rb

@@ -13,6 +13,22 @@ module MarkLogic
       }
     end
 
+    def self.load(forest_name, host_name = nil, conn = nil)
+      db = Forest.new(forest_name, host_name, conn)
+      db.load
+      db
+    end
+
+    def load
+      resp = manage_connection.get(%Q{/manage/v2/forests/#{forest_name}/properties?format=json})
+      if resp.code.to_i == 200
+        options = Oj.load(resp.body)
+        options.each do |key, value|
+          self[key] = value
+        end
+      end
+    end
+
     def []=(key, value)
       @options[key] = value
     end

data/lib/marklogic/persistence.rb

@@ -1,6 +1,25 @@
 module MarkLogic
   module Persistence
     include MarkLogic::Loggable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def manage_connection=(manage_conn)
+        @@manage_connection = manage_conn if manage_conn
+      end
+
+      def manage_connection
+        @@manage_connection ||= MarkLogic::Connection.manage_connection
+      end
+
+      def admin_connection=(admin_conn)
+        @@admin_connection = admin_conn if admin_conn
+      end
+
+      def admin_connection
+        @@admin_connection ||= MarkLogic::Connection.admin_connection
+      end
+    end
 
     def connection=(conn)
       @connection = conn if conn

data/lib/marklogic/version.rb

@@ -1,3 +1,3 @@
 module Marklogic
-  VERSION = "0.0.1"
+  VERSION = "0.0.3"
 end

data/marklogic.gemspec

@@ -19,5 +19,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
   spec.has_rdoc        = 'yard'
 
+  spec.add_runtime_dependency 'net-http-persistent', '~> 2.9', '>= 2.9.4'
+  spec.add_runtime_dependency 'oj', '~> 2.12', '>= 2.12.2'
   spec.add_runtime_dependency 'activesupport', '~> 4.2', '>= 4.2.0'
 end

data/spec/marklogic/app_server_spec.rb

@@ -18,4 +18,14 @@ describe MarkLogic::AppServer do
     end
 
   end
+
+  describe "load" do
+    it "should load an existing config from the server" do
+      app = MarkLogic::AppServer.load('App-Services')
+      expect(app['server-name']).to eq('App-Services')
+      expect(app['content-database']).to eq('Documents')
+      expect(app['modules-database']).to eq('Modules')
+      expect(app['port']).to eq(8000)
+    end
+  end
 end

data/spec/marklogic/application_spec.rb

@@ -102,4 +102,18 @@ describe MarkLogic::Application do
       expect(@a).to be_stale
     end
   end
+
+  describe "load" do
+    it "should load from existing config" do
+      app = MarkLogic::Application.load('App-Services', connection: CONNECTION)
+      expect(app.port).to eq(8000)
+      expect(app.app_servers.count).to eq(1)
+      expect(app.app_servers['App-Services'].server_name).to eq('App-Services')
+      expect(app.content_databases.count).to eq(1)
+      expect(app.content_databases.first.database_name).to eq('Documents')
+      expect(app.content_databases.first['forest']).to eq(['Documents'])
+      expect(app.modules_databases.count).to eq(1)
+      expect(app.modules_databases.first.database_name).to eq('Modules')
+    end
+  end
 end

data/spec/marklogic/connection_spec.rb

@@ -104,6 +104,14 @@ describe MarkLogic::Connection do
     it "should split properly when a crazy object is returned" do
       expect(@b.run_query(%Q{x = { stuff: [1, 2, 3], junk: false}; x}).body).to eq({"stuff" => [1, 2, 3], "junk" => false})
     end
+
+    it "should handle url unencoded stuff" do
+      expect(@b.run_query(%Q{
+        let $x := "Hi & stuff"
+        return
+          $x
+      }, 'xquery').body).to eq("Hi & stuff")
+    end
   end
 
   describe "#digest" do

metadata

@@ -1,15 +1,55 @@
 --- !ruby/object:Gem::Specification
 name: marklogic
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
 - Paxton Hare
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-14 00:00:00.000000000 Z
+date: 2015-04-16 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-http-persistent
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.9.4
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.9.4
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.12.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.12'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.12.2
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -145,7 +185,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 4
 summary: A Ruby Driver for MarkLogic