ladder 0.2.1 → 0.3.0

data/spec/ladder/searchable/background_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe Ladder::Searchable::Background do
+  before do
+    Mongoid.load!('mongoid.yml', :development)
+    Mongoid.logger.level = Moped.logger.level = Logger::DEBUG
+    Mongoid.purge!
+
+    Elasticsearch::Model.client = Elasticsearch::Client.new host: 'localhost:9200', log: true
+    Elasticsearch::Model.client.indices.delete index: '_all'
+
+    LADDER_BASE_URI ||= 'http://example.org'
+
+    class Thing
+      include Ladder::Resource
+      include Ladder::Searchable::Background
+    end
+    
+    class Datastream
+      include Ladder::File
+      include Ladder::Searchable::Background
+    end
+  end
+
+  after do
+    Object.send(:remove_const, :LADDER_BASE_URI) if Object
+    Object.send(:remove_const, "Thing") if Object
+    Object.send(:remove_const, "Datastream") 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
+  end
+
+  shared_context 'with relations' do
+    before do
+      # related object
+      person.class.configure type: RDF::FOAF.Person
+      person.class.property :foaf_name, predicate: RDF::FOAF.name
+      person.foaf_name = 'Tove Jansson'
+
+      # many-to-many relation
+      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
+    end    
+  end
+
+  context 'with data' do
+    let(:subject) { Thing.new }
+
+    include_context 'with data'
+
+    it_behaves_like 'a Searchable'
+  end
+
+  context 'with relations' do
+    let(:subject) { Thing.new }
+    let(:person)  { Person.new }
+    
+    before do
+      class Person
+        include Ladder::Resource
+        include Ladder::Searchable::Background
+      end
+    end
+
+    after do
+      Object.send(:remove_const, "Person") if Object
+    end
+
+    include_context 'with data'
+    include_context 'with relations'
+
+    it_behaves_like 'a Searchable'
+    it_behaves_like 'a Searchable with related'
+  end
+
+  context 'with data from file' do
+    TEST_FILE ||= './spec/shared/moomin.pdf'
+
+    let(:subject) { Datastream.new file: open(TEST_FILE) }
+    let(:source) { open(TEST_FILE).read } # ASCII-8BIT (binary)
+
+    it_behaves_like 'a Searchable File'
+  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."
+    
+    let(:subject) { Datastream.new }
+    let(:source) { data } # UTF-8 (string)
+
+    before do
+      subject.file = StringIO.new(source)
+    end
+
+    it_behaves_like 'a Searchable File'
+  end
+
+end

data/spec/ladder/{file/searchable_spec.rb → searchable/file_spec.rb}

@@ -9,7 +9,7 @@ describe Ladder::Searchable::File do
     Elasticsearch::Model.client = Elasticsearch::Client.new host: 'localhost:9200', log: true
     Elasticsearch::Model.client.indices.delete index: '_all'
 
-    LADDER_BASE_URI = 'http://example.org'
+    LADDER_BASE_URI ||= 'http://example.org'
 
     class Datastream
       include Ladder::File
@@ -17,34 +17,18 @@ describe Ladder::Searchable::File do
     end
   end
 
-  shared_context 'searchable' do
-    before do
-      subject.save
-      Elasticsearch::Model.client.indices.flush
-    end
-
-    it 'should exist in the index' do
-      results = subject.class.search('Moomin*')
-      expect(results.count).to eq 1
-      expect(results.first.id).to eq subject.id.to_s
-    end
-    
-    it 'should contain full-text content' do
-      results = subject.class.search 'Moomin*', fields: '*'
-      expect(results.count).to eq 1
-      expect(results.first.fields.file.first).to include 'Moomin'
-    end
+  after do
+    Object.send(:remove_const, "Datastream") if Object
   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)
 
     it_behaves_like 'a File'
-
-    include_context 'searchable'
+    it_behaves_like 'a Searchable File'
   end
 
   context 'with data from string after creation' do
@@ -58,11 +42,7 @@ describe Ladder::Searchable::File do
     end
 
     it_behaves_like 'a File'
