ladder 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ec1270a31250bb0419ba153d1dee8db81788bed7
-  data.tar.gz: ffb8adb9b1ab0adcd83ff542642ebbb6342d4572
+  metadata.gz: c7375d4f5b507945381d998d3965f4cdcc8e585e
+  data.tar.gz: 01b3d742e5457614366c60d083715fea84b09cc4
 SHA512:
-  metadata.gz: 041d289b8105df18cb2dd1f3728a513abc5964807950bf6927ea2b73d85a9e2a060a9f962bf419b18260627554aa895028695c9857e08f3183334e208dc1b32e
-  data.tar.gz: 73f4d0acec4fadc96c77c29302a58ab2cdd7d2309e69fc3f29df6a6794b645d5888ad350d0cc25263fba7d083aa58583ba7966df8cecbcf23ed920eed6bb5f3d
+  metadata.gz: dbca5ae82c1668d8faa094d75b4a09f1c63bc882af0f057231ecf228d79044895f9b8a813b962a3f981ff974f9cf20855146fd0126c1a31c9abcc4872f9106db
+  data.tar.gz: 5981572185f3939e1f25843e50b9306d1bb3ec8937e16d11ad90d08e28027e5b755023294965ce8de7d9a8574cc395e7e5f4e2b6b4c7bff4e5a420624e169733

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.1.1
+#  - jruby-19mode
+# uncomment this line if your project needs to run something other than `rake`:
+script: bundle exec rspec spec
+services:
+  - mongodb
+  - elasticsearch
+before_script:
+  - sleep 15

data/README.md

