uri_service 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3e2701d3c51e490b0ed59b0d69c0b4f4d0606fab
-  data.tar.gz: 345a4844c537e35bbcffe25a87627b24e6dc870e
+  metadata.gz: ea6881c7a5b2ef53d0c1ac66821ee4ea30820f46
+  data.tar.gz: 56cc8b75b8756a3084a018e5d1cbe26b2fe8632e
 SHA512:
-  metadata.gz: d349b930a9f9b30148b58c56430bcb4095ae1f410b3cc9491b614037ffdeedd9b8f39acb901e3178660d03ea11ab2f48e7ed4163932ae46645661dbbdd919f85
-  data.tar.gz: fb7f23d7561b83092053599962b70ebea5fbf431318d7966e910123f1c9c4c135ef190b7b7764ae0e1f3964fe8a8ed12eeefa5f9d58dc345ad3b3f110e71dbaa
+  metadata.gz: 8ba7fd8de87e27a5d32f1c7ac4afebb58e05b0226adc7ddbcc9b1cc1f7783e835673c4c062cfecd554f51d7b7ae7a750d4f13740cece73f5d8c9bef62b8199cb
+  data.tar.gz: c3e4f1f75f2083fbd9050eaaf7367c59a6afb36f1f1a9b01714d15710bd558d2d86a5e4108d99deea3db5b1da7fbe1eb09315d8f83d152381d3d5d8ed027b13d

data/lib/uri_service.rb

@@ -1,4 +1,4 @@
-require 'active_support/inflector'
+require 'active_support/all'
 require 'connection_pool'
 require 'rsolr'
 require 'sequel'

data/lib/uri_service/client.rb

@@ -4,6 +4,7 @@ class UriService::Client
   
   ALPHANUMERIC_UNDERSCORE_KEY_REGEX = /\A[a-z]+[a-z0-9_]*\z/
   VALID_URI_REGEX = /\A#{URI::regexp(['http', 'https'])}\z/
+  CORE_FIELD_NAMES = ['uri', 'vocabulary_string_key', 'value', 'is_local']
   
   def initialize(opts)
     raise UriService::InvalidOptsError, "Must supply opts['local_uri_base'] to initialize method." if opts['local_uri_base'].nil?
@@ -92,6 +93,7 @@ class UriService::Client
   
   def create_vocabulary(string_key, display_label)
     if string_key.to_s == 'all'
+      # Note: There isn't currently a use case for searching across 'all' vocabularies, but I'm leaving this restriction as a placeholder in case that changes.
       raise UriService::InvalidVocabularyStringKeyError, 'The value "all" is a reserved word and cannot be used as the string_key value for a vocabulary.'
     end
     unless string_key =~ ALPHANUMERIC_UNDERSCORE_KEY_REGEX
@@ -110,7 +112,7 @@ class UriService::Client
   
   # Creates a new term.
   def create_term(vocabulary_string_key, value, term_uri, additional_fields={})
-    self.create_term_impl(vocabulary_string_key, value, term_uri, additional_fields, false)
+    return self.create_term_impl(vocabulary_string_key, value, term_uri, additional_fields, false)
   end
   
   # Creates a new local term, auto-generating a URI
@@ -124,18 +126,19 @@ class UriService::Client
     # Getting a duplicate UUID from SecureRandom.uuid is EXTREMELY unlikely, but we'll account for it just in case (by making a few more attempts).
     5.times {
       begin
-        self.create_term_impl(vocabulary_string_key, value, term_uri, additional_fields, true)
-        break
+        return self.create_term_impl(vocabulary_string_key, value, term_uri, additional_fields, true)
       rescue UriService::ExistingUriError
-        if defined?(Rails)
-          Rails.logger.error "UriService generated a duplicate random UUID (via SecureRandom.uuid) and will now attempt to create another.  This type of problem is EXTREMELY rare."
-        end
+        raise UriService::ExistingUriError, "UriService generated a duplicate random UUID (via SecureRandom.uuid) and will now attempt to create another.  This type of problem is EXTREMELY rare."
       end
     }
+    
+    return nil
   end
   
   def create_term_impl(vocabulary_string_key, value, term_uri, additional_fields, is_local)
     
+    additional_fields.stringify_keys!
+    
     #Ensure that vocabulary with vocabulary_string_key exists
     if self.find_vocabulary(vocabulary_string_key).nil?
       raise UriService::NonExistentVocabularyError, "There is no vocabulary with string key: " + vocabulary_string_key
@@ -155,46 +158,83 @@ class UriService::Client
           vocabulary_string_key: vocabulary_string_key,
           additional_fields: JSON.generate(additional_fields)
         )
-        
-        self.send_term_to_solr(@db[UriService::TERMS].where(uri: term_uri).first)
-        
+        send_term_to_solr(vocabulary_string_key, value, term_uri, additional_fields, is_local)
       rescue Sequel::UniqueConstraintViolation
         raise UriService::ExistingUriError, "A term already exists with uri: " + term_uri + " (conflict found via uri_hash check)"
       end
     end
     