-
-    include_context 'searchable'
+    it_behaves_like 'a Searchable File'
   end
 
-  after do
-    Object.send(:remove_const, "Datastream") if Object
-  end
 end

data/spec/ladder/searchable/resource_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Ladder::Searchable::Resource do
+  before do
+    Mongoid.load!('mongoid.yml', :development)
+    Mongoid.logger.level = Moped.logger.level = Logger::DEBUG
+    Mongoid.purge!
+
+    Elasticsearch::Model.client = Elasticsearch::Client.new host: 'localhost:9200', log: true
+    Elasticsearch::Model.client.indices.delete index: '_all'
+
+    LADDER_BASE_URI ||= 'http://example.org'
+
+    class Thing
+      include Ladder::Resource
+      include Ladder::Searchable
+    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
+  end
+
+  shared_context 'with relations' do
+    before do
+      # related object
+      person.class.configure type: RDF::FOAF.Person
+      person.class.property :foaf_name, predicate: RDF::FOAF.name
+      person.foaf_name = 'Tove Jansson'
+
+      # many-to-many relation
+      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
+    end    
+  end
+
+  context 'with data' do
+    let(:subject) { Thing.new }
+
+    include_context 'with data'
+
+    it_behaves_like 'a Searchable'
+  end
+
+  context 'with relations' do
+    let(:subject) { Thing.new }
+    let(:person)  { Person.new }
+    
+    before do
+      class Person
+        include Ladder::Resource
+        include Ladder::Searchable
+      end
+    end
+
+    after do
+      Object.send(:remove_const, "Person") if Object
+    end
+
+    include_context 'with data'
+    include_context 'with relations'
+
+    it_behaves_like 'a Searchable with related'
+  end
+
+end

data/spec/shared/file.rb

@@ -2,28 +2,6 @@ require 'mimemagic'
 
 shared_examples 'a File' do
 
-  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
-      
-      # TODO: build some relations of various types
-      # explicit using HABTM
-      # explicit has-one
-    end
-
-    after do
-      Object.send(:remove_const, 'Thing')
-    end
-  end
-
   describe 'LADDER_BASE_URI' do
     it 'should automatically have a base URI' do
       expect(subject.rdf_subject.parent).to eq RDF::URI('http://example.org/datastreams/')
@@ -43,22 +21,22 @@ shared_examples 'a File' do
   end
 
   describe '#save' do
-    it 'should persist' do
-      expect(subject.save).to be true
+    before do
+      subject.save
     end
-  end
 
-  describe '#find' do
     it 'should be retrievable' do
-      subject.save
       found = subject.class.find(subject.id)
-
       expect(found).to eq subject
       expect(found.data).to eq subject.data
       expect(found.data).to eq source.force_encoding(found.data.encoding)
     end
   end
 
+  describe '#grid' do
+    # TODO
+  end
+
   describe '#attributes' do
     before do
       subject.save
@@ -84,31 +62,9 @@ shared_examples 'a File' do
       expect(subject.resource).to eq subject.update_resource
     end
 
-    it 'should not have related object relations' do
-      expect(subject.resource.statements).to be_empty
+    it 'should not have any statements' do
+      expect(subject.update_resource.statements).to be_empty
     end    
   end
 
-  context 'with one-sided has-many' do
-    include_context 'with relations'
-
-    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

data/spec/shared/resource.rb

@@ -1,72 +1,4 @@
 shared_examples 'a Resource' do
-  let(:subject) { Thing.new }
-  let(:person) { Person.new }
-
-  shared_context 'with data' 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
-  end
-
-  shared_context 'with relations' do
-    let(:concept) { Concept.new }
-    let(:part)    { Part.new }
-
-    include_context 'with data'
-    
-    before do
-      class Concept
-        include Ladder::Resource
-      end
-
-      class Part
-        include Ladder::Resource
-      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
-
-      # 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
-
-      # 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
-    end
-
-    after do
-      Object.send(:remove_const, 'Concept')
-      Object.send(:remove_const, 'Part')
-    end
-
-    it 'should have relations' do
-      expect(subject.title).to eq 'Comet in Moominland'
-      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
-  end
 
   describe 'LADDER_BASE_URI' do
     it 'should automatically have a base URI' do