@@ -1,11 +1,13 @@
 ![Ladder logo](https://github.com/mjsuhonos/ladder/blob/master/logo.png)
+[![Gem Version](http://img.shields.io/gem/v/ladder.svg)](https://rubygems.org/gems/ladder) [![Build Status](https://travis-ci.org/mjsuhonos/ladder.svg)](https://travis-ci.org/mjsuhonos/ladder)
+
 # Ladder
 
-Ladder is a highly scalable metadata framework written in Ruby using well-known components for Linked Data ([ActiveTriples](https://github.com/no-reply/ActiveTriples)/RDF.rb), persistence ([Mongoid](http://mongoid.org)/MongoDB), indexing ([ElasticSearch](http://www.elasticsearch.org)), asynchronicity ([Sidekiq](http://sidekiq.org)/Redis) and HTTP interaction ([Padrino](http://www.padrinorb.com)/Sinatra).  It is designed around the following philosophical goals:
+Ladder is a dynamic, scalable metadata framework written in Ruby using well-known components for Linked Data ([ActiveTriples](https://github.com/no-reply/ActiveTriples)/RDF.rb), persistence ([Mongoid](http://mongoid.org)/MongoDB), indexing ([ElasticSearch](http://www.elasticsearch.org)), asynchronicity ([Sidekiq](http://sidekiq.org)/Redis) and HTTP interaction ([Padrino](http://www.padrinorb.com)/Sinatra).  It is designed around the following philosophical goals:
 
-- make it as modular (eg. the Ruby Way) as possible
-- use as much commodity (ie. non-LAM-specific) tooling as possible
-- make it as easy to use (ie. little programming required) as possible
+- make it as modular as possible
+- use as much commodity tooling as possible
+- make it as easy to use as possible
 
 ## History
 
@@ -13,9 +15,7 @@ Ladder was loosely conceived over the course of several years prior to 2011.  In
 
 From mid-2014, Ladder is being re-architected as a series of Ruby modules that can be used individually and incorporated within existing Ruby frameworks (eg. [Project Hydra](http://projecthydra.org)), or used together as a comprehensive stack.  Ladder is intended to encourage the LAM community to think less dogmatically about our established (often monolithic and/or niche) toolsets and instead embrace a broader vision of using non-LAM specific technologies.
 
-### There's Not Much Here!
-
-The original [prototype](https://github.com/mjsuhonos/ladder/tree/prototype) branch is available, as is an [experimental](https://github.com/mjsuhonos/ladder/tree/l2) branch.  Core functionality is being refactored as modules in the "ladder" gem (see below).
+For those interested in the historical code, the original [prototype](https://github.com/mjsuhonos/ladder/tree/prototype) branch is available, as is an [experimental](https://github.com/mjsuhonos/ladder/tree/l2) branch.
 
 ## Installation
 
@@ -35,11 +35,12 @@ Or install it yourself as:
 
 ## Usage
 
-* [Ladder::Resource](#ladderresource)
+* [Resources](#resource)
   * [Configuring Resources](#configuring-resources)
-* [Ladder::Searchable](#laddersearchable)
+  * [Dynamic Resources](#dynamic-resources)
+* [Indexing for Search](#indexing-for-search)
 
-### Ladder::Resource
+### Resources
 
 Much like ActiveTriples, Resources are the core of Ladder.  Resources implement all the functionality of a Mongoid::Document and an ActiveTriples::Resource.  To add Ladder integration for your model, require 
 and include the main module in your class:
@@ -52,16 +53,16 @@ class Person
 
   configure type: RDF::FOAF.Person
 
-  property :name, predicate: RDF::FOAF.name
+  property :first_name, predicate: RDF::FOAF.name
   property :description, predicate: RDF::DC.description
 end
 
 steve = Person.new
-steve.name = 'Steve'
+steve.first_name = 'Steve'
 steve.description = 'Funny-looking'
 
 steve.as_document
- => {"_id"=>BSON::ObjectId('542f0c124169720ea0000000'), "name"=>{"en"=>"Steve"}, "description"=>{"en"=>"Funny-looking"}}
+ => {"_id"=>BSON::ObjectId('542f0c124169720ea0000000'), "first_name"=>{"en"=>"Steve"}, "description"=>{"en"=>"Funny-looking"}}
 
 steve.as_jsonld
  # => {
@@ -90,7 +91,7 @@ class Person
 
   configure type: RDF::FOAF.Person
 
-  property :name, predicate: RDF::FOAF.name
+  property :first_name, predicate: RDF::FOAF.name
   property :books, predicate: RDF::FOAF.made, class_name: 'Book'
 end
 
@@ -106,8 +107,8 @@ end
 b = Book.new(title: 'Heart of Darkness')
 => #<Book _id: 542f28d44169721941000000, title: {"en"=>"Heart of Darkness"}, person_ids: nil>
 
-b.people << Person.new(name: 'Joseph Conrad')
-=> [#<Person _id: 542f28dd4169721941010000, name: {"en"=>"Joseph Conrad"}, book_ids: [BSON::ObjectId('542f28d44169721941000000')]>]
+b.people << Person.new(first_name: 'Joseph Conrad')
+=> [#<Person _id: 542f28dd4169721941010000, first_name: {"en"=>"Joseph Conrad"}, book_ids: [BSON::ObjectId('542f28d44169721941000000')]>]
 
 b.as_jsonld
  # => {
@@ -170,7 +171,7 @@ class Person
 
   configure type: RDF::FOAF.Person
 
-  property :name, predicate: RDF::FOAF.name
+  property :first_name, predicate: RDF::FOAF.name
 
   embeds_one :address, class_name: 'Place'
   property :address, predicate: RDF::FOAF.based_near
@@ -188,8 +189,8 @@ class Place
   property :resident, predicate: RDF::VCARD.agent
 end
 
-steve = Person.new(name: 'Steve')
-=> #<Person _id: 542f341e41697219a2000000, name: {"en"=>"Steve"}, address: nil>
+steve = Person.new(first_name: 'Steve')
+=> #<Person _id: 542f341e41697219a2000000, first_name: {"en"=>"Steve"}, address: nil>
 
 steve.address = Place.new(city: 'Toronto', country: 'Canada')
 => #<Place _id: 542f342741697219a2010000, city: {"en"=>"Toronto"}, country: {"en"=>"Canada"}, resident: nil>
@@ -233,7 +234,7 @@ steve.as_jsonld
 
 Note in this case that both objects are included in the RDF graph, thanks to embedded relations. This can be useful to avoid additional queries to the database for objects that are tightly coupled.
 
-### Configuring Resources
+#### Configuring Resources
 
 If the LADDER_BASE_URI global constant is set, base URIs are dynamically generated based on the name of the model class.  However, you can still set the base URI for a class explicitly just as you would in ActiveTriples:
 
@@ -249,7 +250,93 @@ Person.resource_class.base_uri
 => "http://some.other.uri/"
 ```
 
-### Ladder::Searchable
+#### Dynamic Resources
+
+In line with ActiveTriples' [Open Model](https://github.com/ActiveTriples/ActiveTriples#open-model) design, you can define properties on any Resource instance similarly to how you would on the class:
+
+```ruby
+class Person
+  include Ladder::Resource::Dynamic
+
+  configure type: RDF::FOAF.Person
+
+  property :first_name, predicate: RDF::FOAF.name
+end
+
+steve = Person.new(first_name: 'Steve')
+
+steve.description
+=> NoMethodError: undefined method 'description' for #<Person:0x007fb54eb1d0b8>
+
+steve.property :description, predicate: RDF::DC.description
+steve.description = 'Funny-looking'
+
+steve.as_document
+=> {"_id"=>BSON::ObjectId('546669234169720397000000'),
+ "first_name"=>{"en"=>"Steve"},
+ "_context"=>{:description=>"http://purl.org/dc/terms/description"},
+ "description"=>"Funny-looking"}
+
+steve.as_jsonld
+ # => {
+ #    "@context": {
+ #        "dc": "http://purl.org/dc/terms/",
+ #        "foaf": "http://xmlns.com/foaf/0.1/"
+ #    },
+ #    "@id": "http://example.org/people/546669234169720397000000",
+ #    "@type": "foaf:Person",
+ #    "dc:description": "Funny-looking",
+ #    "foaf:name": {
+ #        "@language": "en",
+ #        "@value": "Steve"
+ #  }
+```
+
+Additionally, you can push RDF statements into a Resource instance like you would with ActiveTriples or RDF::Graph, noting that the subject is ignored since it is implicit:
+
+```ruby
+steve << RDF::Statement(nil, RDF::DC.description, 'Tall, dark, and handsome')
+steve << RDF::Statement(nil, RDF::FOAF.depiction, RDF::URI('http://some.image/pic.jpg'))
+steve << RDF::Statement(nil, RDF::FOAF.age, 32)
+
+steve.as_document
+=> {"_id"=>BSON::ObjectId('546669234169720397000000'),
+ "first_name"=>{"en"=>"Steve"},
+ "_context"=>
+  {:description=>"http://purl.org/dc/terms/description",
+   :depiction=>"http://xmlns.com/foaf/0.1/depiction",
+   :age=>"http://xmlns.com/foaf/0.1/age"},
+ "description"=>"Tall, dark, and handsome",
+ "depiction"=>"http://some.image/pic.jpg",
+ "age"=>32}
+
+steve.as_jsonld
+ # => {
+ #    "@context": {
+ #        "dc": "http://purl.org/dc/terms/",
+ #        "foaf": "http://xmlns.com/foaf/0.1/",
+ #        "xsd": "http://www.w3.org/2001/XMLSchema#"
+ #    },
+ #    "@id": "http://example.org/people/546669234169720397000000",
+ #    "@type": "foaf:Person",
+ #    "dc:description": "Tall, dark, and handsome",
+ #    "foaf:age": {
+ #        "@type": "xsd:integer",
+ #        "@value": "32"
+ #    },
+ #    "foaf:depiction": {
+ #        "@id": "http://some.image/pic.jpg"
+ #    },
+ #    "foaf:name": {
+ #        "@language": "en",
+ #        "@value": "Steve"
+ #    }
+ #	}
+```
+
+Note that due to the way Mongoid handles dynamic fields, dynamic properties **can not** be localized.  They can be any kind of literal, but they **can not** be a related object. They can, however, contain a reference to the related object's URI.
+
+### Indexing for Search
 
 You can also index your model classes for keyword searching through ElasticSearch by mixing in the Ladder::Searchable module:
 
@@ -260,23 +347,23 @@ class Person
 
   configure type: RDF::FOAF.Person
 
-  property :name, predicate: RDF::FOAF.name
+  property :first_name, predicate: RDF::FOAF.name
   property :description, predicate: RDF::DC.description
 end
 
 kimchy = Person.new
-kimchy.name = 'Shay'
+kimchy.first_name = 'Shay'
 kimchy.description = 'Real genius'
 ```
 
-In order to enable indexing, call the `#index` method on the class:
+In order to enable indexing, call the `#index_for_search` method on the class:
 
 ```ruby
-Person.index
+Person.index_for_search
 => :as_indexed_json
 
 kimchy.as_indexed_json
-=> {"description"=>"Real genius", "name"=>"Shay"}
+=> {"description"=>"Real genius", "first_name"=>"Shay"}
 
 kimchy.save
 => true
@@ -294,7 +381,7 @@ results.count
 => 1
 
 results.first._source
-=> {"description"=>"Real genius", "name"=>"Shay"}
+=> {"description"=>"Real genius", "first_name"=>"Shay"}
 
 results.records.first == kimchy
 => true
@@ -303,7 +390,7 @@ results.records.first == kimchy
 When indexing, you can control how your model is stored in the index by supplying the `as: :jsonld` or `as: :qname` options:
 
 ```ruby
-Person.index as: :jsonld
+Person.index_for_search as: :jsonld
 => :as_indexed_json
 
 kimchy.as_indexed_json
@@ -324,7 +411,7 @@ kimchy.as_indexed_json
  #   }
  # }
 
-Person.index as: :qname
+Person.index_for_search as: :qname
 => :as_indexed_json
 
 kimchy.as_indexed_json
@@ -350,20 +437,20 @@ class Project
 
   configure type: RDF::DOAP.Project
 
-  property :name, predicate: RDF::DOAP.name
+  property :project_name, predicate: RDF::DOAP.name
   property :description, predicate: RDF::DC.description
   property :developers, predicate: RDF::DOAP.developer, class_name: 'Person'
 end
 
 Person.property :projects, predicate: RDF::FOAF.made, class_name: 'Project'
 
-es = Project.new(name: 'ElasticSearch', description: 'You know, for search')
+es = Project.new(project_name: 'ElasticSearch', description: 'You know, for search')
 es.developers << kimchy
 es.save
 
-Person.index as: :jsonld, related: true
+Person.index_for_search as: :jsonld, related: true
 => :as_indexed_json
-Project.index as: :jsonld, related: true
+Project.index_for_search as: :jsonld, related: true
 => :as_indexed_json
 
 kimchy.as_indexed_json
@@ -434,9 +521,9 @@ es.as_indexed_json
  #    }
  # }
 
-Person.index as: :qname, related: true
+Person.index_for_search as: :qname, related: true
 => :as_indexed_json
-Project.index as: :qname, related: true
+Project.index_for_search as: :qname, related: true
 => :as_indexed_json
 
 kimchy.as_indexed_json

data/ladder.gemspec

@@ -24,10 +24,10 @@ Gem::Specification.new do |spec|
   spec.add_dependency "active-triples", "~> 0.3"
   spec.add_dependency "elasticsearch-model", "~> 0.1"
   
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "pry"
-  spec.add_development_dependency "wirble"
-  spec.add_development_dependency "rspec"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "yard"
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_development_dependency "wirble", "~> 0.1"
+  spec.add_development_dependency "rspec", "~> 3.1"
+  spec.add_development_dependency "rake", "~> 10.3"
+  spec.add_development_dependency "yard", "~> 0.8"
 end

data/lib/ladder/resource.rb

@@ -8,6 +8,8 @@ module Ladder::Resource
   include Mongoid::Document
   include ActiveTriples::Identifiable
 
+  autoload :Dynamic, 'ladder/resource/dynamic'
+
   included do
     configure base_uri: RDF::URI.new(LADDER_BASE_URI) / name.underscore.pluralize if defined? LADDER_BASE_URI
   end
@@ -20,45 +22,59 @@ module Ladder::Resource
     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
+
   ##
   # Overload ActiveTriples #update_resource
   #
   # @see ActiveTriples::Identifiable
   def update_resource(opts = {})
     super() do |name, prop|
-      # this is a literal property
-      if field_def = fields[name]
-        if field_def.localized?
-          value = read_attribute(name).map { |lang, val| RDF::Literal.new(val, language: lang) }
-        else
-          value = self.send(prop.term)
-        end
-      end
-      
-      # this is a relation property
-      if relation_def = relations[name]
-        objects = self.send(prop.term).to_a
-
-        if opts[:related] or embedded_relations[name]
-          value = objects.map(&:update_resource)
-
-          # update inverse relation properties
-          objects.each { |object| object.resource.set_value(relation_def.inverse, self.rdf_subject) } if relation_def.inverse
-        else
-          value = objects.map(&:rdf_subject)
-          
-          # remove inverse relation properties
-          objects.each { |object| resource.delete [object.rdf_subject] }
-        end
-
-      end
+      value = update_from_field(name) if fields[name] # this is a literal property
+      value = update_from_relation(name, opts) if relations[name] # this is a relation property
 
-      resource.set_value(prop.predicate, value)
+      cast_uri = RDF::URI.new(value)
+      resource.set_value(prop.predicate, cast_uri.valid? ? cast_uri : value) if value
     end
 
     resource
   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?
+      else
+        self.send(name)
+      end
+    end
+    
+    def update_from_relation(name, opts = {})
+      objects = self.send(name).to_a
+
+      if opts[:related] or embedded_relations[name]
+        # 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
+        objects.map(&:update_resource)
+      else
+        # remove inverse relation properties
+        objects.each { |object| resource.delete [object.rdf_subject] }
+        objects.map(&:rdf_subject)
+      end
+    end
+
+  public
+
   module ClassMethods
     
     ##
@@ -67,12 +83,12 @@ module Ladder::Resource
     # @see ActiveTriples::Properties
     def property(name, opts={})
       if class_name = opts[:class_name]
-        mongoid_opts = opts.except(:predicate, :multivalue).merge(autosave: true)
+        mongoid_opts = {autosave: true, index: true}.merge(opts.except(:predicate, :multivalue))
         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)
+        field(name, localize: true) unless fields[name.to_s]
       end
 
       super

data/lib/ladder/resource/dynamic.rb

@@ -0,0 +1,115 @@
+module Ladder::Resource::Dynamic
+  extend ActiveSupport::Concern
+
+  included do
+    include Ladder::Resource
+
+    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
+    
+    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 = case data.object
+        when RDF::Literal
+          data.object.object
+        when RDF::URI
+          data.object.to_s
+        else
+          data.object
+      end
+
+      self.send("#{field_name}=", value)
+    end
+
+    private
+    
+      ##
+      # Overload ActiveTriples #resource_class
+      #
+      # @see ActiveTriples::Identifiable
+      def resource_class
+        @modified_resource_class ||= self.class.resource_class.clone
+      end
+
+  end
+
+  ##
+  # Dynamic field definition
+  def property(field_name, *opts)
+    # Store context information
+    self._context ||= Hash.new(nil)
+    self._context[field_name] = opts.first[:predicate].to_s
+
+    apply_context
+  end
+
+  private
+
+    ##
+    # Dynamic field accessors (Mongoid)
+    def create_accessors(field_name)
+      define_singleton_method field_name do
+        read_attribute(field_name)
+      end
+
+      define_singleton_method "#{field_name}=" do |value|
+        write_attribute(field_name, value)
+      end
+    end
+    
+    ##
+    # Apply dynamic fields and properties to this instance
+    def apply_context
+      return unless self._context
+
+      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
+
+          # Update resource properties
+          resource_class.property(field_name, predicate: term)
+        end
+      end
+    end
+
+end