ladder 0.0.3 → 0.0.4

data/lib/ladder/resource.rb

@@ -0,0 +1,80 @@
+require 'mongoid'
+require 'active_triples'
+require 'json/ld'
+
+module Ladder::Resource
+  extend ActiveSupport::Concern
+
+  include Mongoid::Document
+  include ActiveTriples::Identifiable
+
+  included do
+    configure base_uri: RDF::URI.new(LADDER_BASE_URI) / name.underscore.pluralize if defined? LADDER_BASE_URI
+  end
+
+  ##
+  # Convenience method to return JSON-LD representation
+  #
+  def as_jsonld(opts = {})
+    update_resource(opts.slice :related).dump(:jsonld, {standard_prefixes: true}.merge(opts))
+  end
+
+  ##
+  # Overload ActiveTriples #update_resource
+  #
+  # @see ActiveTriples::Identifiable
+  def update_resource(opts = {})
+    relation_hash = opts[:related] ? relations : embedded_relations
+
+    super() do |name, prop|
+      object = self.send(prop.term)
+      next if object.nil?
+
+      objects = object.is_a?(Enumerable) ? object : [object]
+
+      values = objects.map do |obj|
+        if obj.is_a?(ActiveTriples::Identifiable)
+          if relation_hash.keys.include? name
+            obj.update_resource
+            obj.resource.set_value(relation_hash[name].inverse, self.rdf_subject) if relation_hash[name].inverse
+            obj
+          else
+            resource.delete [obj.rdf_subject] if resource.enum_subjects.include? obj.rdf_subject and ! opts[:related]
+            obj.rdf_subject
+          end
+        else
+          if fields[name].localized?
+            read_attribute(name).map { |lang, val| RDF::Literal.new(val, language: lang) }
+          else
+            obj
+          end
+        end
+      end
+
+      resource.set_value(prop.predicate, values.flatten)      
+    end
+
+    resource
+  end
+
+  module ClassMethods
+    
+    ##
+    # Overload ActiveTriples #property
+    #
+    # @see ActiveTriples::Properties
+    def property(name, opts={})
+      if class_name = opts[:class_name]
+        mongoid_opts = opts.except(:predicate, :multivalue).merge(autosave: true)
+        opts.except! *mongoid_opts.keys
+
+        has_and_belongs_to_many(name, mongoid_opts) unless relations.keys.include? name.to_s
+      else
+        field(name, localize: true)
+      end
+
+      super
+    end
+  end
+
+end

data/lib/ladder/searchable.rb

@@ -0,0 +1,53 @@
+require 'ladder/resource'
+require 'elasticsearch/model'
+require 'elasticsearch/model/callbacks'
+
+module Ladder::Searchable
+  extend ActiveSupport::Concern
+
+  included do
+    include Elasticsearch::Model
+    include Elasticsearch::Model::Callbacks
+  end
+
+  ##
+  # Generate a qname-based JSON representation
+  #
+  def as_qname
+    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
+        qname_hash[ns][name] = object.to_a.map { |obj| "#{obj.class.name.underscore.pluralize}:#{obj.id}" }
+      elsif fields.keys.include? field_name
+        qname_hash[ns][name] = read_attribute(field_name)
+      end
+    end
+
+    qname_hash
+  end
+
+  module ClassMethods
+
+    ##
+    # Specify type of serialization to use for indexing
+    #
+    def index(opts={})
+      case opts[:as]
+      when :jsonld
+        define_method(:as_indexed_json) { |opts = {}| as_jsonld }
+      when :qname
+        define_method(:as_indexed_json) { |opts = {}| as_qname }
+      else
+        define_method(:as_indexed_json) { |opts = {}| as_json(except: ['id', '_id']) }
+      end
+    end
+
+  end
+    
+end

data/lib/ladder/version.rb

@@ -0,0 +1,3 @@
+module Ladder
+  VERSION = "0.0.4"
+end

data/lib/ladder.rb

@@ -0,0 +1,6 @@
+require "ladder/version"
+
+module Ladder
+  autoload :Resource, 'ladder/resource'
+  autoload :Searchable, 'ladder/searchable'
+end

