ladder 0.2.1 → 0.3.0

data/lib/ladder/resource.rb

@@ -1,35 +1,21 @@
 require 'mongoid'
 require 'active_triples'
-require 'json/ld'
 
 module Ladder::Resource
+  autoload :Dynamic, 'ladder/resource/dynamic'
+  autoload :Serializable, 'ladder/resource/serializable'
+
   extend ActiveSupport::Concern
 
   include Mongoid::Document
   include ActiveTriples::Identifiable
-
-  autoload :Dynamic, 'ladder/resource/dynamic'
+  include Ladder::Resource::Serializable
 
   included do
     configure base_uri: RDF::URI.new(LADDER_BASE_URI) / name.underscore.pluralize if defined? LADDER_BASE_URI
   end
 
-  ##
-  # Return JSON-LD representation
-  #
-  # @see ActiveTriples::Resource#dump
-  def as_jsonld(opts = {})
-    JSON.parse update_resource(opts.slice :related).dump(:jsonld, {standard_prefixes: true}.merge(opts))
-  end
-
-  ##
-  # Overload ActiveTriples #rdf_label
-  #
-  # @see ActiveTriples::Resource
-  def rdf_label
-    update_resource
-    resource.rdf_label
-  end
+  delegate :rdf_label, to: :update_resource
 
   ##
   # Populate resource properties from ActiveModel
@@ -38,19 +24,40 @@ module Ladder::Resource
       value = update_from_field(name) if fields[name]
       value = update_from_relation(name, opts) if relations[name]
 
-      cast_uri = RDF::URI.new(value)
-      resource.set_value(property.predicate, cast_uri.valid? ? cast_uri : value) if value
+      resource.set_value(property.predicate, value) #if value
     end
 
     resource
   end
 
+  ##
+  # Push RDF statement into resource
+  def <<(data)
+    # ActiveTriples::Resource expects: RDF::Statement, Hash, or Array
+    data = RDF::Statement.from(data) unless data.is_a? RDF::Statement
+
+    # Only push statement if the statement's predicate is defined on the class
+    if resource_class.properties.values.map(&:predicate).include? data.predicate
+      field_name = resource_class.properties.select { |name, term| term.predicate == data.predicate }.keys.first.to_sym
+
+      # Set the value in Mongoid
+      value = data.object.is_a?(RDF::Literal) ? data.object.object : data.object.to_s
+      self.send("#{field_name}=", value)
+    end
+  end
+
   private
 
     def update_from_field(name)
       if fields[name].localized?
         localized_hash = read_attribute(name)
-        localized_hash.map { |lang, val| RDF::Literal.new(val, language: lang) } unless localized_hash.nil?
+
+        unless localized_hash.nil?
+          localized_hash.map do |lang, value|
+            cast_uri = RDF::URI.new(value)
+            cast_uri.valid? ? cast_uri : RDF::Literal.new(value, language: lang)
+          end
+        end
       else
         self.send(name)
       end
@@ -60,6 +67,9 @@ module Ladder::Resource
       objects = self.send(name).to_a
 
       if opts[:related] or embedded_relations[name]
+        # Force autosave of related documents to ensure correct serialization
+        methods.select{|i| i[/autosave_documents/] }.each{|m| send m}
+
         # update inverse relation properties
         relation_def = relations[name]
         objects.each { |object| object.resource.set_value(relation_def.inverse, self.rdf_subject) } if relation_def.inverse

data/lib/ladder/resource/dynamic.rb

@@ -3,29 +3,12 @@ module Ladder::Resource::Dynamic
 
   included do
     include Ladder::Resource
+    include InstanceMethods
+    include ClassMethods
 
     field :_context, type: Hash
 
     after_find :apply_context
-    
-    ##
-    # Overload Ladder #update_resource
-    #
-    # @see Ladder::Resource
-    def update_resource(opts = {})
-      # FIXME: for some reason super has to go first or AT clobbers properties
-      super(opts)
-
-      if self._context
-        self._context.each do |field_name, uri|
-          value = self.send(field_name)
-          cast_uri = RDF::URI.new(value)
-          resource.set_value(RDF::Vocabulary.find_term(uri), cast_uri.valid? ? cast_uri : value)
-        end
-      end
-
-      resource
-    end
   end
 
   ##
