active-triples 0.6.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 809451f4e93b30a688fe6408869e9a854f17566b
-  data.tar.gz: e7245d27ba5ead992693c0287cda780552525ab6
+  metadata.gz: a4dc6967bd4ea18668b379926f3504e0c67c5135
+  data.tar.gz: c75e487fcf484d7e1f91a7a919ac9c56c2728c1b
 SHA512:
-  metadata.gz: b00382722ed8c6217be858229f817707f3e9ab79de5f9d8c286894f670c1918da137aefa2f30d852ccf6f4b61974cd28d97f9a6b0833faa6bd5dc70721208b2d
-  data.tar.gz: 5a1df0a4b7f39d97af9a28f78cefb34af861b0a8c4276a0c50bce79b6455838d6f705b7fc6c737b7c02a1b864d5d200f70a5afcb13decc544e03d0b2d4a1bf15
+  metadata.gz: d548a15c50003b4625c33283399bd8d101edceec9671658012b1702cead051c7230188afe2a6100feb9bd93c3a08204bbd4395266fec6aebc071863e3e647b28
+  data.tar.gz: c2a1f637cd7a4edf4a9a3eb3fd78fcbf143e964561d6648d674353575a4c5312aee21f8502de003b4ae1a4bbb4c7f13760eabbdfe35d126ef9f312e9efd14775

data/.travis.yml

@@ -1,12 +1,16 @@
 anguage: ruby
 bundler_args: --without debug
 script: "bundle exec rspec spec"
+sudo: false
+cache: bundler
 rvm:
-  - 1.9.3
   - 2.0.0
   - 2.1.0
   - 2.1.1
-  - jruby-19mode
+  - 2.2.1
+  - ruby-head
+  - jruby
+  - rbx-2
 matrix:
   allow_failures:
-      - rvm: jruby-19mode
+      - rvm: jruby

data/CHANGES.md

@@ -0,0 +1,20 @@
+0.7.0
+-----
+
+__ATTN: This release withdraws support for Ruby 1.9__
+
+  - Removes `#solrize` which was a badly named holdever from the
+  ActiveFedroa days.
+  - Fixes a bug on properties defined without a predicate. They are now
+  rejected.
+  - Disallows setting properties on the `ActiveTriples::Resource` base
+  class directly. This kind of property setting is unintended and
+  resulted in unexpected behavior.
+  - Introduces `ActiveTriples::RDFSource` as a mixin module for which
+  forms the basis of `Resource`.
+    - Use of this module is now preferred to single inheritance of the
+  `Resource` base class.
+    - `Resource` will remain indefinitely as the generic model.
+  - Renamed `Term` to `Relation`. `Term` is deprecated for removal in
+  the next minor release.
+  - Allow configuration of multiple `rdf:type`s.

data/Gemfile

@@ -1,3 +1,5 @@
 source "https://rubygems.org"
 
 gemspec
+
+gem 'pry-byebug' unless ENV["CI"]

data/README.md