data/mongoid.yml

@@ -0,0 +1,6 @@
+development:
+  sessions:
+    default:
+      database: ladder
+      hosts:
+        - localhost:27017

data/spec/ladder/resource_spec.rb

@@ -0,0 +1,305 @@
+require 'spec_helper'
+require 'pry'
+
+describe Ladder::Resource do
+  before do
+    Mongoid.load!('mongoid.yml', :development)
+    Mongoid.logger.level = Moped.logger.level = Logger::DEBUG
+    Mongoid.purge!
+
+    LADDER_BASE_URI = 'http://example.org'
+
+    class Thing
+      include Ladder::Resource
+    end
+
+    class Person
+      include Ladder::Resource
+    end
+  end
+  
+  after do
+    Object.send(:remove_const, :LADDER_BASE_URI) if Object
+    Object.send(:remove_const, "Thing") if Object
+    Object.send(:remove_const, "Person") if Object
+  end
+
+  subject { Thing.new }
+  let(:person) { Person.new }
+
+  shared_context 'with data' do
+    let(:concept) { Concept.new }
+    let(:part)    { Part.new }
+    
+    before do
+      class Concept
+        include Ladder::Resource
+      end
+
+      class Part
+        include Ladder::Resource
+        embedded_in :thing
+        property :thing, :predicate => RDF::DC.relation, :class_name => 'Thing'
+      end
+
+      # localized literal
+      subject.class.property :title, :predicate => RDF::DC.title
+      subject.title = 'Comet in Moominland'
+
+      # 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 many
+      subject.class.embeds_many :parts, cascade_callbacks: true
+      subject.class.property :parts, :predicate => RDF::DC.hasPart, :class_name => 'Part'
+      subject.parts << 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.parts.to_a).to include part
+    end
+    
+    it 'should have reverse 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
+      expect(subject.rdf_subject.parent).to eq RDF::URI('http://example.org/things/')
+    end
+  end
+
+  describe '#property' do
+    context 'with localized literal' do
+      before do
+        subject.class.property :title, :predicate => RDF::DC.title
+        subject.title = 'Comet in Moominland'
+      end
+      
+      it 'should return localized value' do
+        expect(subject.title).to eq 'Comet in Moominland'
+      end
+      
+      it 'should return all locales' do
+        expect(subject.attributes['title']).to eq Hash({'en' => 'Comet in Moominland'})
+      end
+      
+      it 'should have a valid predicate' do
+        expect(subject.class.properties).to include 'title'
+        expect(t = subject.class.properties['title']).to be_a ActiveTriples::NodeConfig
+        expect(t.predicate).to eq RDF::DC.title
+      end
+    end
+
+    context 'with many-to-many' do
+      before do
+        subject.class.property :people, :predicate => RDF::DC.creator, :class_name => 'Person'
+        person.class.property :things, :predicate => RDF::DC.relation, :class_name => 'Thing'
+        subject.people << person
+        subject.save
+      end
+
+      it 'should have a relation' do
+        expect(subject.relations).to include 'people'
+        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).to include 'things'
+        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).to include 'people'
+        expect(t = subject.class.properties['people']).to be_a ActiveTriples::NodeConfig
+        expect(t.predicate).to eq RDF::DC.creator
+      end
+
+      it 'should have a valid inverse predicate' do
+        expect(person.class.properties).to include 'things'
+        expect(t = person.class.properties['things']).to be_a ActiveTriples::NodeConfig
+        expect(t.predicate).to eq RDF::DC.relation
+      end
+    end
+
+    context 'with one-sided has-many' do
+      before do
+        subject.class.has_and_belongs_to_many :people, inverse_of: nil
+        subject.class.property :people, :predicate => RDF::DC.creator, :class_name => 'Person'
+        subject.people << person
+      end
+
+      it 'should have a relation' do
+        expect(subject.relations).to include 'people'
+        expect(subject.relations['people'].relation).to eq (Mongoid::Relations::Referenced::ManyToMany)
+        expect(subject.people.to_a).to include person
+      end
+
+      it 'should not have an inverse relation' do
+        expect(subject.relations['people'].inverse_of).to be nil
+        expect(person.relations).to be_empty
+      end
+
+      it 'should have a valid predicate' do
+        expect(subject.class.properties).to include 'people'
+        expect(t = subject.class.properties['people']).to be_a ActiveTriples::NodeConfig
+        expect(t.predicate).to eq RDF::DC.creator
+      end
+
+      it 'should not have an inverse predicate' do
+        expect(person.class.properties).to be_empty
+      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).to include 'people'
+        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).to include 'thing'
+        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).to include 'people'
+        expect(t = subject.class.properties['people']).to be_a ActiveTriples::NodeConfig
+        expect(t.predicate).to eq RDF::DC.creator
+      end
+
+      it 'should have a valid inverse predicate' do
+        expect(person.class.properties).to include 'thing'
+        expect(t = person.class.properties['thing']).to be_a ActiveTriples::NodeConfig
+        expect(t.predicate).to eq RDF::DC.relation
+      end
+    end  
+  end
+
+  describe '#update_resource' do
+
+    context 'without related: true' do
+      include_context 'with data'
+      
+      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
+        subject.resource.query(:subject => part.rdf_subject, :predicate => RDF::DC.relation).each_statement do |s|
+          expect(s.object).to eq subject.rdf_subject
+        end
+      end
+
+      it 'should have an embedded object relation' do
+        subject.resource.query(:subject => subject.rdf_subject, :predicate => RDF::DC.hasPart).each_statement do |s|
+          expect(s.object).to eq part.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
+      end
+    end
+
+    context 'with related: true' do
+      include_context 'with data'
+      
+      before do
+        subject.update_resource(:related => true)
+      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
+        subject.resource.query(:subject => part.rdf_subject, :predicate => RDF::DC.relation).each_statement do |s|
+          expect(s.object).to eq subject.rdf_subject
+        end
+      end
+
+      it 'should have an embedded object relation' do
+        subject.resource.query(:subject => subject.rdf_subject, :predicate => RDF::DC.hasPart).each_statement do |s|
+          expect(s.object).to eq part.rdf_subject
+        end
+      end
+
+      it 'should have related objects' do
+        subject.resource.query(:subject => subject.rdf_subject, :predicate => RDF::DC.subject).each_statement do |s|
+          expect(s.object).to eq concept.rdf_subject
+        end
+        subject.resource.query(:subject => subject.rdf_subject, :predicate => RDF::DC.creator).each_statement do |s|
+          expect(s.object).to eq person.rdf_subject
+        end
+      end
+
+      it 'should have related object relations' do
+        person.resource.query(:subject => person.rdf_subject, :predicate => RDF::DC.relation).each_statement do |s|
+          expect(s.object).to eq subject.rdf_subject
+        end
+      end
+    end
+  end
+  
+  describe '#as_jsonld' do
+    include_context 'with data'
+    
+    before do
+      subject.update_resource
+    end
+    
+    it 'should output a valid jsonld representation of itself' do
+      g = RDF::Graph.new << JSON::LD::API.toRdf(JSON.parse subject.as_jsonld)
+      expect(subject.resource.to_hash == g.to_hash).to be true
+    end
+  end
+
+end