@@ -41,35 +24,6 @@ module Ladder::Resource::Dynamic
     apply_context
   end
 
-  def <<(data)
-    # ActiveTriples::Resource expects: RDF::Statement, Hash, or Array
-    data = RDF::Statement.from(data) unless data.is_a? RDF::Statement
-
-    # Define predicate on object unless it's defined on the class
-    if resource_class.properties.values.map(&:predicate).include? data.predicate
-      field_name = resource_class.properties.select { |name, term| term.predicate == data.predicate }.keys.first.to_sym
-    else
-      qname = data.predicate.qname
-
-      if respond_to? qname.last or :name == qname.last
-        field_name = qname.join('_').to_sym
-      else
-        field_name = qname.last
-      end
-
-      property field_name, predicate: data.predicate
-    end
-
-    # Set the value in Mongoid
-    value = if data.object.is_a? RDF::Literal
-      data.object.object
-    else
-      data.object.to_s
-    end
-
-    self.send("#{field_name}=", value)
-  end
-
   private
 
     ##
@@ -96,7 +50,47 @@ module Ladder::Resource::Dynamic
       end
     end
 
-  public
+  module InstanceMethods
+
+    ##
+    # Overload Ladder #update_resource
+    #
+    # @see Ladder::Resource
+    def update_resource(opts = {})
+      # NB: super has to go first or AT clobbers properties
+      super(opts)
+
+      if self._context
+        self._context.each do |field_name, uri|
+          value = self.send(field_name)
+          cast_uri = RDF::URI.new(value)
+          resource.set_value(RDF::Vocabulary.find_term(uri), cast_uri.valid? ? cast_uri : value)
+        end
+      end
+
+      resource
+    end
+
+    ##
+    # Overload Ladder #<<
+    #
+    # @see Ladder::Resource
+    def <<(data)
+      # ActiveTriples::Resource expects: RDF::Statement, Hash, or Array
+      data = RDF::Statement.from(data) unless data.is_a? RDF::Statement
+
+      unless resource_class.properties.values.map(&:predicate).include? data.predicate
+        # Generate a dynamic field name
+        qname = data.predicate.qname
+        field_name = (respond_to? qname.last or :name == qname.last) ? qname.join('_').to_sym : qname.last
+
+        # Define property on class
+        property field_name, predicate: data.predicate
+      end
+    
+      super(data)
+    end
+  end
   
   module ClassMethods
     

data/lib/ladder/resource/serializable.rb

@@ -0,0 +1,54 @@
+require 'json/ld'
+
+module Ladder::Resource::Serializable
+  ##
+  # Return JSON-LD representation
+  #
+  # @see ActiveTriples::Resource#dump
+  def as_jsonld(opts = {})
+    JSON.parse update_resource(opts.slice :related).dump(:jsonld, {standard_prefixes: true}.merge(opts))
+  end
+
+  ##
+  # Generate a qname-based JSON representation
+  #
+  def as_qname(opts = {})
+    qname_hash = type.empty? ? {} : {rdf: {type: type.first.pname }}
+
+    resource_class.properties.each do |field_name, property|
+      ns, name = property.predicate.qname
+      qname_hash[ns] ||= Hash.new
+
+      object = self.send(field_name)
+
+      if relations.keys.include? field_name
+        if opts[:related]
+          qname_hash[ns][name] = object.to_a.map { |obj| obj.as_qname }
+        else
+          qname_hash[ns][name] = object.to_a.map { |obj| "#{obj.class.name.underscore.pluralize}:#{obj.id}" }
+        end
+      elsif fields.keys.include? field_name
+        qname_hash[ns][name] = read_attribute(field_name)
+      end
+    end
+
+    qname_hash
+  end
+
+  ##
+  # Return a framed, compacted JSON-LD representation
+  # by embedding related objects from the graph
+  #
+  # NB: Will NOT embed related objects with same @type.
+  # Spec under discussion, see https://github.com/json-ld/json-ld.org/issues/110
+  def as_framed_jsonld
+    json_hash = as_jsonld related: true
+
+    context = json_hash['@context']
+    frame = {'@context' => context}
+    frame['@type'] = type.first.pname unless type.empty?
+
+    JSON::LD::API.compact(JSON::LD::API.frame(json_hash, frame), context)
+  end
+  
+end