@@ -5,7 +5,7 @@ Description
 [![Coverage Status](https://coveralls.io/repos/ActiveTriples/ActiveTriples/badge.png?branch=master)](https://coveralls.io/r/ActiveTriples/ActiveTriples?branch=master)
 [![Gem Version](https://badge.fury.io/rb/active-triples.svg)](http://badge.fury.io/rb/active-triples)
 
-An ActiveModel-like interface for RDF data. Models graphs as Resources with property/attribute configuration, accessors, and other methods to support Linked Data in a Ruby/Rails enviornment.
+An ActiveModel-like interface for RDF data. Models graphs as RDFSources with property/attribute configuration, accessors, and other methods to support Linked Data in a Ruby/Rails enviornment. See [RDF Concepts and Abstract Syntax](http://www.w3.org/TR/2014/REC-rdf11-concepts-20140225/#change-over-time) for an informal definition of an RDF Source.
 
 This library was extracted from work on [ActiveFedora](https://github.com/projecthydra/active_fedora). It is closely related to (and borrows some syntax from) [Spira](https://github.com/ruby-rdf/spira), but does some important things differently.
 
@@ -16,14 +16,15 @@ Add `gem "active-triples"` to your Gemfile and run `bundle`.
 
 Or install manually with `gem install active-triples`.
 
-Defining Resource Models
-------------------------
+Defining RDFSource Models
+-------------------------
 
-The core class of ActiveTriples is ActiveTriples::Resource. You can subclass this to create ActiveModel-like classes that represent a node in an RDF graph, and its surrounding statements. Resources implement all the functionality of an RDF::Graph. You can manipulate them by adding or deleting statements, query, serialize, and load arbitrary RDF. 
+The core module of `ActiveTriples` is `ActiveTriples::RDFSource`. You can use this module as a mixin to create ActiveModel-like classes that represent an RDF resource as a stateful entity represented by an `RDF::Graph`. `RDFSource` implements the `RDF::Resource` interface, as well as `RDF::Queryable`, `RDF::Enumerable`, and `RDF::Mutable`. This means you can manipulate them by adding or deleting statements, query, serialize, and load arbitrary RDF.
 
 
 ```ruby
-class Thing < ActiveTriples::Resource
+class Thing
+  include  ActiveTriples::RDFSource
   configure :type => RDF::OWL.Thing, :base_uri => 'http://example.org/things#'
   property :title, :predicate => RDF::DC.title
   property :description, :predicate => RDF::DC.description
@@ -34,12 +35,13 @@ obj.title = 'Resource'
 obj.description = 'A resource.'
 obj.dump :ntriples # => "<http://example.org/things#123> <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://www.w3.org/2002/07/owl#Thing> .\n<http://example.org/things#123> <http://purl.org/dc/terms/title> \"Resource\" .\n<http://example.org/things#123> <http://purl.org/dc/terms/description> \"A resource.\" .\n"
 ```
-URI and bnode values are built out as Resources when accessed, and a model class can be configured on individual properties.
+URI and bnode values are built out as generic Resources when accessed. A more specific model class can be configured on individual properties.
 
 ```ruby
 Thing.property :creator, :predicate => RDF::DC.creator, :class_name => 'Person'
 
-class Person < ActiveTriples::Resource
+class Person
+  include  ActiveTriples::RDFSource
   configure :type => RDF::FOAF.Person, :base_uri => 'http://example.org/people#'
   property :name, :predicate => RDF::FOAF.name
 end
@@ -56,24 +58,24 @@ obj_2.dump :ntriples # => "<http://example.org/things#2> <http://www.w3.org/1999
 Open Model
 -----------
 
-A Resource lets you handle data as a graph, independent of whether it is defined in the model. This is important for working in a Linked Data context, where you will want access to data you may not have known about when your models were written.
+An RDFSource lets you handle data as a graph, independent of whether it is defined in the model. This is important for working in a Linked Data context, where you will want access to data you may not have known about when your models were written.
 
 ```ruby
 related = Thing.new
 
 related << RDF::Statement(related, RDF::DC.relation, obj)
 related << RDF::Statement(related, RDF::DC.subject, 'ActiveTriples')
-	
+
 related.query(:subject => related, :predicate => RDF::DC.relation).each_statement {|s,p,o| puts o}
 # => http://example.org/things#123
 related.query(:subject => subject, :predicate => RDF::DC.relation).each_statement {|s,p,o| puts o}
 # => http://example.org/things#123
 ```
 
-Any operation you can run against an RDF::Graph works with Resources, too. Or you can use generic setters and getters with URI predicates:
+Any operation you can run against an RDF::Graph works with RDFSources, too. Or you can use generic setters and getters with URI predicates:
 
 ```ruby
-related.set_value(RDF::DC.relation, obj) 
+related.set_value(RDF::DC.relation, obj)
 related.set_value(RDF::DC.subject, 'ActiveTriples')
 
 related.get_values(RDF::DC.relation) # => [#<Thing:0x3f949c6a2294(default)>]
@@ -81,7 +83,7 @@ related.get_values(RDF::DC.subject) # => ["ActiveTriples"]
 ```
 
 Some convienience methods provide support for handling data from web sources:
-  * `fetch` loads data from the Resource's #rdf_subject URI
+  * `fetch` loads data from the RDFSource's #rdf_subject URI
   * `rdf_label` queries across common (& configured) label fields and returning the best match
 
 ```ruby
@@ -115,10 +117,10 @@ Data is cast back to the appropriate class when it is accessed.
 my_thing.date
 # => [Thu, 19 Jun 2014]
 ```
-   
+
 Note that you can mix types on a single property.
 
-```ruby     
+```ruby
 my_thing.date << DateTime.now
 my_thing.date << "circa 2014"
 my_thing.date
@@ -143,12 +145,15 @@ Resources can persist to various databases and triplestores though integration w
 ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
 ActiveTriples::Repositories.add_repository :people, RDF::Repository.new
 
-class Person < ActiveTriples::Resource
+class Person
+  include  ActiveTriples::RDFSource
   configure :type => RDF::FOAF.Person, :base_uri => 'http://example.org/people#', :repository => :people
   property :name, :predicate => RDF::FOAF.name
 end
 
-class Thing < ActiveTriples::Resource
+class Thing
+  include  ActiveTriples::RDFSource
+
   configure :type => RDF::OWL.Thing, :base_uri => 'http://example.org/things#', :repository => :default
   property :title, :predicate => RDF::DC.title
   property :description, :predicate => RDF::DC.description
@@ -183,4 +188,3 @@ Please observe the following guidelines:
  - Organize your commits into logical units.
  - Don't leave trailing whitespace (i.e. run ```git diff --check``` before committing).
  - Use [well formed](http://tbaggery.com/2008/04/19/a-note-about-git-commit-messages.html) commit messages.
-

data/lib/active_triples.rb

@@ -5,9 +5,10 @@ require 'active_support'
 module ActiveTriples
   extend ActiveSupport::Autoload
   eager_autoload do
+    autoload :RDFSource
     autoload :Resource
     autoload :List
-    autoload :Term
+    autoload :Relation
     autoload :Configurable
     autoload :Properties
     autoload :PropertyBuilder
@@ -16,6 +17,10 @@ module ActiveTriples
     autoload :NodeConfig
     autoload :NestedAttributes
     autoload :Identifiable
+    autoload :Configuration
+
+    # deprecated class
+    autoload :Term, 'active_triples/relation'
   end
 
   # Raised when a declared repository doesn't have a definition

data/lib/active_triples/configurable.rb

@@ -12,17 +12,20 @@ module ActiveTriples
   # Available properties are base_uri, rdf_label, type, and repository
   module Configurable
     extend Deprecation
-
     def base_uri
-      nil
+      configuration[:base_uri]
     end
 
     def rdf_label
-      nil
+      configuration[:rdf_label]
     end
 
     def type
-      nil
+      configuration[:type]
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
     end
 
     ##
@@ -33,7 +36,7 @@ module ActiveTriples
     end
 
     def repository
-      :parent
+      configuration[:repository] || :parent
     end
 
     ##
@@ -52,24 +55,20 @@ module ActiveTriples
     #
     # @param options [Hash]
     def configure(options = {})
-      {
-        base_uri: options[:base_uri],
-        rdf_label: options[:rdf_label],
-        type: options[:type],
-        repository: options[:repository]
-      }.each do |name, value|
-        if value
-          value = self.send("transform_#{name}", value) if self.respond_to?("transform_#{name}")
-          define_singleton_method(name) do
-            value
-          end
+      options = options.map do |key, value|
+        if self.respond_to?("transform_#{key}")
+          value = self.__send__("transform_#{key}", value)
         end
+        [key, value]
       end
+      @configuration = configuration.merge(options)
     end
 
-    def transform_type(value)
-      RDF::URI.new(value).tap do |value|
-        Resource.type_registry[value] = self
+    def transform_type(values)
+      Array(values).map do |value|
+        RDF::URI.new(value).tap do |uri|
+          Resource.type_registry[uri] = self
+        end
       end
     end
   end

data/lib/active_triples/configuration.rb

@@ -0,0 +1,72 @@
+module ActiveTriples
+  require_relative 'configuration/item'
+  require_relative 'configuration/merge_item'
+  require_relative 'configuration/item_factory'
+  ##
+  # Class which contains configuration for RDFSources.
+  class Configuration
+    attr_accessor :inner_hash
+    # @param [Hash] options the configuration options.
+    def initialize(options={})
+      @inner_hash = Hash[options.to_a]
+    end
+
+    # Merges this configuration with other configuration options. This uses
+    # reflection setters to handle special cases like :type.
+    #
+    # @param [Hash] options configuration options to merge in.
+    # @return [ActiveTriples::Configuration] the configuration object which is a
+    #   result of merging.
+    def merge(options)
+      new_config = Configuration.new(options)
+      new_config.items.each do |property, item|
+        build_configuration_item(property).set item.value
+      end
+      self
+    end
+
+    # Returns a hash with keys as the configuration property and values as
+    # reflections which know how to set a new value to it.
+    #
+    # @return [Hash{Symbol => ActiveTriples::Configuration::Item}]
+    def items
+      to_h.each_with_object({}) do |config_value, hsh|
+        key = config_value.first
+        hsh[key] = build_configuration_item(key)
+      end
+    end
+
+    # Returns the configured value for an option
+    #
+    # @return the configured value
+    def [](value)
+      to_h[value]
+    end
+
+    # Returns the available configured options as a hash.
+    #
+    # This filters the options the class is initialized with.
+    #
+    # @return [Hash{Symbol => String, ::RDF::URI}]
+    def to_h
+      @inner_hash.slice(*valid_config_options)
+    end
+
+    protected
+
+    def build_configuration_item(key)
+      configuration_item_factory.new(self, key)
+    end
+
+    private
+
+    def configuration_item_factory
+      @configuration_item_factory ||= ItemFactory.new
+    end
+
+    def valid_config_options
+      [:base_uri, :rdf_label, :type, :repository]
+    end
+  end
+
+end

data/lib/active_triples/configuration/item.rb

@@ -0,0 +1,20 @@
+module ActiveTriples
+  class Configuration
+    # Basic configuration item which overrides the value for a key on the object.
+    class Item
+      attr_reader :object, :key
+      def initialize(object, key)
+        @object = object
+        @key = key
+      end
+
+      def value
+        object.inner_hash[key]
+      end
+
+      def set(value)
+        object.inner_hash[key] = value
+      end
+    end
+  end
+end

data/lib/active_triples/configuration/item_factory.rb

@@ -0,0 +1,27 @@
+module ActiveTriples
+  class Configuration
+    ## Returns a configuration item appropriate for a given configuration property.
+    class ItemFactory
+      # @return [MergeItem, Item]
+      def new(object, name)
+        if merge_configs.include?(name)
+          merge_item.new(object, name)
+        else
+          item.new(object, name)
+        end
+      end
+
+      def merge_item
+        MergeItem
+      end
+
+      def item
+        Item
+      end
+
+      def merge_configs
+        [:type]
+      end
+    end
+  end
+end

data/lib/active_triples/configuration/merge_item.rb

@@ -0,0 +1,14 @@
+module ActiveTriples
+  class Configuration
+    # Configuration item which sets a value by turning the original into an array and
+    # appending the given value to it.
+    #
+    # This enables multiple types to be set on an object, for example.
+    class MergeItem < Item
+      def set(value)
+        object.inner_hash[key] = Array(object.inner_hash[key])
+        object.inner_hash[key] |= Array(value)
+      end
+    end
+  end
+end

data/lib/active_triples/identifiable.rb

@@ -7,12 +7,12 @@ module ActiveTriples::Identifiable
   delegate :rdf_subject, :type, to: :resource
 
   ##
-  # @return [ActiveTriples::Resource] a resource that contains this object's 
+  # @return [ActiveTriples::Resource] a resource that contains this object's
   # graph.
   def resource
    @resource ||= resource_class.new(to_uri)
   end
-  
+
   def parent
     @parent ||= resource.parent
   end
@@ -21,7 +21,7 @@ module ActiveTriples::Identifiable
     @parent = val
   end
 
-  ## 
+  ##
   # @return [String] a uri or slug
   def to_uri
     return id if respond_to? :id and !resource_class.base_uri.nil?

data/lib/active_triples/list.rb

@@ -28,7 +28,7 @@ module ActiveTriples
     def initialize(*args)
       super
       parent = graph.parent if graph.respond_to? :parent
-      @graph = ListResource.new(subject) << graph unless graph.kind_of? Resource
+      @graph = ListResource.new(subject) << graph unless graph.kind_of? RDFSource
       graph << parent if parent
       graph.list = self
       graph.reload
@@ -97,7 +97,9 @@ module ActiveTriples
     ##
     # This class is the graph/Resource that backs the List and
     # supplies integration with the rest of ActiveTriples
-    class ListResource < Resource
+    class ListResource
+      include ActiveTriples::RDFSource
+
       attr_reader :list
 
       def list=(list)
@@ -171,11 +173,11 @@ module ActiveTriples
         @graph.type = RDF.List
         resource.set_value(RDF.first, value)
         resource.insert([subject, RDF.rest, RDF.nil])
-        resource << value if value.kind_of? Resource
+        resource << value if value.kind_of? RDFSource
         return self
       end
       super
-      resource << value if value.kind_of? Resource
+      resource << value if value.kind_of? RDFSource
     end
   end
 end