ladder 0.3.1 → 0.3.2

data/lib/ladder/searchable/file.rb

@@ -1,30 +1,37 @@
-module Ladder::Searchable::File
-  extend ActiveSupport::Concern
+module Ladder
+  module Searchable
+    module File
+      extend ActiveSupport::Concern
 
-  included do
-    # Index binary content using Elasticsearch mapper attachment plugin
-    # https://github.com/elasticsearch/elasticsearch-mapper-attachments
-    mapping _source: { enabled: false } do
-      indexes :file, type: 'attachment', fields: {
-        file: { store: true },
-        title: { store: true },
-        date: { store: true },
-        author: { store: true },
-        keywords: { store: true },
-        content_type: { store: true },
-        content_length: { store: true },
-        language: { store: true }
-      }
-    end
+      included do
+        # Index binary content using Elasticsearch mapper attachment plugin
+        # https://github.com/elasticsearch/elasticsearch-mapper-attachments
+        mapping _source: { enabled: false } do
+          indexes :file, type: 'attachment', fields: {
+            file: { store: true },
+            title: { store: true },
+            date: { store: true },
+            author: { store: true },
+            keywords: { store: true },
+            content_type: { store: true },
+            content_length: { store: true },
+            language: { store: true }
+          }
+        end
 
-    # Explicitly set mapping definition on index
-    self.__elasticsearch__.create_index!
-  end
+        # Explicitly set mapping definition on index
+        __elasticsearch__.create_index!
+      end
 
-  ##
-  # Return a Base64-encoded copy of data
-  def as_indexed_json(opts = {})
-    { file: Base64.encode64(data) }
+      ##
+      # Serialize a Base64-encoded version of data for indexing
+      #
+      # @see Elasticsearch::Model::Serializing#as_indexed_json
+      #
+      # @return [Hash] a serialized version of the file
+      def as_indexed_json(*)
+        { file: Base64.encode64(data) }
+      end
+    end
   end
-
-end
+end

data/lib/ladder/searchable/resource.rb

@@ -1,19 +1,30 @@
-module Ladder::Searchable::Resource
-  extend ActiveSupport::Concern
-  
-  def as_indexed_json(opts = {})
-    respond_to?(:serialized_json) ? serialized_json : as_json(except: [:id, :_id])
-  end
+module Ladder
+  module Searchable
+    module Resource
+      extend ActiveSupport::Concern
 
-  module ClassMethods
+      ##
+      # Serialize the resource as JSON for indexing
+      #
+      # @see Elasticsearch::Model::Serializing#as_indexed_json
+      #
+      # @return [Hash] a serialized version of the resource
+      def as_indexed_json(*)
+        respond_to?(:serialized_json) ? serialized_json : as_json(except: [:id, :_id])
+      end
 
-    ##
-    # Specify type of serialization to use for indexing
-    #
-    def index_for_search(opts = {}, &block)
-      define_method(:serialized_json, block)
+      module ClassMethods
+        ##
+        # Specify type of serialization to use for indexing;
+        # if a block is provided, it is expected to return a Hash
+        # that will be used in lieu of {#as_indexed_json} for
+        # serializing the resource in the index
+        #
+        # @return [void]
+        def index_for_search(&block)
+          define_method(:serialized_json, block) if block_given?
+        end
+      end
     end
-
   end
-    
-end
+end

data/lib/ladder/version.rb

@@ -1,3 +1,3 @@
 module Ladder
-  VERSION = "0.3.1"
-end
+  VERSION = '0.3.2'
+end

data/spec/ladder/file_spec.rb

@@ -15,7 +15,7 @@ describe Ladder::File do
 
   after do
     Object.send(:remove_const, :LADDER_BASE_URI) if Object
-    Object.send(:remove_const, "Datastream") if Object
+    Object.send(:remove_const, 'Datastream') if Object
   end
 
   shared_context 'with relations' do