data/lib/ladder/searchable.rb

@@ -1,16 +1,17 @@
-require 'ladder/resource'
+require 'active_support/concern'
 require 'elasticsearch/model'
 require 'elasticsearch/model/callbacks'
 
 module Ladder::Searchable
   extend ActiveSupport::Concern
 
-  autoload :Resource, 'ladder/searchable/resource'
-  autoload :File,     'ladder/searchable/file'
+  autoload :Background, 'ladder/searchable/background'
+  autoload :File,       'ladder/searchable/file'
+  autoload :Resource,   'ladder/searchable/resource'
 
   included do
     include Elasticsearch::Model
-    include Elasticsearch::Model::Callbacks
+    include Elasticsearch::Model::Callbacks unless self.ancestors.include? Ladder::Searchable::Background
 
     include Ladder::Searchable::Resource if self.ancestors.include? Ladder::Resource
     include Ladder::Searchable::File     if self.ancestors.include? Ladder::File

data/lib/ladder/searchable/background.rb

@@ -0,0 +1,43 @@
+require 'active_job'
+
+module Ladder::Searchable::Background
+  extend ActiveSupport::Concern
+
+  included do
+    include Ladder::Searchable
+    include GlobalID::Identification
+
+    GlobalID.app = 'Ladder'
+
+    after_create   { enqueue :index }
+    after_update   { enqueue :update }
+    before_destroy { enqueue :delete }
+  end
+
+  private
+
+    def enqueue(operation)
+      # Force autosave of related documents before queueing for indexing or updating
+      methods.select{|i| i[/autosave_documents/] }.each{|m| send m} unless :delete == operation
+
+      Indexer.set(queue: self.class.name.underscore.pluralize).perform_later(operation.to_s, self)
+    end
+
+  class Indexer < ActiveJob::Base
+    queue_as :elasticsearch
+
+    def perform(operation, model)
+      case operation
+        when 'index'
+          model.__elasticsearch__.index_document
+        when 'update'
+          model.__elasticsearch__.update_document
+        when 'delete'
+          model.__elasticsearch__.delete_document
+#        else raise ArgumentError, "Unknown operation '#{operation}'"
+      end
+    end
+
+  end
+
+end

data/lib/ladder/searchable/resource.rb

@@ -1,76 +1,17 @@
 module Ladder::Searchable::Resource
   extend ActiveSupport::Concern
-
-  ##
-  # Generate a qname-based JSON representation
-  #
-  def as_qname(opts = {})
-    qname_hash = type.empty? ? {} : {rdf: {type: type.first.pname }}
-
-    resource_class.properties.each do |field_name, property|
-      ns, name = property.predicate.qname
-      qname_hash[ns] ||= Hash.new
-
-      object = self.send(field_name)
-
-      if relations.keys.include? field_name
-        if opts[:related]
-          qname_hash[ns][name] = object.to_a.map { |obj| obj.as_qname }
-        else
-          qname_hash[ns][name] = object.to_a.map { |obj| "#{obj.class.name.underscore.pluralize}:#{obj.id}" }
-        end
-      elsif fields.keys.include? field_name
-        qname_hash[ns][name] = read_attribute(field_name)
-      end
-    end
-
-    qname_hash
+  
+  def as_indexed_json(opts = {})
+    respond_to?(:serialized_json) ? serialized_json : as_json(except: [:id, :_id])
   end
 