@@ -76,8 +8,6 @@ shared_examples 'a Resource' do
 
   describe '#property' do
     context 'with non-localized literal' do
-      include_context 'with data'
-
       it 'should return non-localized value' do
         expect(subject.alt).to eq 'Mumintrollet pa kometjakt'
       end
@@ -91,14 +21,12 @@ shared_examples 'a Resource' do
       end
 
       it 'allows resetting of properties' do
-        subject.class.property :alt, :predicate => RDF::DC.title
+        subject.class.property :alt, predicate: RDF::DC.title
         expect(subject.class.properties['alt'].predicate).to eq RDF::DC.title
       end
     end
     
     context 'with localized literal' do
-      include_context 'with data'
-      
       it 'should return localized value' do
         expect(subject.title).to eq 'Comet in Moominland'
       end
@@ -112,241 +40,95 @@ shared_examples 'a Resource' do
       end
 
       it 'allows resetting of properties' do
-        subject.class.property :title, :predicate => RDF::DC.alternative
+        subject.class.property :title, predicate: RDF::DC.alternative
         expect(subject.class.properties['title'].predicate).to eq RDF::DC.alternative
       end
     end
+  end
 
-    context 'with many-to-many' do
-      include_context 'with relations'
-
-      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
+  describe '#update_resource' do
+    before do
+      subject.update_resource
     end
 
-    context 'with one-sided has-many' do
-      include_context 'with relations'
-
-      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
+    it 'should have a non-localized literal object' do
+      subject.resource.query(subject: subject.rdf_subject, predicate: RDF::DC.title).each_statement do |s|
+        expect(s.object.to_s).to eq 'Comet in Moominland'
       end
     end
-
-    context 'with embeds-many' do
-      before do
-        subject.class.embeds_many :people
-        subject.class.property :people, :predicate => RDF::DC.creator, :class_name => 'Person'
-
-        person.class.embedded_in :thing
-        person.class.property :thing, :predicate => RDF::DC.relation, :class_name => 'Thing'
-
-        subject.people << person
-      end
-
-      it 'should have a relation' do
-        expect(subject.relations['people'].relation).to eq (Mongoid::Relations::Embedded::Many)
-        expect(subject.people.to_a).to include person
-      end
-
-      it 'should have an inverse relation' do
-        expect(person.relations['thing'].relation).to eq (Mongoid::Relations::Embedded::In)
-        expect(person.thing).to eq subject
-      end
-
-      it 'should have a valid predicate' do
-        expect(subject.class.properties['people'].predicate).to eq RDF::DC.creator
+    
+    it 'should have a localized literal object' do
+      subject.resource.query(subject: subject.rdf_subject, predicate: RDF::DC.alternative).each_statement do |s|
+        expect(s.object.to_s).to eq 'Mumintrollet pa kometjakt'
       end
+    end
 
-      it 'should have a valid inverse predicate' do
-        expect(person.class.properties['thing'].predicate).to eq RDF::DC.relation
-      end
+    it 'should not have related objects' do
+      expect(subject.resource.query(object: subject)).to be_empty
     end
   end
 
-  describe '#update_resource' do
-    context 'without related: true' do
-      include_context 'with relations'
-      
+  describe '#<<' do
+    context 'with defined field' do
       before do
-        subject.update_resource
-      end
-
-      it 'should have a literal object' do
-        subject.resource.query(:subject => subject.rdf_subject, :predicate => RDF::DC.title).each_statement do |s|
-          expect(s.object.to_s).to eq 'Comet in Moominland'
-        end
-      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
-        
-        query.each_statement do |s|
-          expect(s.object).to eq part.rdf_subject
-        end
+        subject << RDF::Statement(nil, RDF::DC.title, 'Kometen kommer')
       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.to_hash).to eq part.resource.statements.to_hash