@@ -42,7 +42,7 @@ describe Ladder::File do
 
     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.relations['files'].relation).to eq Mongoid::Relations::Referenced::ManyToMany
         expect(thing.files.to_a).to include subject
       end
 
@@ -59,7 +59,6 @@ describe Ladder::File do
         expect(subject.class.properties).to be_empty
       end
     end
-
   end
 
   context 'with data from file' do
@@ -73,8 +72,12 @@ describe Ladder::File do
   end
 
   context 'with data from string after creation' do
-    data = "And so Moomintroll was helplessly thrown out into a strange and dangerous world and dropped up to his ears in the first snowdrift of his experience. It felt unpleasantly prickly to his velvet skin, but at the same time his nose caught a new smell. It was a more serious smell than any he had met before, and slightly frightening. But it made him wide awake and greatly interested."
-    
+    data = 'And so Moomintroll was helplessly thrown out into a strange and dangerous world and dropped
+            up to his ears in the first snowdrift of his experience. It felt unpleasantly prickly to his
+            velvet skin, but at the same time his nose caught a new smell. It was a more serious smell
+            than any he had met before, and slightly frightening. But it made him wide awake and greatly
+            interested.'
+
     let(:subject) { Datastream.new }
     let(:source) { data } # UTF-8 (string)
 
@@ -85,5 +88,4 @@ describe Ladder::File do
     include_context 'with relations'
     it_behaves_like 'a File'
   end
-
-end
+end

data/spec/ladder/resource/dynamic_spec.rb

@@ -10,12 +10,17 @@ describe Ladder::Resource::Dynamic do
 
     class Thing
       include Ladder::Resource::Dynamic
+      configure type: RDF::DC.BibliographicResource
+
+      field :alt
+      property :alt, predicate: RDF::DC.alternative # non-localized literal
+      property :title, predicate: RDF::DC.title     # localized literal
     end
   end
 
   after do
     Object.send(:remove_const, :LADDER_BASE_URI) if Object
-    Object.send(:remove_const, "Thing") if Object
+    Object.send(:remove_const, 'Thing') if Object
   end
 
   context 'with data' do
@@ -23,155 +28,20 @@ describe Ladder::Resource::Dynamic do
 
     before do
       # non-localized literal
-      subject.class.field :alt
-      subject.class.property :alt, predicate: RDF::DC.alternative
       subject.alt = 'Mumintrollet pa kometjakt'
 
       # localized literal
-      subject.class.property :title, predicate: RDF::DC.title
       subject.title = 'Comet in Moominland'
     end
 
     it_behaves_like 'a Resource'