data/spec/ladder/searchable_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+require 'pry'
+
+describe Ladder::Searchable 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
+
+    class Person
+      include Ladder::Resource
+      include Ladder::Searchable
+    end
+  end
+  
+  after do
+    Object.send(:remove_const, "Thing") if Object
+    Object.send(:remove_const, "Person") if Object
+  end
+
+  subject { Thing.new }
+  let(:person) { Person.new }
+
+  shared_context 'with data' do
+    before do
+      subject.class.configure type: RDF::DC.BibliographicResource
+      subject.class.property :title, :predicate => RDF::DC.title
+      subject.title = 'Comet in Moominland'
+    end
+  end
+
+  describe '#index' do
+    include_context 'with data'
+
+    context 'with default' do
+      before do
+        subject.class.index
+        subject.save
+        Elasticsearch::Model.client.indices.flush
+      end
+
+      it 'should exist in the index' do
+        results = subject.class.search('title:moomin*')
+        expect(results.count).to eq 1
+        expect(results.first._source.to_hash).to eq JSON.parse(subject.as_indexed_json.to_json)
+      end
+    end
+
+    context 'with as qname' do
+      before do
+        subject.class.index as: :qname
+        subject.save
+        Elasticsearch::Model.client.indices.flush
+      end
+
+      it 'should exist in the index' do
+        results = subject.class.search('dc.title.en:moomin*')
+        expect(results.count).to eq 1
+        expect(results.first._source.to_hash).to eq JSON.parse(subject.as_qname.to_json)
+      end
+    end
+
+    context 'with as jsonld' do
+      before do
+        subject.class.index as: :jsonld
+        subject.save
+        Elasticsearch::Model.client.indices.flush
+      end
+      
+      it 'should exist in the index' do
+        results = subject.class.search('dc\:title.@value:moomin*')
+        expect(results.count).to eq 1
+        expect(results.first._source.to_hash).to eq JSON.parse(subject.as_jsonld)
+      end
+    end  
+  end
+
+  describe '#index with related' do
+    include_context 'with data'
+    
+    before do
+      # related object
+      person.class.configure type: RDF::FOAF.Person
+      person.class.property :name, :predicate => RDF::FOAF.name
+      person.class.property :things, :predicate => RDF::DC.relation, :class_name => 'Thing'
+      person.name = 'Tove Jansson'
+
+      # many-to-many relation
+      subject.class.property :people, :predicate => RDF::DC.creator, :class_name => 'Person'
+      subject.people << person
+    end
+
+    context 'with default' do
+      before do
+        person.class.index
+        subject.class.index
+        subject.save
+        Elasticsearch::Model.client.indices.flush
+      end
+
+      it 'should contain an ID for the related object' do
+        results = subject.class.search('person_ids.$oid:' + person.id)
+        expect(results.count).to eq 1
+      end
+
+      it 'should include the related object in the index' do
+        results = person.class.search('name:tove')
+        expect(results.count).to eq 1
+        expect(results.first._source.to_hash).to eq JSON.parse(person.as_indexed_json.to_json)
+      end
+
+      it 'should contain an ID for the subject' do
+        results = person.class.search('thing_ids.$oid:' + subject.id)
+        expect(results.count).to eq 1
+      end
+    end
+
+    context 'with as qname' do
+      before do
+        person.class.index as: :qname
+        subject.class.index as: :qname
+        subject.save
+        Elasticsearch::Model.client.indices.flush
+      end
+
+      it 'should contain an ID for the related object' do
+        results = subject.class.search('dc.creator:' + person.id)
+        expect(results.count).to eq 1
+      end
+
+      it 'should include the related object in the index' do
+        results = person.class.search('foaf.name.en:tove')
+        expect(results.count).to eq 1
+        expect(results.first._source.to_hash).to eq JSON.parse(person.as_qname.to_json)
+      end
+
+      it 'should contain an ID for the subject' do
+        results = person.class.search('dc.relation:' + subject.id)
+        expect(results.count).to eq 1
+      end
+    end
+
+    context 'with as_jsonld' do
+      before do
+        person.class.index as: :jsonld
+        subject.class.index as: :jsonld
+        subject.save
+        Elasticsearch::Model.client.indices.flush
+      end
+      
+      it 'should contain an ID for the related object' do
+        results = subject.class.search('dc\:creator.@id:' + person.id)
+        expect(results.count).to eq 1
+      end
+
+      it 'should include the related object in the index' do
+        results = person.class.search('foaf\:name.@value:tove')
+        expect(results.count).to eq 1
+        expect(results.first._source.to_hash).to eq JSON.parse(person.as_jsonld)
+      end
+
+      it 'should contain an ID for the subject' do
+        results = person.class.search('dc\:relation.@id:' + subject.id)
+        expect(results.count).to eq 1
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,15 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'ladder'
+
+RSpec.configure do |config|
+  config.color = true
+  config.tty = true
+  
+  # Uncomment the following line to get errors and backtrace for deprecation warnings
+  # config.raise_errors_for_deprecations!
+
+  # Use the specified formatter
+  config.formatter = :documentation
+end