ladder 0.3.1 → 0.3.2

data/lib/ladder/resource/dynamic.rb

@@ -1,104 +1,155 @@
-module Ladder::Resource::Dynamic
-  extend ActiveSupport::Concern
+module Ladder
+  module Resource
+    module Dynamic
+      extend ActiveSupport::Concern
 
-  included do
-    include Ladder::Resource
-    include InstanceMethods
+      include Ladder::Resource
 
-    field :_context, type: Hash
+      included do
+        include InstanceMethods
 
-    after_find :apply_context
-  end
+        field :_context, type: Hash
+        field :_types,   type: Array
 
-  ##
-  # Dynamic field definition
-  def property(field_name, *opts)
-    # Store context information
-    self._context ||= Hash.new(nil)
+        after_find :apply_context
+        after_find :apply_types
+      end
 
-    # Ensure new field name is unique
-    field_name = opts.first[:predicate].qname.join('_').to_sym if respond_to? field_name or :name == field_name
-    self._context[field_name] = opts.first[:predicate].to_s
+      ##
+      # Dynamically define a field on the object instance; in addition to
+      # (or overloading) class-level properties
+      #
+      # @see Ladder::Resource#property
+      #
+      # @param [String] field_name ActiveModel attribute name for the field
+      # @param [Hash] opts options to pass to Mongoid / ActiveTriples
+      # @option opts [RDF::Term] :predicate RDF predicate for this property
+      # @return [Hash] an updated context for the object
+      def property(field_name, opts = {})
+        # Store context information
+        self._context ||= Hash.new(nil)
+
+        # Ensure new field name is unique
+        field_name = opts[:predicate].qname.join('_').to_sym if resource_class.properties.symbolize_keys.keys.include? field_name
+
+        self._context[field_name] = opts[:predicate].to_s
+        apply_context
+      end
 
-    apply_context
-  end
+      private
 
-  private
+      ##
+      # Dynamically define field accessors
+      #
+      # @see http://mongoid.org/en/mongoid/v3/documents.html#dynamic_fields Mongoid Dynamic Fields
+      #
+      # @param [String] field_name ActiveModel attribute name for the field
+      # @return [void]
+      def create_accessors(field_name)
+        define_singleton_method(field_name) { read_attribute(field_name) }
+        define_singleton_method("#{field_name}=") { |value| write_attribute(field_name, value) }
+      end
 
-    ##
-    # Dynamic field accessors (Mongoid)
-    def create_accessors(field_name)
-      define_singleton_method(field_name) { read_attribute(field_name) }
-      define_singleton_method("#{field_name}=") { |value| write_attribute(field_name, value) } 
-    end
-    
-    ##
-    # Apply dynamic fields and properties to this instance
-    def apply_context
-      return unless self._context
+      ##
+      # Apply dynamic fields and properties to this instance
+      #
+      # @return [void]
+      def apply_context
+        return unless self._context
 
-      self._context.each do |field_name, uri|
-        next if fields.keys.include? field_name
+        self._context.each do |field_name, uri|
+          next if fields.keys.include? field_name
 
-        if term = RDF::Vocabulary.find_term(uri)
-          create_accessors field_name
+          if RDF::Vocabulary.find_term(uri)
+            create_accessors field_name
 
-          # Update resource properties
-          resource_class.property(field_name, predicate: term)
+            # Update resource properties
+            resource_class.property(field_name.to_sym, predicate: RDF::Vocabulary.find_term(uri))
+          end
         end
       end
-    end
 
-  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)
+      ##
+      # Apply dynamic types to this instance
+      #
+      # @return [void]
+      def apply_types
+        return unless _types
+
+        _types.each do |rdf_type|
+          unless resource.type.include? RDF::Vocabulary.find_term(rdf_type)
+            resource << RDF::Statement.new(rdf_subject, RDF.type, RDF::Vocabulary.find_term(rdf_type))
+          end
         end
       end
 
-      resource
-    end
+      module InstanceMethods
+        ##
+        # Update the delegated ActiveTriples::Resource from
+        # ActiveModel properties & relations
+        #
+        # @see Ladder::Resource#update_resource
+        #
+        # @param [Hash] opts options to pass to Mongoid / ActiveTriples
+        # @return [ActiveTriples::Resource] resource for the object
+        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 = 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
+        ##
+        # Push an RDF::Statement into the object
+        #
+        # @see Ladder::Resource#<<
+        #
+        # @param [RDF::Statement, Hash, Array] statement @see RDF::Statement#from
+        # @return [void]
+        def <<(statement)
+          # ActiveTriples::Resource expects: RDF::Statement, Hash, or Array
+          statement = RDF::Statement.from(statement) unless statement.is_a? RDF::Statement
+
+          # Don't store statically-defined types
+          return if resource_class.type == statement.object
+
+          if RDF.type == statement.predicate
+            # Store type information
+            self._types ||= []
+            self._types << statement.object.to_s
+
+            apply_types
+            return
+          end
+
+          # If we have an undefined predicate, then dynamically define it
+          return unless statement.predicate.qname
+          property statement.predicate.qname.last, predicate: statement.predicate unless field_from_predicate statement.predicate
+
+          super
+        end
 