-    
-    describe '#property' do
-      context 'with undefined property' do
-        before do
-          subject.property :description, predicate: RDF::DC.description
-          subject.description = "Second in Tove Jansson's series of Moomin books"
-        end
-
-        it 'should create a context' do
-          expect(subject._context).to eq({description: RDF::DC.description.to_uri.to_s})
-        end
-      
-        it 'should build an accessor' do
-          expect(subject.description).to eq "Second in Tove Jansson's series of Moomin books"
-        end
-      end
-
-      context 'with conflicting property' do
-        before do
-          subject.property :title, predicate: RDF::DC11.title
-          subject.dc11_title = "Kometjakten"
-        end
-
-        it 'should create a context' do
-          expect(subject._context).to eq({dc11_title: RDF::DC11.title.to_uri.to_s})
-        end
-      
-        it 'should build an accessor' do
-          expect(subject.dc11_title).to eq "Kometjakten"
-        end
-      end
-    end
-  
-    describe '#update_resource' do
-      before do
-        # undefined property
-        subject.property :description, predicate: RDF::DC.description
-        subject.description = "Second in Tove Jansson's series of Moomin books"
-
-        # conflicting property
-        subject.property :title, predicate: RDF::DC11.title
-        subject.dc11_title = "Kometjakten"
-
-        # defined field
-        subject << RDF::Statement(nil, RDF::DC.title, 'Kometen kommer')
-
-        # conflicting property
-        subject << RDF::Statement(nil, RDF::DC.alternative, "Kometjakten")
-
-        # URI value
-        subject << RDF::Statement(nil, RDF::DC.identifier, RDF::URI('http://some.uri'))
-
-        subject.update_resource
-      end
-    
-      it 'should have updated values' do
-        expect(subject.resource.statements.count).to eq 5
-        expect(subject.resource.query(predicate: RDF::DC.description, object: "Second in Tove Jansson's series of Moomin books").count).to eq 1
-        expect(subject.resource.query(predicate: RDF::DC11.title, object: "Kometjakten").count).to eq 1
-        expect(subject.resource.query(predicate: RDF::DC.title, object: RDF::Literal.new('Kometen kommer', language: :en)).count).to eq 1
-        expect(subject.resource.query(predicate: RDF::DC.alternative, object: "Kometjakten").count).to eq 1
-        expect(subject.resource.query(predicate: RDF::DC.identifier, object: RDF::URI('http://some.uri')).count).to eq 1
-      end
-    end
-
-    describe '#<<' do
-      context 'with defined field' do
-        before do
-          subject << RDF::Statement(nil, RDF::DC.title, 'Kometen kommer')
-        end
-      
-        it 'should not create a context' do
-          expect(subject._context).to be nil
-        end
-      
-        it 'should update existing values' do
-          expect(subject.title).to eq 'Kometen kommer'
-        end
-      end
-
-      context 'with undefined field' do
-        before do
-          subject << RDF::Statement(nil, RDF::DC.description, "Second in Tove Jansson's series of Moomin books")
-        end
-
-        it 'should create a context' do
-          expect(subject._context).to eq({ description: RDF::DC.description.to_uri.to_s })
-        end
-      
-        it 'should build an accessor' do
-          expect(subject.description).to eq "Second in Tove Jansson's series of Moomin books"
-        end
-      end
-
-      context 'with conflicting property' do
-        before do
-          subject << RDF::Statement(nil, RDF::DC11.title, "Kometjakten")
-        end
-
-        it 'should create a context' do
-          expect(subject._context).to eq({ dc11_title: RDF::DC11.title.to_uri.to_s })
-        end
-      
-        it 'should build an accessor' do
-          expect(subject.dc11_title).to eq "Kometjakten"
-        end
-      end
-
-      context 'with a URI value' do
-        before do
-          subject << RDF::Statement(nil, RDF::DC.identifier, RDF::URI('http://some.uri'))
-        end
-      
-        it 'should store the URI as a string' do
-          expect(subject.identifier).to eq 'http://some.uri'
-        end
+    it_behaves_like 'a Dynamic Resource'
+  end
 
-        it 'should cast a URI into the resource' do
-          subject.update_resource
-          query = subject.resource.query(subject: subject.rdf_subject, predicate: RDF::DC.identifier)
-          expect(query.first_object).to be_a_kind_of RDF::URI
-        end
-      end
-    end
-    
-    describe '#resource_class' do
-      before do
-        subject.property :description, predicate: RDF::DC.description
-      end
+  context 'from JSON-LD' do
+    let(:subject) { Thing.new_from_graph(RDF::Graph.load './spec/shared/graph.jsonld') }
 
-      it 'should have modified properties on the instance' do
-        expect(subject.resource.class.properties.keys).to include 'description'
-      end
-      
-      it 'should not modify the global class properties' do
-        expect(subject.class.resource_class.properties.keys).to_not include 'description'
-        expect(subject.class.resource_class.properties).to eq subject.class.new.class.resource_class.properties
-      end
-    end
+    it_behaves_like 'a Resource'
+    it_behaves_like 'a Dynamic Resource'
   end
-
-end
+end

data/spec/ladder/resource_spec.rb

