aspace_client 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ac953db47d3758e451a44a90dbdf570bad1c6d48
+  data.tar.gz: ee196ef429407e4f59cea5190865fd08a70b9c44
+SHA512:
+  metadata.gz: 191e45a120e291974d55e0000073acfd460e6162847d3c891c7b9422e98532b5ad8f8f7861410d4906191bb4d37fbbfe4833c05c5c45328f957152e8880cc1ec
+  data.tar.gz: 34076a7f7f5fb3d8c8d64ac578c66bde17f1c5887da65462af9b76855c94c5ed70bafcf145c4c7b58db9bd121d9fa6ed0015039cf8000705e00b7c5343a8426c

data/lib/aspace_client.rb

@@ -0,0 +1,15 @@
+$: << "#{File.dirname(__FILE__)}" unless $:.include? File.dirname(__FILE__)
+
+require "aspace_client/jsonmodel"
+require "aspace_client/asutils"
+require "aspace_client/memoryleak"
+require "aspace_client/client_enum_source"
+require "aspace_client/jsonmodel_i18n_mixin"
+require 'aspace_client/jsonmodel_client'
+require 'aspace_client/archivesspace_json_schema.rb'
+
+include JSONModel 
+
+module AspaceClient
+
+end

data/lib/aspace_client/archivesspace_json_schema.rb