-
-        query.each_statement do |s|
-          expect(s.object).to eq subject.rdf_subject
-        end
-      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 not have related object relations' do
-        expect(person.resource.statements).to be_empty
-        expect(concept.resource.statements).to be_empty
+    
+      it 'should update existing values' do
+        expect(subject.title).to eq 'Kometen kommer'
       end
     end
 
-    context 'with related: true' do
-      include_context 'with relations'
-      
+    context 'with undefined field' do
       before do
-        subject.update_resource(:related => true)
+        subject << RDF::Statement(nil, RDF::DC.description, "Second in Tove Jansson's series of Moomin books")
       end
 
-      it 'should have a literal object' do
-        subject.resource.query(:subject => subject.rdf_subject, :predicate => RDF::DC.title).each_statement do |s|
-          expect(s.object.to_s).to eq 'Comet in Moominland'
-        end
+      it 'should ignore undefined properties' do
+        expect(subject.fields['description']).to be_nil
+        expect(subject.resource.query(predicate: RDF::DC.description)).to be_empty
       end
+    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
-        
-        query.each_statement do |s|
-          expect(s.object).to eq part.rdf_subject
-        end
+    context 'with a URI value' do
+      before do
+        subject.class.property :identifier, predicate: RDF::DC.identifier
+        subject << RDF::Statement(nil, RDF::DC.identifier, RDF::URI('http://some.uri'))
       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.to_hash).to eq part.resource.statements.to_hash
-
-        query.each_statement do |s|
-          expect(s.object).to eq subject.rdf_subject
-        end
+    
+      it 'should store the URI as a string' do
+        expect(subject.identifier).to eq 'http://some.uri'
       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
-
-        query_creator.each_statement do |s|
-          expect(s.object).to eq person.rdf_subject
-        end
-
-        # one-sided has-many
-        query_subject = subject.resource.query(:subject => subject.rdf_subject, :predicate => RDF::DC.subject)
-        expect(query_subject.count).to eq 1
-
-        query_subject.each_statement do |s|
-          expect(s.object).to eq concept.rdf_subject
-        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
 
-      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.to_hash).to eq person.resource.statements.to_hash
-
-        query.each_statement do |s|
-          expect(s.object).to eq subject.rdf_subject
-        end
-        
-        # one-sided has-many
-        expect(subject.resource.query(:subject => concept.rdf_subject)).to be_empty
-        expect(concept.resource.statements).to be_empty
-      end
+  describe '#rdf_label' do
+    it 'should return the default label' do
+      expect(subject.rdf_label.to_a).to eq ['Comet in Moominland']
     end
+  end
 
-    context 'with related and then without related' do
-      include_context 'with relations'
-      
-      before do
-        subject.update_resource(:related => true)
-        subject.update_resource
-      end
+  context 'a serializable' do
 
-      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
+    describe '#as_jsonld' do
+      it 'should output a valid jsonld representation of itself' do
+        graph = RDF::Graph.new << JSON::LD::API.toRdf(subject.as_jsonld)
+        expect(subject.update_resource.to_hash).to eq graph.to_hash
       end
+    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.to_hash).to eq person.resource.statements.to_hash
-
-        query.each_statement do |s|
-          expect(s.object).to eq subject.rdf_subject
-        end
-        
-        # one-sided has-many
-        expect(subject.resource.query(:subject => concept.rdf_subject)).to be_empty
-        expect(concept.resource.statements).to be_empty
+    describe '#as_qname' do
+      it 'should output a valid qname representation of itself' do
+        # TODO
       end
     end
-  end
-  
-  describe '#as_jsonld' do
-    include_context 'with relations'
-    
-    it 'should output a valid jsonld representation of itself' do
-      g = RDF::Graph.new << JSON::LD::API.toRdf(subject.as_jsonld)
-      expect(subject.resource.to_hash == g.to_hash).to be true
-    end
-  end
-  
-  describe '#rdf_label' do
-    include_context 'with data'
 
-    it 'should return the default label' do
-      expect(subject.rdf_label.to_a).to eq ['Comet in Moominland']
-    end
   end
 
 end