@@ -10,266 +10,63 @@ describe Ladder::Resource do
 
     class Thing
       include Ladder::Resource
+      configure type: RDF::DC.BibliographicResource
+
+      field :alt
+      property :alt, predicate: RDF::DC.alternative # non-localized literal
+      property :title, predicate: RDF::DC.title     # localized literal
+      property :identifier, predicate: RDF::DC.identifier
     end
   end
 
   after do
     Object.send(:remove_const, :LADDER_BASE_URI) if Object
-    Object.send(:remove_const, "Thing") if Object
-  end
-
-  shared_context 'with data' do
-    before do
-      subject.class.configure type: RDF::DC.BibliographicResource
-
-      # non-localized literal
-      subject.class.field :alt
-      subject.class.property :alt, predicate: RDF::DC.alternative
-      subject.alt = 'Mumintrollet pa kometjakt'
-
-      # localized literal
-      subject.class.property :title, predicate: RDF::DC.title
-      subject.title = 'Comet in Moominland'
-    end
+    Object.send(:remove_const, 'Thing') if Object
   end
 
   shared_context 'with relations' do
     let(:person)  { Person.new }
     let(:concept) { Concept.new }
     let(:part)    { Part.new }
-    
+
     before do
       class Person
         include Ladder::Resource
+        configure type: RDF::DC.AgentClass
+
+        property :things, predicate: RDF::DC.relation, class_name: 'Thing'
       end
 
       class Concept
         include Ladder::Resource
+        configure type: RDF::SKOS.Concept
       end
 
       class Part
         include Ladder::Resource
-      end
+        configure type: RDF::DC.PhysicalResource
 
-      person.class.configure type: RDF::DC.AgentClass
-      concept.class.configure type: RDF::SKOS.Concept
-      part.class.configure type: RDF::DC.PhysicalResource
+        embedded_in :thing
+        property :thing, predicate: RDF::DC.relation, class_name: 'Thing'
+      end
 
       # many-to-many
-      person.class.property :things, predicate: RDF::DC.relation, class_name: 'Thing'
-      subject.class.property :people, predicate: RDF::DC.creator, class_name: 'Person'
-      subject.people << person
+      Thing.property :people, predicate: RDF::DC.creator, class_name: 'Person'
 
       # one-sided has-many
-      subject.class.has_and_belongs_to_many :concepts, inverse_of: nil
-      subject.class.property :concepts, predicate: RDF::DC.subject, class_name: 'Concept'
-      subject.concepts << concept
+      Thing.has_and_belongs_to_many :concepts, inverse_of: nil, autosave: true
+      Thing.property :concepts, predicate: RDF::DC.subject, class_name: 'Concept'
 
       # embedded one
-      part.class.embedded_in :thing
-      part.class.property :thing, predicate: RDF::DC.relation, class_name: 'Thing'
-      subject.class.embeds_one :part, cascade_callbacks: true
-      subject.class.property :part, predicate: RDF::DC.hasPart, class_name: 'Part'
-      subject.part = part
-      subject.save
+      Thing.embeds_one :part, cascade_callbacks: true
+      Thing.property :part, predicate: RDF::DC.hasPart, class_name: 'Part'
     end
 
     after do
-      Object.send(:remove_const, "Person") if Object
+      Object.send(:remove_const, 'Person') if Object
       Object.send(:remove_const, 'Concept') if Object
       Object.send(:remove_const, 'Part') if Object
     end