@@ -0,0 +1,210 @@
+require 'date'
+
+# Add a new 'ifmissing' attribute which emits either an error or warning
+# depending on its value.
+class IfMissingAttribute < JSON::Schema::PropertiesAttribute
+
+  def self.validate(current_schema, data, fragments, validator, options = {})
+    super
+
+    if data.is_a?(Hash)
+      current_schema.schema['properties'].each do |property, property_schema|
+        if (property_schema['ifmissing'] && !data.has_key?(property))
+          message = nil
+
+          if property_schema['ifmissing'] == 'error'
+            message = "ERROR: The property '#{build_fragment(fragments)}' did not contain a required property of '#{property}'"
+          elsif property_schema['ifmissing'] == 'warn'
+            message = "WARNING: The property '#{build_fragment(fragments)}' did not contain a required property of '#{property}'"
+          end
+
+          if message
+            validation_error(message, fragments, current_schema, self, options[:record_errors])
+          end
+        end
+      end
+    end
+  end
+
+end
+
+
+class ArchivesSpaceTypeAttribute < JSON::Schema::TypeAttribute
+  extend JSONModel
+
+
+  # This reuse business is a bit of a pain.  The story here: JRuby backtraces
+  # are relatively expensive to create (relative to MRI Ruby), and JSON Schema
+  # validation is using exceptions as control flow here (sigh).  During imports,
+  # these validation error are hit a *lot*, and calculating a backtrace every
+  # time is expensive.
+  #
+  # So, we recycle.
+  def self.validation_error_for(expected_type, fragments, current_schema)
+    Thread.current[:json_validation_cached_errors] ||= {}
+    if !Thread.current[:json_validation_cached_errors][expected_type]
+      msg = "ERROR: Schema type mismatch.  Expected type: #{expected_type}"
+      Thread.current[:json_validation_cached_errors][expected_type] = JSON::Schema::ValidationError.new(msg, fragments, self, current_schema)
+    end
+
+    Thread.current[:json_validation_cached_errors][expected_type].fragments = fragments
+    Thread.current[:json_validation_cached_errors][expected_type]
+  end
+
+
+  def self.validate(current_schema, data, fragments, validator, options = {})
+    types = current_schema.schema['type']
+
+    if types == 'date'
+      begin
+        Date.parse(data)
+        return
+      rescue
+        validation_error("The property '#{build_fragment(fragments)}' was not " +
+                         "a well-formed date (value: #{data})",
+                         fragments, current_schema, self, options[:record_errors])
+      end
+    end
+
+
+    if types == 'object' && data.is_a?(Hash) && data.has_key?('ref') && current_schema.schema['subtype'] != 'ref'
+      # Provide a helpful warning about potentially missing subtype definitions
+      $stderr.puts("WARNING: Schema #{current_schema.inspect} appears to be missing a subtype definition of 'ref'")
+    end
+
+    # A bit crazy, sorry.  If we're being asked to validate a hash whose
+    # jsonmodel_type is marked against a different JSONModel schema, we're
+    # wasting our time.  Just stop straight away.
+    if (data.is_a?(Hash) && data["jsonmodel_type"]) &&
+        (current_schema.schema.is_a?(Hash) &&
+         "#{current_schema.schema["type"]}".include?("JSONModel") &&
+         !"#{current_schema.schema["type"]}".include?("JSONModel(:#{data['jsonmodel_type']})"))
+
+      raise validation_error_for(data['jsonmodel_type'], fragments, current_schema)
+    end
+
+    if JSONModel.parse_jsonmodel_ref(types)
+      (model, qualifier) = JSONModel.parse_jsonmodel_ref(types)
+
+      if qualifier == 'uri' || (qualifier == 'uri_or_object' && data.is_a?(String))
+        if JSONModel(model).id_for(data, {}, true).nil?
+          validation_error("The property '#{build_fragment(fragments)}' of type " +
+                           "#{data.class} did not match the following type: #{types} in schema",
+                           fragments, current_schema, self, options[:record_errors])
+        end
+
+      elsif qualifier == 'uri_or_object' || qualifier == 'object'
+        if data.is_a?(Hash)
+          data["jsonmodel_type"] ||= model.to_s
+
+          ValidatorCache.with_validator_for(JSONModel(model), data) do |subvalidator|
+            # Urk.  Validate the subrecord but pass in the fragments of the point
+            # we're at in the parent record.
+            subvalidator.instance_eval do
+              @base_schema.validate(@data, fragments, @validation_options)
+            end
+          end
+
+        else
+          validation_error("The property '#{build_fragment(fragments)}' of type " +
+                           "#{data.class} did not match the following type: #{types} in schema",
+                           fragments, current_schema, self, options[:record_errors])
+        end
+      end
+    else
+      super
+    end
+  end
+end
+
+
+class ArchivesSpaceSubTypeAttribute < JSON::Schema::TypeAttribute
+
+  def self.validate(current_schema, data, fragments, validator, options = {})
+    if data.is_a?(Hash) && !data.has_key?('ref')
+      message = "ERROR: The property '#{build_fragment(fragments)}' did not contain a required property of 'ref'"
+      validation_error(message, fragments, current_schema, self, options[:record_errors])
+    end
+  end
+
+end
+
+class ArchivesSpaceReadOnlyDynamicEnumAttribute < JSON::Schema::TypeAttribute; end
+
+class ArchivesSpaceDynamicEnumAttribute < JSON::Schema::TypeAttribute
+
+  def self.validate(current_schema, data, fragments, validator, options = {})
+    enum_name = current_schema.schema['dynamic_enum']
+
+    if !JSONModel.init_args[:enum_source].valid?(enum_name, data)
+      possible_values = JSONModel.init_args[:enum_source].values_for(enum_name)  
+      message = ("The property '#{build_fragment(fragments)}' value #{data.inspect} " +
+                 "did not match one of the following configurable values: #{possible_values.join(', ')}")
+     
+      if JSONModel.init_args[:enum_source].editable?(enum_name)
+        klass = self
+      else
+        klass = ArchivesSpaceReadOnlyDynamicEnumAttribute
+      end
+      
+      validation_error(message, fragments, current_schema, klass, options[:record_errors])
+    end
+  end
+
+end
+
+
+class ArchivesSpaceSchema < JSON::Schema::Validator
+  def initialize
+    super
+    extend_schema_definition("http://json-schema.org/draft-03/schema#")
+    @attributes["type"] = ArchivesSpaceTypeAttribute
+    @attributes["subtype"] = ArchivesSpaceSubTypeAttribute
+    @attributes["dynamic_enum"] = ArchivesSpaceDynamicEnumAttribute
+    @attributes["properties"] = IfMissingAttribute
+    @uri = URI.parse("http://www.archivesspace.org/archivesspace.json")
+  end
+
+
+  def already_failed?(fragments)
+    JSON::Validator.validation_errors.any? {|error|
+      error.fragments == fragments
+    }
+  end
+
+
+  def validate(current_schema, data, fragments, options = {})
+    super
+
+    # Run any custom validations if we've made it this far with no errors
+    if !already_failed?(fragments) && current_schema.schema.has_key?("validations")
+      current_schema.schema["validations"].each do |level_and_name|
+        level, name = level_and_name
+
+        errors = JSONModel::custom_validations[name].call(data)
+
+        errors.each do |error|
+          error_string = nil
+
+          if error.is_a? Symbol
+            error_string = "Validation error code: #{error}"
+          else
+            field, msg = error
+            prefix = level == :warning ? "Warning generated for" : "Validation failed for"
+            error_string = "#{prefix} '#{field}': #{msg}"
+
+          end
+
+          err = JSON::Schema::ValidationError.new(error_string,
+                                                  fragments,
+                                                  "custom_validation",
+                                                  current_schema)
+
+          JSON::Validator.validation_error(err)
+        end
+      end
+    end
+  end
+
+  JSON::Validator.register_validator(self.new)
+end