-    private
-      ##
-      # Overload ActiveTriples #resource_class
-      #
-      # @see ActiveTriples::Identifiable
-      def resource_class
-        @modified_resource_class ||= self.class.resource_class.clone
+        private
+
+        ##
+        # Return a cloned, mutatable copy of the
+        # ActiveTriples::Resource class for this instance
+        #
+        # @see ActiveTriples::Identifiable#resource_class
+        #
+        # @return [Class] a GeneratedResourceSchema for this class
+        def resource_class
+          @modified_resource_class ||= self.class.resource_class.clone
+        end
       end
-
+    end
   end
-
-end
+end

data/lib/ladder/resource/serializable.rb

@@ -1,54 +1,67 @@
 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 }}
+module Ladder
+  module Resource
+    module Serializable
+      ##
+      # Return a JSON-LD representation for the resource
+      #
+      # @see ActiveTriples::Resource#dump
+      #
+      # @param [Hash] opts options to pass to ActiveTriples
+      # @option opts [Boolean] :related whether to include related resources
+      # @return [Hash] a serialized JSON-LD version of the resource
+      def as_jsonld(opts = {})
+        JSON.parse update_resource(opts.slice :related).dump(:jsonld, { standard_prefixes: true }.merge(opts))
+      end
 
-    resource_class.properties.each do |field_name, property|
-      ns, name = property.predicate.qname
-      qname_hash[ns] ||= Hash.new
+      ##
+      # 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
+      #
+      # @return [Hash] a serialized JSON-LD version of the resource
+      def as_framed_jsonld
+        json_hash = as_jsonld related: true
 
-      object = self.send(field_name)
+        context = json_hash['@context']
+        frame = { '@context' => context }
+        frame['@type'] = type.first.pname unless type.empty?
 
-      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)
+        JSON::LD::API.compact(JSON::LD::API.frame(json_hash, frame), context)
       end
-    end
 
-    qname_hash
-  end
+      ##
+      # Return a qname-based JSON representation
+      #
+      # @param [Hash] opts options for serializaiton
+      # @option opts [Boolean] :related whether to include related resources
+      # @return [Hash] a serialized 'qname' version of the resource
+      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] ||= {}
 
-  ##
-  # 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
+          if relations.keys.include? field_name
+            if opts[:related]
+              qname_hash[ns][name] = send(field_name).to_a.map(&:as_qname)
+            else
+              qname_hash[ns][name] = send(field_name).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
 
-    context = json_hash['@context']
-    frame = {'@context' => context}
-    frame['@type'] = type.first.pname unless type.empty?
+          # Remove empty/null values
+          qname_hash[ns].delete_if { |_k, v| v.blank? }
+        end
 
-    JSON::LD::API.compact(JSON::LD::API.frame(json_hash, frame), context)
+        qname_hash
+      end
+    end
   end
-  
-end
+end

data/lib/ladder/searchable.rb

@@ -2,18 +2,20 @@ require 'active_support/concern'
 require 'elasticsearch/model'
 require 'elasticsearch/model/callbacks'
 
-module Ladder::Searchable
-  extend ActiveSupport::Concern
+module Ladder
+  module Searchable
+    extend ActiveSupport::Concern
 
-  autoload :Background, 'ladder/searchable/background'
-  autoload :File,       'ladder/searchable/file'
-  autoload :Resource,   'ladder/searchable/resource'
+    autoload :Background, 'ladder/searchable/background'
+    autoload :File,       'ladder/searchable/file'
+    autoload :Resource,   'ladder/searchable/resource'
 
-  included do
-    include Elasticsearch::Model
-    include Elasticsearch::Model::Callbacks unless self.ancestors.include? Ladder::Searchable::Background
+    included do
+      include Elasticsearch::Model
+      include Elasticsearch::Model::Callbacks unless 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
-  end  
-end
+      include Ladder::Searchable::Resource if ancestors.include? Ladder::Resource
+      include Ladder::Searchable::File     if ancestors.include? Ladder::File
+    end
+  end
+end

data/lib/ladder/searchable/background.rb

@@ -1,43 +1,52 @@
 require 'active_job'
 
-module Ladder::Searchable::Background
-  extend ActiveSupport::Concern
+module Ladder
+  module Searchable
+    module Background
+      extend ActiveSupport::Concern
 
-  included do
-    include Ladder::Searchable
-    include GlobalID::Identification
+      included do
+        include Ladder::Searchable
+        include GlobalID::Identification
 
-    GlobalID.app = 'Ladder'
+        GlobalID.app = 'Ladder'
 
-    after_create   { enqueue :index }
-    after_update   { enqueue :update }
-    before_destroy { enqueue :delete }
-  end
+        after_create   { enqueue :index }
+        after_update   { enqueue :update }
+        before_destroy { enqueue :delete }
+      end
 
-  private
+      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
+      ##
+      # Queue an index operation for asynchronous execution
+      #
+      # @param [Symbol] operation the kind of operation to perform: index, delete, update
+      # @return [void]
+      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
+        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}'"
+      class Indexer < ActiveJob::Base
+        queue_as :elasticsearch
+
+        ##
+        # Perform a queued index operation
+        #
+        # @param [String] operation the kind of operation to perform: index, delete, update
+        # @param [Ladder::Resource, Ladder::File] model the object instance to modify in the index
+        # @return [void]
+        def perform(operation, model)
+          case operation
+          when 'index' then model.__elasticsearch__.index_document
+          when 'update' then model.__elasticsearch__.update_document
+          when 'delete' then model.__elasticsearch__.delete_document
+          end
+        end
       end
     end
-
   end
-
-end
+end