-
-    it 'should have relations' do
-      expect(subject.people.to_a).to include person
-      expect(subject.concepts.to_a).to include concept
-      expect(subject.part).to eq part
-    end
-
-    it 'should have inverse relations' do
-      expect(person.things.to_a).to include subject
-      expect(concept.relations).to be_empty
-      expect(part.thing).to eq subject
-    end
-
-    context 'with many-to-many' do
-      it 'should have a relation' do
-        expect(subject.relations['people'].relation).to eq (Mongoid::Relations::Referenced::ManyToMany)
-        expect(subject.people.to_a).to include person
-      end
-
-      it 'should have an inverse relation' do
-        expect(person.relations['things'].relation).to eq (Mongoid::Relations::Referenced::ManyToMany)
-        expect(person.things.to_a).to include subject
-      end
-
-      it 'should have a valid predicate' do
-        expect(subject.class.properties['people'].predicate).to eq RDF::DC.creator
-      end
-
-      it 'should have a valid inverse predicate' do
-        expect(person.class.properties['things'].predicate).to eq RDF::DC.relation
-      end
-    end
-
-    context 'with one-sided has-many' do
-      it 'should have a relation' do
-        expect(subject.relations['concepts'].relation).to eq (Mongoid::Relations::Referenced::ManyToMany)
-        expect(subject.concepts.to_a).to include concept
-      end
-
-      it 'should not have an inverse relation' do
-        expect(subject.relations['concepts'].inverse_of).to be nil
-        expect(concept.relations).to be_empty
-      end
-
-      it 'should have a valid predicate' do
-        expect(subject.class.properties['concepts'].predicate).to eq RDF::DC.subject
-      end
-
-      it 'should not have an inverse predicate' do
-        expect(concept.class.properties).to be_empty
-      end
-    end
-
-    context 'with embedded-one' do
-      it 'should have a relation' do
-        expect(subject.relations['part'].relation).to eq (Mongoid::Relations::Embedded::One)
-        expect(subject.part).to eq part
-      end
-
-      it 'should have an inverse relation' do
-        expect(part.relations['thing'].relation).to eq (Mongoid::Relations::Embedded::In)
-        expect(part.thing).to eq subject
-      end
-
-      it 'should have a valid predicate' do
-        expect(subject.class.properties['part'].predicate).to eq RDF::DC.hasPart
-      end
-
-      it 'should have a valid inverse predicate' do
-        expect(part.class.properties['thing'].predicate).to eq RDF::DC.relation
-      end
-    end
-    
-    context '#update_resource with related' do
-      # TODO add tests for autosaved relations
-      before do
-        subject.update_resource(related: true)
-      end
-
-      it 'should have a literal object' do
-        query = subject.resource.query(subject: subject.rdf_subject, predicate: RDF::DC.title)
-        expect(query.first_object.to_s).to eq 'Comet in Moominland'
-      end
-
-      it 'should have an embedded object' do
-        query = subject.resource.query(subject: subject.rdf_subject, predicate: RDF::DC.hasPart)
-        expect(query.count).to eq 1
-        expect(query.first_object).to eq part.rdf_subject
-      end
-
-      it 'should have an embedded object relation' do
-        query = subject.resource.query(subject: part.rdf_subject, predicate: RDF::DC.relation)
-        expect(query.count).to eq 1
-        expect(query.first_object).to eq subject.rdf_subject
-      end
-
-      it 'should have related objects' do
-        # many-to-many
-        query_creator = subject.resource.query(subject: subject.rdf_subject, predicate: RDF::DC.creator)
-        expect(query_creator.count).to eq 1
-        expect(query_creator.first_object).to eq person.rdf_subject
-
-        # one-sided has-many
-        query_subject = subject.resource.query(subject: subject.rdf_subject, predicate: RDF::DC.subject)
-        expect(query_subject.count).to eq 1
-        expect(query_subject.first_object).to eq concept.rdf_subject
-
-        # embedded-one
-        query_part = subject.resource.query(subject: subject.rdf_subject, predicate: RDF::DC.hasPart)
-        expect(query_part.count).to eq 1
-        expect(query_part.first_object).to eq part.rdf_subject
-      end
-
-      it 'should have related object relations' do
-        # many-to-many
-        query = person.resource.query(subject: person.rdf_subject, predicate: RDF::DC.relation)
-        expect(query.count).to eq 1
-        expect(query.first_object).to eq subject.rdf_subject
-        
-        # one-sided has-many
-        expect(concept.resource.query(object: subject.rdf_subject)).to be_empty
-
-        # embedded-one
-        query = part.resource.query(subject: part.rdf_subject, predicate: RDF::DC.relation)
-        expect(query.count).to eq 1
-        expect(query.first_object).to eq subject.rdf_subject
-      end
-    end
-
-    context '#update_resource with related and then without related' do
-      # TODO add tests for autosaved relations
-      before do
-        subject.update_resource(related: true)
-        subject.update_resource # implicit false
-      end
-
-      it 'should not have related objects' do
-        expect(subject.resource.query(subject: person.rdf_subject)).to be_empty
-        expect(subject.resource.query(subject: concept.rdf_subject)).to be_empty
-      end
-      
-      it 'should have embedded object relations' do
-        query = subject.resource.query(subject: part.rdf_subject, predicate: RDF::DC.relation)
-        expect(query.count).to eq 1
-        expect(query.first_object).to eq subject.rdf_subject
-      end
-
-      it 'should have related object relations' do
-        # many-to-many
-        query = person.resource.query(subject: person.rdf_subject, predicate: RDF::DC.relation)
-        expect(query.count).to eq 1
-        expect(query.first_object).to eq subject.rdf_subject
-        
-        # one-sided has-many
-        expect(concept.resource.query(object: subject.rdf_subject)).to be_empty
-
-        # embedded-one
-        query = part.resource.query(subject: part.rdf_subject, predicate: RDF::DC.relation)
-        expect(query.count).to eq 1
-        expect(query.first_object).to eq subject.rdf_subject
-      end
-    end
-
-    context 'serializable' do
-      # TODO: contexts with relations and without
-#      expect(subject.as_jsonld(related: true)).to eq subject.as_jsonld
-#      expect(subject.as_qname(related: true)).to eq subject.as_qname
-#      expect(subject.as_framed_jsonld).to eq subject.as_jsonld
-
-      describe '#as_jsonld related: true' do
-        it 'should output a valid jsonld representation of itself and related' do
-          graph = RDF::Graph.new << JSON::LD::API.toRdf(subject.as_jsonld related: true)
-          expect(subject.update_resource(related: true).to_hash).to eq graph.to_hash
-        end
-      end
-
-      describe '#as_qname related: true' do
-        it 'should output a valid qname representation of itself and related' do
-          # TODO
-        end
-      end
-
-      describe '#as_framed_jsonld' do
-        it 'should output a valid framed jsonld representation of itself and related' do
-          framed_graph = RDF::Graph.new << JSON::LD::API.toRdf(subject.as_framed_jsonld)
-          related_graph = RDF::Graph.new << JSON::LD::API.toRdf(subject.as_jsonld related: true)          
-          expect(framed_graph.to_hash).to eq related_graph.to_hash
-        end
-      end
-    end
-
   end
 
   context 'with data' do
@@ -286,7 +83,31 @@ describe Ladder::Resource do
     include_context 'with data'
     include_context 'with relations'
 
+    before do
+      subject.people << person    # many-to-many
+      subject.concepts << concept # one-sided has-many
+      subject.part = part         # embedded one
+      subject.save
+    end
+
     it_behaves_like 'a Resource'
+    it_behaves_like 'a Resource with relations'
   end
 
-end
+  context 'from JSON-LD' do
+    let(:subject) { Thing.new_from_graph(RDF::Graph.load './spec/shared/graph.jsonld') }
+
+    include_context 'with relations'
+
+    let(:person)  { subject.people.first }
+    let(:concept) { subject.concepts.first }
+    let(:part)    { subject.part }
+
+    before do
+      subject.save
+    end
+
+    it_behaves_like 'a Resource'
+    it_behaves_like 'a Resource with relations'
+  end
+end