data/lib/aspace_client/asutils.rb

@@ -0,0 +1,142 @@
+require 'json'
+require 'tmpdir'
+require 'tempfile'
+
+module ASUtils
+
+  def self.keys_as_strings(hash)
+    result = {}
+
+    hash.each do |key, value|
+      result[key.to_s] = value.is_a?(Date) ? value.to_s : value 
+    end
+
+    result
+  end
+
+
+  def self.as_array(thing)
+    return [] if thing.nil?
+    thing.kind_of?(Array) ? thing : [thing]
+  end
+
+
+  def self.jsonmodels_to_hashes(elt)
+
+    if elt.is_a?(JSONModelType)
+      elt = elt.to_hash(:raw)
+    end
+
+    if elt.is_a?(Hash)
+      Hash[elt.map {|k, v| [k, self.jsonmodels_to_hashes(v)]}]
+    elsif elt.is_a?(Array)
+      elt.map {|v| self.jsonmodels_to_hashes(v)}
+    else
+      elt
+    end
+  end
+
+
+  def self.json_parse(s)
+    JSON.parse(s, :max_nesting => false, :create_additions => false)
+  end
+
+
+
+  def self.to_json(obj, opts = {})
+    if obj.respond_to?(:jsonize)
+      obj.jsonize(opts.merge(:max_nesting => false))
+    else
+      obj.to_json(opts.merge(:max_nesting => false))
+    end
+  end
+
+
+  def self.find_base_directory(root = nil)
+    [ File.join(*[File.dirname(__FILE__), "..", root].compact)].find {|dir|
+      Dir.exists?(dir)
+    }
+  end
+
+
+  def self.find_local_directories(base = nil, *plugins)
+    base_directory = self.find_base_directory
+    Array(plugins).map { |plugin| File.join(*[base_directory, "plugins", plugin, base].compact) }
+  end
+
+
+  def self.find_locales_directories(base = nil)
+    [File.join(*[self.find_base_directory("common"), "locales", base].compact)]
+  end
+
+
+  def self.extract_nested_strings(coll)
+    if coll.is_a?(Hash)
+      coll.values.map {|v| self.extract_nested_strings(v)}.flatten.compact
+    elsif coll.is_a?(Array)
+      coll.map {|v| self.extract_nested_strings(v)}.flatten.compact
+    else
+      coll
+    end
+  end
+
+  def self.dump_diagnostics(exception = nil)
+    diagnostics = self.get_diagnostics( exception ) 
+    tmp = File.join(Dir.tmpdir, "aspaue_diagnostic_#{Time.now.to_i}.txt")
+    File.open(tmp, "w") do |fh|
+      fh.write(JSON.pretty_generate(diagnostics))
+    end
+
+    msg = <<EOF
+A trace file has been written to the following location: #{tmp}
+
+This file contains information that will assist developers in diagnosing
+problems with your ArchivesSpace installation.  Please review the file's
+contents for sensitive information (such as passwords) that you might not
+want to share.
+EOF
+
+    $stderr.puts("=" * 72)
+    $stderr.puts(msg)
+    $stderr.puts("=" * 72)
+
+    raise exception if exception
+  end
+
+
+  # Recursively overlays hash2 onto hash 1
+  def self.deep_merge(hash1, hash2)
+    target = hash1.dup
+    hash2.keys.each do |key|
+      if hash2[key].is_a? Hash and hash1[key].is_a? Hash
+        target[key] = self.deep_merge(target[key], hash2[key])
+        next
+      end
+      target[key] = hash2[key]
+    end
+    target
+  end
+
+
+  def self.load_plugin_gems(context)
+    ASUtils.find_local_directories.each do |plugin|
+      gemfile = File.join(plugin, 'Gemfile')
+      if File.exists?(gemfile)
+        context.instance_eval(File.read(gemfile))
+      end
+    end
+  end
+
+
+  # Borrowed from: file activesupport/lib/active_support/core_ext/array/wrap.rb, line 36
+  def self.wrap(object)
+    if object.nil?
+      []
+    elsif object.respond_to?(:to_ary)
+      object.to_ary || [object]
+    else
+      [object]
+    end
+  end
+
+end