+    return generate_frozen_term_hash(vocabulary_string_key, value, term_uri, additional_fields, is_local)
   end
   
-  def term_db_row_to_solr_doc(term_row_data_from_db)
+  def generate_frozen_term_hash(vocabulary_string_key, value, uri, additional_fields, is_local)
+    hash_to_return = {}
+    hash_to_return['uri'] = uri
+    hash_to_return['value'] = value
+    hash_to_return['is_local'] = is_local
+    hash_to_return['vocabulary_string_key'] = vocabulary_string_key
+    
+    additional_fields.each do |key, val|
+      hash_to_return[key] = val
+    end
+    
+    hash_to_return.freeze # To make this a read-only hash
+    
+    return hash_to_return
+  end
+  
+  def create_term_solr_doc(vocabulary_string_key, value, uri, additional_fields, is_local)
     doc = {}
-    doc['uri'] = term_row_data_from_db[:uri]
-    doc['value'] = term_row_data_from_db[:value]
-    doc['is_local_bsi'] = term_row_data_from_db[:is_local]
-    doc['vocabulary_string_key_ssi'] = term_row_data_from_db[:vocabulary_string_key]
-    JSON.parse(term_row_data_from_db[:additional_fields]).each do |key, val|
-      doc[key + '_ssi'] = val
+    doc['uri'] = uri
+    doc['value'] = value
+    doc['is_local'] = is_local
+    doc['vocabulary_string_key'] = vocabulary_string_key
+    
+    additional_fields.each do |key, val|
+      doc[key + self.class.get_solr_suffix_for_object(val)] = val
     end
     
     return doc
   end
   
+  def self.get_solr_suffix_for_object(obj)
+    if obj.is_a?(Array)
+      # Note boolean arrays aren't supported because they don't seem useful in this context
+      if obj[0].is_a?(Fixnum)
+        return '_isim'
+      else
+        # Treat like a string array
+        return '_ssim'
+      end
+    else
+      if obj.is_a?(String)
+        return '_ssi'
+      elsif obj.is_a?(TrueClass) || obj.is_a?(FalseClass)
+        return '_bsi'
+      elsif obj.is_a?(Fixnum)
+        return '_isi'
+      else
+        raise UriService::UnsupportedObjectTypeError, "Unable to determine solr suffix for unsupported object type."
+      end
+    end
+  end
+  
   # Index the DB row term data into solr
-  def send_term_to_solr(term_row_data_from_db, commit=true)
-    
+  def send_term_to_solr(vocabulary_string_key, value, term_uri, additional_fields, is_local, commit=true)
+    doc = create_term_solr_doc(vocabulary_string_key, value, term_uri, additional_fields, is_local)
     @rsolr_pool.with do |rsolr|
-      rsolr.add(term_db_row_to_solr_doc(term_row_data_from_db))
+      rsolr.add(doc)
       rsolr.commit if commit
     end
   end
   
   # Validates additional_fields and verifies that no reserved words are supplied
   def validate_additional_fields(additional_fields)
-    reserved_keys = ['is_local', 'uri', 'value', 'vocabulary_string_key']
     additional_fields.each do |key, value|
-      if reserved_keys.include?(key.to_s)
+      if CORE_FIELD_NAMES.include?(key.to_s)
         raise UriService::InvalidAdditionalFieldKeyError, "Cannot supply the key \"#{key.to_s}\" as an additional field because it is a reserved key."
       end
-      unless key =~ ALPHANUMERIC_UNDERSCORE_KEY_REGEX
+      unless key.to_s =~ ALPHANUMERIC_UNDERSCORE_KEY_REGEX
         raise UriService::InvalidAdditionalFieldKeyError, "Invalid key (can only include lower case letters, numbers or underscores, but cannot start with an underscore): " + key
       end
     end
@@ -212,37 +252,47 @@ class UriService::Client
     UriService.client.rsolr_pool.with do |rsolr|
       response = rsolr.get('select', params: { :q => '*:*', :fq => 'uri:' + UriService.solr_escape(uri) })
       if response['response']['numFound'] == 1
-        return term_solr_doc_to_term_hash(response['response']['docs'].first)
+        return term_solr_doc_to_frozen_term_hash(response['response']['docs'].first)
       end
     end
     return nil
   end
   
-  def term_solr_doc_to_term_hash(term_solr_doc)
-    term_hash = {}
-    term_solr_doc.each do |key, value|
-      next if ['_version_', 'timestamp', 'score'].include?(key) # Skip certain automatically added fields that we don't care about
-      term_hash[key.gsub(/_[^_]+$/, '')] = value # Remove trailing '_si', '_bi', etc. if present
+  def term_solr_doc_to_frozen_term_hash(term_solr_doc)
+    
+    uri = term_solr_doc.delete('uri')
+    vocabulary_string_key = term_solr_doc.delete('vocabulary_string_key')
+    value = term_solr_doc.delete('value')
+    is_local = term_solr_doc.delete('is_local')
+    additional_fields = {}
+    
+    # Iterate through remaining keys and put them in additional_fields after removing suffixes
+    term_solr_doc.each do |key, val|
+      # Skip certain automatically added fields that aren't part of the term_hash
+      next if ['_version_', 'timestamp', 'score'].include?(key)
+      
+      # Remove trailing '_si', '_bi', etc. if present for solr-suffixed fields
+      additional_fields[key.gsub(/_[^_]+$/, '')] = val
     end