-  private
-
-    ##
-    # Return a framed, compacted JSON-LD representation
-    # by embedding related objects from the graph
-    #
-    # NB: Will NOT embed related objects with same @type. Spec under discussion, see https://github.com/json-ld/json-ld.org/issues/110
-    def as_framed_jsonld
-      json_hash = as_jsonld related: true
-      context = json_hash['@context']
-      frame = {'@context' => context, '@type' => type.first.pname}
-      JSON::LD::API.compact(JSON::LD::API.frame(json_hash, frame), context)
-    end
-    
-    ##
-    # Force autosave of related documents using Mongoid-defined methods
-    # Required for explicit autosave prior to after_update index callbacks
-    #
-    def autosave
-      methods.select{|i| i[/autosave_documents/] }.each{|m| send m}
-    end
-
   module ClassMethods
 
     ##
     # Specify type of serialization to use for indexing
     #
-    def index_for_search(opts = {})
-      case opts[:as]
-      when :jsonld
-        if opts[:related]
-          define_method(:as_indexed_json) { |opts = {}| autosave; as_framed_jsonld }
-        else
-          define_method(:as_indexed_json) { |opts = {}| as_jsonld }
-        end
-      when :qname
-        if opts[:related]
-          define_method(:as_indexed_json) { |opts = {}| as_qname related: true }
-        else
-          define_method(:as_indexed_json) { |opts = {}| as_qname }
-        end
-      else
-        define_method(:as_indexed_json) { |opts = {}| as_json(except: [:id, :_id]) }
-      end
+    def index_for_search(opts = {}, &block)
+      define_method(:serialized_json, block)
     end
 
   end

data/lib/ladder/version.rb

@@ -1,3 +1,3 @@
 module Ladder
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/spec/ladder/file_spec.rb

@@ -6,19 +6,69 @@ describe Ladder::File do
     Mongoid.logger.level = Moped.logger.level = Logger::DEBUG
     Mongoid.purge!
 
-    LADDER_BASE_URI = 'http://example.org'
+    LADDER_BASE_URI ||= 'http://example.org'
 
     class Datastream
       include Ladder::File
     end
   end
 
+  after do
+    Object.send(:remove_const, :LADDER_BASE_URI) if Object
+    Object.send(:remove_const, "Datastream") if Object
+  end
+
+  shared_context 'with relations' do
+    let(:thing)    { Thing.new }
+
+    before do
+      class Thing
+        include Ladder::Resource
+      end
+
+      # implicit from #property
+      thing.class.property :files, predicate: RDF::DC.relation, class_name: subject.class.name, inverse_of: nil
+      thing.files << subject
+      thing.save
+
+      # TODO: build some relations of various types
+      # explicit using HABTM
+      # explicit has-one
+    end
+
+    after do
+      Object.send(:remove_const, 'Thing') if Object
+    end
+
+    context 'with one-sided has-many' do
+      it 'should have a relation' do
+        expect(thing.relations['files'].relation).to eq (Mongoid::Relations::Referenced::ManyToMany)
+        expect(thing.files.to_a).to include subject
+      end
+
+      it 'should not have an inverse relation' do
+        expect(thing.relations['files'].inverse_of).to be nil
+        expect(subject.relations).to be_empty
+      end
+
+      it 'should have a valid predicate' do
+        expect(thing.class.properties['files'].predicate).to eq RDF::DC.relation
+      end
+
+      it 'should not have an inverse predicate' do
+        expect(subject.class.properties).to be_empty
+      end
+    end
+
+  end
+
   context 'with data from file' do
-    TEST_FILE = './spec/shared/moomin.pdf'
+    TEST_FILE ||= './spec/shared/moomin.pdf'
 
     let(:subject) { Datastream.new file: open(TEST_FILE) }
     let(:source) { open(TEST_FILE).read } # ASCII-8BIT (binary)
 
+    include_context 'with relations'
     it_behaves_like 'a File'
   end
 
@@ -32,11 +82,8 @@ describe Ladder::File do
       subject.file = StringIO.new(source)
     end
 
+    include_context 'with relations'
     it_behaves_like 'a File'
   end
 
-  after do
-    Object.send(:remove_const, :LADDER_BASE_URI) if Object
-    Object.send(:remove_const, "Datastream") if Object
-  end
 end