data/lib/aspace_client/client_enum_source.rb

@@ -0,0 +1,30 @@
+require "aspace_client/jsonmodel"
+require "aspace_client/memoryleak"
+
+class ClientEnumSource
+
+  def initialize
+    MemoryLeak::Resources.define(:enumerations, proc {
+                                   JSONModel::Client::EnumSource.fetch_enumerations
+                                 }, 300)
+  end
+
+
+  def valid?(name, value)
+    values_for(name).include?(value)
+  end
+  
+  def editable?(name)
+    MemoryLeak::Resources.get(:enumerations).fetch(name).editable?
+  end
+
+
+  def values_for(name)
+    MemoryLeak::Resources.get(:enumerations).fetch(name)
+  end
+  
+  def default_value_for(name)
+    MemoryLeak::Resources.get(:enumerations)[:defaults].fetch(name)
+  end
+
+end

data/lib/aspace_client/exceptions.rb

@@ -0,0 +1,15 @@
+class AccessDeniedException < StandardError
+end
+
+
+class ConflictException < StandardError
+  attr_reader :conflicts
+
+  def initialize(conflicts)
+    @conflicts = conflicts
+    super
+  end
+end
+
+class RecordNotFound < StandardError
+end

data/lib/aspace_client/json_schema_concurrency_fix.rb

@@ -0,0 +1,52 @@
+# Monkey patch against json-schema 1.0.12 to work around
+# https://github.com/hoxworth/json-schema/issues/24
+
+
+module JSON
+  class Validator
+
+    # Run a simple true/false validation of data against a schema
+    def validate()
+      begin
+        Validator.clear_errors
+        @base_schema.validate(@data,[],@validation_options)
+        Validator.clear_cache
+        if @options[:errors_as_objects]
+          self.class.validation_errors.map{|e| e.to_hash}
+        else
+          self.class.validation_errors.map{|e| e.to_string}
+        end
+      rescue JSON::Schema::ValidationError
+        Validator.clear_cache
+        raise $!
+      end
+    end
+
+    class << self
+      def clear_errors
+        Thread.current[:jsonschema_errors] = []
+      end
+
+      def validation_error(error)
+        Thread.current[:jsonschema_errors] << error
+      end
+
+      def validation_errors
+        Thread.current[:jsonschema_errors] or []
+      end
+    end
+
+
+    # Plus one bonus: don't use MultiJson here.
+    def serialize schema
+      # if defined?(MultiJson)
+      #   MultiJson.respond_to?(:dump) ? MultiJson.dump(schema) : MultiJson.encode(schema)
+      # else
+      #   @@serializer.call(schema)
+      # end
+
+      ASUtils.to_json(schema)
+    end
+
+  end
+end