-    return term_hash
+    
+    return generate_frozen_term_hash(vocabulary_string_key, value, uri, additional_fields, is_local)
   end
   
-  def find_terms_by_query(vocabulary_string_key, value_query)
-    
-    return [] if value_query.empty?
-    
+  def find_terms_by_query(vocabulary_string_key, value_query, limit=10, start=0)
     terms_to_return = []
     UriService.client.rsolr_pool.with do |rsolr|
       
       solr_params = {
-        :q => UriService.solr_escape(value_query),
-        :fq => 'vocabulary_string_key_ssi:' + UriService.solr_escape(vocabulary_string_key)
+        :q => value_query == '' ? '*' : UriService.solr_escape(value_query),
+        :fq => 'vocabulary_string_key:' + UriService.solr_escape(vocabulary_string_key),
+        :rows => limit,
+        :start => start
       }
       
       response = rsolr.get('suggest', params: solr_params)
       if response['response']['numFound'] > 0
         response['response']['docs'].each do |doc|
-          terms_to_return << term_solr_doc_to_term_hash(doc)
+          terms_to_return << term_solr_doc_to_frozen_term_hash(doc)
         end
       end
     end
@@ -280,39 +330,32 @@ class UriService::Client
     end
   end
   
-  def update_term_value(term_uri, value)
-    self.update_term_impl(term_uri, value, {}, true)
-  end
-  
-  def update_term_additional_fields(term_uri, additional_fields, merge=false)
-    self.update_term_impl(term_uri, nil, additional_fields, merge)
-  end
-  
-  def update_term_impl(term_uri, value, additional_fields, merge_additional_fields)
-    
+  # opts format: {:value => 'new value', :additional_fields => {'key' => 'value'}}
+  def update_term(term_uri, opts, merge_additional_fields=true)
     dataset = @db[UriService::TERMS].where(uri: term_uri)
     raise UriService::NonExistentUriError, "No term found with uri: " + term_uri if dataset.count == 0
-    validate_additional_fields(additional_fields)
       
-    term = dataset.first
-    term_additional_fields = term['additional_fields'].nil? ? {} : JSON.parse(term['additional_fields'])
+    term_db_row = dataset.first
     
-    if merge_additional_fields
-      term_additional_fields.merge!(additional_fields)
-      term_additional_fields.delete_if { |k, v| v.nil? } # Delete nil values. This is a way to clear data in additional_fields.
-    else
-      term_additional_fields = additional_fields
-    end
+    new_value = opts[:value] || term_db_row[:value]
+    new_additional_fields = term_db_row[:additional_fields].nil? ? {} : JSON.parse(term_db_row[:additional_fields])
     
-    new_data = {}
-    new_data[:value] = value unless value.nil?
-    new_data[:additional_fields] = JSON.generate(term_additional_fields)
+    unless opts[:additional_fields].nil?
+      if merge_additional_fields
+        new_additional_fields.merge!(opts[:additional_fields])
+        new_additional_fields.delete_if { |k, v| v.nil? } # Delete nil values. This is a way to clear data in additional_fields.
+      else
+        new_additional_fields = opts[:additional_fields]
+      end
+    end
+    validate_additional_fields(new_additional_fields)
     
     @db.transaction do
-      dataset.update(new_data)
-      self.send_term_to_solr(@db[UriService::TERMS].where(uri: term_uri).first)
+      dataset.update(value: new_value, additional_fields: JSON.generate(new_additional_fields))
+      self.send_term_to_solr(term_db_row[:vocabulary_string_key], new_value, term_uri, new_additional_fields, term_db_row[:is_local])
     end
     
+    return generate_frozen_term_hash(term_db_row[:vocabulary_string_key], new_value, term_uri, new_additional_fields, term_db_row[:is_local])
   end
   
 end
@@ -325,3 +368,4 @@ class UriService::ExistingUriError < StandardError;end
 class UriService::ExistingVocabularyStringKeyError < StandardError;end
 class UriService::NonExistentUriError < StandardError;end
 class UriService::NonExistentVocabularyError < StandardError;end
+class UriService::UnsupportedObjectTypeError < StandardError;end

data/lib/uri_service/version.rb

@@ -1,6 +1,6 @@
 module UriService
   
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
   
   def self.version
     VERSION

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uri_service
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - Eric O'Hanlon
@@ -202,4 +202,3 @@ specification_version: 4
 summary: A service for registering local URIs and performing both local and remote
   URI lookups.
 test_files: []
-has_rdoc: