ld4l-foaf_rdf 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 37e6858b4b5355b65a2e3157a2db5f280ff586fe
+  data.tar.gz: bc856fe13754c5bf584773d7d4a1a905c95fc892
+SHA512:
+  metadata.gz: c36fae03f1eef58e1270f7aedb48592904108d07c32c712394ab0766ea8685b46bb06fd8ec8a2f2d26e858d586db6dfe1418849b0fb295c1c0855f5ae07c4cfb
+  data.tar.gz: cc03aa43c5c8981576eafa823fcad3dda079514c719ed871ad93d9d2b1beefb294a4405f6d48ceca40168115678e4ba985d178116e3258b83e09ff97ae7b319d

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.idea

data/.ruby-gemset

@@ -0,0 +1 @@
+ld4l-foaf-gem_no-rails

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.1.2

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+# GETTING FROM GEMFILE UNTIL ActiveTriples master CODE IS RELEASED (>0.4.0), THEN MOVE THIS BACK TO *.gemspec FILE
+# Use active-triples for handling of triple persistence
+gem 'active-triples', :git => 'git@github.com:ActiveTriples/ActiveTriples.git', :branch => 'master'
+

data/LICENSE.txt

@@ -0,0 +1,14 @@
+Copyright (c) 2014 Cornell University
+
+##########################################################################
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.

data/README.md

@@ -0,0 +1,134 @@
+#LD4L::FoafRDF
+
+LD4L FOAF RDF provides tools for modeling person triples based on the FOAF ontology and persisting to a triplestore.
+
+
+## Installation
+
+Temporary get the gem from github until the gem is released publicly.
+
+Add this line to your application's Gemfile:
+
+<!--    gem 'ld4l-foaf_rdf' -->
+    gem 'ld4l-foaf_rdf', '~> 0.0.3', :git => 'git@github.com:ld4l/foaf_rdf.git'
+    
+
+And then execute:
+
+    $ bundle install
+
+<!--
+Or install it yourself as:
+
+    $ gem install ld4l-foaf_rdf
+-->
+
+
+## Usage
+
+**Caveat:** This gem is part of the LD4L Project and is being used in that context.  There is no guarantee that the 
+code will work in a usable way outside of its use in LD4L Use Cases.
+
+### Examples
+
+Setup required for all examples.
+```
+require 'ld4l/foaf_rdf'
+
+# create an in-memory repository
+ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+```
+
+Example creating a person.
+```
+p = LD4L::FoafRDF::Person.new('p4')
+
+puts p.dump :ttl
+```
+
+Example triples created for a person.
+```
+<http://localhost/p4> a <http://xmlns.com/foaf/0.1/Person> .
+```
+
+
+### Configurations
+
+* base_uri - base URI used when new resources are created (default="http://localhost/")
+* localname_minter - minter function to use for creating unique local names (default=nil which uses default minter in active_triples-local_name gem)
+
+*Setup for all examples.*
+
+* Restart your interactive session (e.g. irb, pry).
+* Use the Setup for all examples in main Examples section above.
+
+*Example usage using configured base_uri and default localname_minter.*
+```
+LD4L::FoafRDF.configure do |config|
+  config.base_uri = "http://example.org/"
+end
+
+p = LD4L::FoafRDF::Person.new(ActiveTriples::LocalName::Minter.generate_local_name(
+              LD4L::FoafRDF::Person, 10, {:prefix=>'p'} ))
+
+puts p.dump :ttl
+```
+NOTE: If base_uri is not used, you need to restart your interactive environment (e.g. irb, pry).  Once the 
+  Person class is instantiated the first time, the base_uri for the class is set.  If you ran
+  through the main Examples, the base_uri was set to the default base_uri.
+
+
+*Example triples created for a person with configured base_uri and default minter.*
+```
+<http://example.org/p45c9c85b-25af-4c52-96a4-cf0d8b70a768> a <http://xmlns.com/foaf/0.1/Person> .
+```
+
+*Example usage using configured base_uri and configured localname_minter.*
+```
+LD4L::FoafRDF.configure do |config|
+  config.base_uri = "http://example.org/"
+  config.localname_minter = lambda { |prefix=""| prefix+'_configured_'+SecureRandom.uuid }
+end
+
+p = LD4L::FoafRDF::Person.new(ActiveTriples::LocalName::Minter.generate_local_name(
+              LD4L::FoafRDF::Person, 10, 'p',
+              &LD4L::FoafRDF.configuration.localname_minter ))
+
+puts p.dump :ttl
+```
+NOTE: If base_uri is not used, you need to restart your interactive environment (e.g. irb, pry).  Once the 
+  Person class is instantiated the first time, the base_uri for the class is set.  If you ran
+  through the main Examples, the base_uri was set to the default base_uri.
+
+
+*Example triples created for a person with configured base_uri and configured minter.*
+```
+<http://example.org/p_configured_6498ba05-8b21-4e8c-b9d4-a6d5d2180966> a <http://xmlns.com/foaf/0.1/Person> .
+```
+
+
+### Models
+
+The LD4L::FoafRDF gem provides model definitions using the 
+[ActiveTriples](https://github.com/ActiveTriples/ActiveTriples) framework extension of 
+[ruby-rdf/rdf](https://github.com/ruby-rdf/rdf).  The following models are provided:
+
+1. LD4L::FoafRDF::Person - Implements the Person class in the FOAF ontology.  (extremely simple for holding rdf_subject only)
+
+
+### Ontologies
+
+The listed ontologies are used to represent the primary metadata about the person.
+Other ontologies may also be used that aren't listed.
+ 
+* [FOAF](http://xmlns.com/foaf/spec/)
+* [RDF](http://www.w3.org/TR/rdf-syntax-grammar/)
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/ld4l-foaf_rdf/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/ld4l-foaf_rdf.gemspec

@@ -0,0 +1,42 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ld4l/foaf_rdf/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ld4l-foaf_rdf"
+  spec.version       = LD4L::FoafRDF::VERSION
+  spec.authors       = ["E. Lynette Rayle"]
+  spec.email         = ["elr37@cornell.edu"]
+  spec.platform      = Gem::Platform::RUBY
+  spec.summary       = %q{FOAF RDF models.}
+  spec.description   = %q{LD4L FOAF RDF provides tools for modeling a person triples based on the FOAF ontology and persisting to a triplestore.}
+  spec.homepage      = "https://github.com/ld4l/foaf_rdf"
+  spec.license       = "APACHE2"
+  spec.required_ruby_version     = '>= 2.1.2'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  # spec.test_files    = `git ls-files -- {spec}/*`.split("\n")               # FROM ActiveTriples gemspec file
+  # spec.require_paths = ["lib"]                                              # NOT IN ActiveTriples gemspec file
+
+#  spec.add_dependency('ffi', '~> 1.9.5')
+  spec.add_dependency('rdf', '~> 1.1')
+
+# GETTING FROM GEMFILE UNTIL ActiveTriples master CODE IS RELEASED (>0.4.0), THEN MOVE THIS BACK TO *.gemspec FILE
+#  spec.add_dependency('active-triples', '~> 0.4')
+
+  spec.add_dependency('active_triples-local_name', '~> 0.1')
+
+  spec.add_development_dependency('pry')
+  spec.add_development_dependency('rdoc')
+  spec.add_development_dependency('rspec')
+  spec.add_development_dependency('guard-rspec')
+  spec.add_development_dependency('webmock')
+
+  spec.extra_rdoc_files = [
+      "LICENSE.txt",
+      "README.md"
+  ]
+end
+

data/lib/ld4l/foaf_rdf/configuration.rb

@@ -0,0 +1,41 @@
+module LD4L
+  module FoafRDF
+    class Configuration
+
+      attr_reader :base_uri
+      attr_reader :localname_minter
+
+      def self.default_base_uri
+        @default_base_uri = "http://localhost/".freeze
+      end
+      private_class_method :default_base_uri
+
+      def self.default_localname_minter
+        # by setting to nil, it will use the default minter in the minter gem
+        @default_localname_minter = nil
+      end
+      private_class_method :default_localname_minter
+
+      def initialize
+        @base_uri         = self.class.send(:default_base_uri)
+        @localname_minter = self.class.send(:default_localname_minter)
+      end
+
+      def base_uri=(new_base_uri)
+        @base_uri = new_base_uri
+      end
+
+      def reset_base_uri
+        @base_uri = self.class.send(:default_base_uri)
+      end
+
+      def localname_minter=(new_minter)
+        @localname_minter = new_minter
+      end
+
+      def reset_localname_minter
+        @localname_minter = self.class.send(:default_localname_minter)
+      end
+    end
+  end
+end

data/lib/ld4l/foaf_rdf/person.rb

@@ -0,0 +1,11 @@
+module LD4L
+  module FoafRDF
+    class Person < ActiveTriples::Resource
+
+      class << self; attr_reader :localname_prefix end
+      @localname_prefix="p"
+
+      configure :type => RDF::FOAF.Person, :base_uri => LD4L::FoafRDF.configuration.base_uri, :repository => :default
+    end
+  end
+end

data/lib/ld4l/foaf_rdf/version.rb

@@ -0,0 +1,5 @@
+module LD4L
+  module FoafRDF
+    VERSION = "0.0.2"
+  end
+end

data/lib/ld4l/foaf_rdf.rb

@@ -0,0 +1,53 @@
+require 'rdf'
+require 'active_triples'
+require 'active_triples/local_name'
+require	'linkeddata'
+require 'ld4l/foaf_rdf/version'
+
+
+module LD4L
+  module FoafRDF
+
+    # Methods for configuring the GEM
+    class << self
+      attr_accessor :configuration
+    end
+
+    def self.configuration
+      @configuration ||= Configuration.new
+    end
+
+    def self.reset
+      @configuration = Configuration.new
+    end
+
+    def self.configure
+      yield(configuration)
+    end
+
+
+    # RDF vocabularies
+    #    none - uses RDF::FOAF vocabulary
+
+    # autoload classes
+    autoload :Configuration,         'ld4l/foaf_rdf/configuration'
+    autoload :Person,                'ld4l/foaf_rdf/person'
+
+    def self.class_from_string(class_name, container_class=Kernel)
+      container_class = container_class.name if container_class.is_a? Module
+      container_parts = container_class.split('::')
+      (container_parts + class_name.split('::')).flatten.inject(Kernel) do |mod, class_name|
+        if mod == Kernel
+          Object.const_get(class_name)
+        elsif mod.const_defined? class_name.to_sym
+          mod.const_get(class_name)
+        else
+          container_parts.pop
+          class_from_string(class_name, container_parts.join('::'))
+        end
+      end
+    end
+
+  end
+end
+

data/spec/ld4l/foaf_rdf/configuration_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+describe 'LD4L::FoafRDF' do
+
+  describe '#configuration' do
+    describe "base_uri" do
+      context "when base_uri is not configured" do
+        before do
+          class DummyPerson < LD4L::FoafRDF::Person
+            configure :type => RDF::FOAF.Person, :base_uri => LD4L::FoafRDF.configuration.base_uri, :repository => :default
+          end
+        end
+        after do
+          Object.send(:remove_const, "DummyPerson") if Object
+        end
+        it "should generate a Person URI using the default base_uri" do
+          expect(DummyPerson.new('1').rdf_subject.to_s).to eq "http://localhost/1"
+        end
+      end
+
+      context "when uri ends with slash" do
+        before do
+          LD4L::FoafRDF.configure do |config|
+            config.base_uri = "http://localhost/test_slash/"
+          end
+          class DummyPerson < LD4L::FoafRDF::Person
+            configure :type => RDF::FOAF.Person, :base_uri => LD4L::FoafRDF.configuration.base_uri, :repository => :default
+          end
+        end
+        after do
+          Object.send(:remove_const, "DummyPerson") if Object
+          LD4L::FoafRDF.reset
+        end
+
+        it "should generate a Person URI using the configured base_uri" do
+          expect(DummyPerson.new('1').rdf_subject.to_s).to eq "http://localhost/test_slash/1"
+        end
+      end
+
+      context "when uri does not end with slash" do
+        before do
+          LD4L::FoafRDF.configure do |config|
+            config.base_uri = "http://localhost/test_no_slash"
+          end
+          class DummyPerson < LD4L::FoafRDF::Person
+            configure :type => RDF::FOAF.Person, :base_uri => LD4L::FoafRDF.configuration.base_uri, :repository => :default
+          end
+        end
+        after do
+          Object.send(:remove_const, "DummyPerson") if Object
+          LD4L::FoafRDF.reset
+        end
+
+        it "should generate a Person URI using the configured base_uri" do
+          expect(DummyPerson.new('1').rdf_subject.to_s).to eq "http://localhost/test_no_slash/1"
+        end
+      end
+
+      it "should return value of configured base_uri" do
+        LD4L::FoafRDF.configure do |config|
+          config.base_uri = "http://localhost/test_config/"
+        end
+        expect(LD4L::FoafRDF.configuration.base_uri).to eq "http://localhost/test_config/"
+      end
+
+      it "should return default base_uri when base_uri is reset" do
+        LD4L::FoafRDF.configure do |config|
+          config.base_uri = "http://localhost/test_config/"
+        end
+        expect(LD4L::FoafRDF.configuration.base_uri).to eq "http://localhost/test_config/"
+        LD4L::FoafRDF.configuration.reset_base_uri
+        expect(LD4L::FoafRDF.configuration.base_uri).to eq "http://localhost/"
+      end
+
+      it "should return default base_uri when all configs are reset" do
+        LD4L::FoafRDF.configure do |config|
+          config.base_uri = "http://localhost/test_config/"
+        end
+        expect(LD4L::FoafRDF.configuration.base_uri).to eq "http://localhost/test_config/"
+        LD4L::FoafRDF.reset
+        expect(LD4L::FoafRDF.configuration.base_uri).to eq "http://localhost/"
+      end
+    end
+
+    describe "localname_minter" do
+      context "when minter is nil" do
+        before do
+          class DummyPerson < LD4L::FoafRDF::Person
+            configure :type => RDF::FOAF.Person, :base_uri => LD4L::FoafRDF.configuration.base_uri, :repository => :default
+          end
+        end
+        after do
+          Object.send(:remove_const, "DummyPerson") if Object
+        end
+        it "should use default minter in minter gem" do
+          localname = ActiveTriples::LocalName::Minter.generate_local_name(
+                  LD4L::FoafRDF::Person, 10, {:prefix=>'default_'},
+                  LD4L::FoafRDF.configuration.localname_minter )
+          expect(localname).to be_kind_of String
+          expect(localname.size).to eq 44
+          expect(localname).to match /default_[a-zA-Z0-9]{8}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{12}/
+        end
+      end
+
+      context "when minter is configured" do
+        before do
+          LD4L::FoafRDF.configure do |config|
+            config.localname_minter = lambda { |prefix=""| prefix+'_configured_'+SecureRandom.uuid }
+          end
+          class DummyPerson < LD4L::FoafRDF::Person
+            configure :type => RDF::FOAF.Person, :base_uri => LD4L::FoafRDF.configuration.base_uri, :repository => :default
+          end
+        end
+        after do
+          Object.send(:remove_const, "DummyPerson") if Object
+          LD4L::FoafRDF.reset
+        end
+
+        it "should generate an Person URI using the configured localname_minter" do
+          localname = ActiveTriples::LocalName::Minter.generate_local_name(
+              LD4L::FoafRDF::Person, 10,
+              LD4L::FoafRDF::Person.localname_prefix,
+              &LD4L::FoafRDF.configuration.localname_minter )
+          expect(localname).to be_kind_of String
+          expect(localname.size).to eq 49
+          expect(localname).to match /p_configured_[a-zA-Z0-9]{8}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{12}/
+        end
+      end
+    end
+  end
+
+
+  describe "LD4L::FoafRDF::Configuration" do
+    describe "#base_uri" do
+      it "should default to localhost" do
+        expect(LD4L::FoafRDF::Configuration.new.base_uri).to eq "http://localhost/"
+      end
+
+      it "should be settable" do
+        config = LD4L::FoafRDF::Configuration.new
+        config.base_uri = "http://localhost/test"
+        expect(config.base_uri).to eq "http://localhost/test"
+      end
+
+      it "should be re-settable" do
+        config = LD4L::FoafRDF::Configuration.new
+        config.base_uri = "http://localhost/test/again"
+        expect(config.base_uri).to eq "http://localhost/test/again"
+        config.reset_base_uri
+        expect(config.base_uri).to eq "http://localhost/"
+      end
+    end
+
+    describe "#localname_minter" do
+      it "should default to nil" do
+        expect(LD4L::FoafRDF::Configuration.new.localname_minter).to eq nil
+      end
+
+      it "should be settable" do
+        config = LD4L::FoafRDF::Configuration.new
+        config.localname_minter = lambda { |prefix=""| prefix+'_configured_'+SecureRandom.uuid }
+        expect(config.localname_minter).to be_kind_of Proc
+      end
+
+      it "should be re-settable" do
+        config = LD4L::FoafRDF::Configuration.new
+        config.localname_minter = lambda { |prefix=""| prefix+'_configured_'+SecureRandom.uuid }
+        expect(config.localname_minter).to be_kind_of Proc
+        config.reset_localname_minter
+        expect(config.localname_minter).to eq nil
+      end
+    end
+  end
+end

data/spec/ld4l/foaf_rdf/person_rdf_spec.rb

@@ -0,0 +1,263 @@
+require 'spec_helper'
+
+describe 'LD4L::FoafRDF::Person' do
+  # it_behaves_like 'an ActiveTriple::Resource'
+
+  subject { LD4L::FoafRDF::Person.new }  # new virtual collection without a subject
+
+  describe 'rdf_subject' do
+    it "should be a blank node if we haven't set it" do
+      expect(subject.rdf_subject.node?).to be true
+    end
+
+    it "should be settable when it has not been set yet" do
+      subject.set_subject! RDF::URI('http://example.org/moomin')
+      expect(subject.rdf_subject).to eq RDF::URI('http://example.org/moomin')
+    end
+
+    it "should append to base URI when setting to non-URI subject" do
+      subject.set_subject! '123'
+      expect(subject.rdf_subject).to eq RDF::URI("#{LD4L::FoafRDF::Person.base_uri}123")
+    end
+
+    describe 'when changing subject' do
+      before do
+        subject << RDF::Statement.new(subject.rdf_subject, RDF::DC.title, RDF::Literal('Comet in Moominland'))
+        subject << RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::DC.isPartOf, subject.rdf_subject)
+        subject << RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::DC.relation, 'http://example.org/moomin_land')
+        subject.set_subject! RDF::URI('http://example.org/moomin')
+      end
+
+      it 'should update graph subjects' do
+        expect(subject.has_statement?(RDF::Statement.new(subject.rdf_subject, RDF::DC.title, RDF::Literal('Comet in Moominland')))).to be true
+      end
+
+      it 'should update graph objects' do
+        expect(subject.has_statement?(RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::DC.isPartOf, subject.rdf_subject))).to be true
+      end
+
+      it 'should leave other uris alone' do
+        expect(subject.has_statement?(RDF::Statement.new(RDF::URI('http://example.org/moomin_comics'), RDF::DC.relation, 'http://example.org/moomin_land'))).to be true
+      end
+    end
+
+    describe 'created with URI subject' do
+      before do
+        subject.set_subject! RDF::URI('http://example.org/moomin')
+      end
+
+      it 'should not be settable' do
+        expect{ subject.set_subject! RDF::URI('http://example.org/moomin2') }.to raise_error
+      end
+    end
+  end
+
+
+  # -------------------------------------------------
+  #  START -- Test attributes specific to this model
+  # -------------------------------------------------
+
+  describe 'type' do
+    it "should be an RDF::FOAF.Person" do
+      expect(subject.type.first.value).to eq RDF::FOAF.Person.value
+    end
+  end
+
+  describe '#localname_prefix' do
+    it "should return default prefix" do
+      prefix = LD4L::FoafRDF::Person.localname_prefix
+      expect(prefix).to eq "p"
+    end
+  end
+
+  # -----------------------------------------------
+  #  END -- Test attributes specific to this model
+  # -----------------------------------------------
+
+
+  describe "#persisted?" do
+    context 'with a repository' do
+      before do
+        # Create inmemory repository
+        repository = RDF::Repository.new
+        allow(subject).to receive(:repository).and_return(repository)
+      end
+
+      context "when the object is new" do
+        it "should return false" do
+          expect(subject).not_to be_persisted
+        end
+      end
+
+      context "when it is saved" do
+        before do
+          subject.persist!
+        end
+
+        it "should return true" do
+          expect(subject).to be_persisted
+        end
+      end
+    end
+  end
+
+  describe "#persist!" do
+    context "when the repository is set" do
+      context "and the item is not a blank node" do
+
+        subject {LD4L::FoafRDF::Person.new("123")}
+
+        before do
+          # Create inmemory repository
+          @repo = RDF::Repository.new
+          allow(subject.class).to receive(:repository).and_return(nil)
+          allow(subject).to receive(:repository).and_return(@repo)
+          subject.persist!
+        end
+
+        it "should persist to the repository" do
+          expect(@repo.statements.first).to eq subject.statements.first
+        end
+
+      end
+    end
+  end
+
+  describe '#destroy!' do
+    before do
+      subject << RDF::Statement(RDF::DC.LicenseDocument, RDF::DC.title, 'LICENSE')
+    end
+
+    subject { LD4L::FoafRDF::Person.new('456')}
+
+    it 'should return true' do
+      expect(subject.destroy!).to be true
+      expect(subject.destroy).to be true
+    end
+
+    it 'should delete the graph' do
+      subject.destroy
+      expect(subject).to be_empty
+    end
+  end
+
+  describe '#type' do
+    it 'should return the type configured on the parent class' do
+      expect(subject.type).to eq [LD4L::FoafRDF::Person.type]
+    end
+
+    it 'should set the type' do
+      subject.type = RDF::URI('http://example.org/AnotherClass')
+      expect(subject.type).to eq [RDF::URI('http://example.org/AnotherClass')]
+    end
+
+    it 'should be the type in the graph' do
+      subject.query(:subject => subject.rdf_subject, :predicate => RDF.type).statements do |s|
+        expect(s.object).to eq RDF::URI('http://example.org/AnotherClass')
+      end
+    end
+  end
+
+  describe '#rdf_label' do
+    subject {LD4L::FoafRDF::Person.new("123")}
+
+    it 'should return an array of label values' do
+      expect(subject.rdf_label).to be_kind_of Array
+    end
+
+    it 'should return the default label as URI when no title property exists' do
+      expect(subject.rdf_label).to eq ["#{LD4L::FoafRDF::Person.base_uri}123"]
+    end
+
+    it 'should prioritize configured label values' do
+      custom_label = RDF::URI('http://example.org/custom_label')
+      subject.class.configure :rdf_label => custom_label
+      subject << RDF::Statement(subject.rdf_subject, custom_label, RDF::Literal('New Label'))
+      expect(subject.rdf_label).to eq ['New Label']
+    end
+  end
+
+  describe '#solrize' do
+    it 'should return a label for bnodes' do
+      expect(subject.solrize).to eq subject.rdf_label
+    end
+
+    it 'should return a string of the resource uri' do
+      subject.set_subject! 'http://example.org/moomin'
+      expect(subject.solrize).to eq 'http://example.org/moomin'
+    end
+  end
+
+  describe 'big complex graphs' do
+    before do
+      class DummyPerson < ActiveTriples::Resource
+        configure :type => RDF::URI('http://example.org/Person')
+        property :foafname, :predicate => RDF::FOAF.name
+        property :publications, :predicate => RDF::FOAF.publications, :class_name => 'DummyDocument'
+        property :knows, :predicate => RDF::FOAF.knows, :class_name => DummyPerson
+      end
+
+      class DummyDocument < ActiveTriples::Resource
+        configure :type => RDF::URI('http://example.org/Document')
+        property :title, :predicate => RDF::DC.title
+        property :creator, :predicate => RDF::DC.creator, :class_name => 'DummyPerson'
+      end
+
+      LD4L::FoafRDF::Person.property :item, :predicate => RDF::DC.relation, :class_name => DummyDocument
+    end
+
+    subject { LD4L::FoafRDF::Person.new }
+
+    let (:document1) do
+      d = DummyDocument.new
+      d.title = 'Document One'
+      d
+    end
+
+    let (:document2) do
+      d = DummyDocument.new
+      d.title = 'Document Two'
+      d
+    end
+
+    let (:person1) do
+      p = DummyPerson.new
+      p.foafname = 'Alice'
+      p
+    end
+
+    let (:person2) do
+      p = DummyPerson.new
+      p.foafname = 'Bob'
+      p
+    end
+
+    let (:data) { <<END
+_:1 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.org/SomeClass> .
+_:1 <http://purl.org/dc/terms/relation> _:2 .
+_:2 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.org/Document> .
+_:2 <http://purl.org/dc/terms/title> "Document One" .
+_:2 <http://purl.org/dc/terms/creator> _:3 .
+_:2 <http://purl.org/dc/terms/creator> _:4 .
+_:4 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.org/Person> .
+_:4 <http://xmlns.com/foaf/0.1/name> "Bob" .
+_:3 <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://example.org/Person> .
+_:3 <http://xmlns.com/foaf/0.1/name> "Alice" .
+_:3 <http://xmlns.com/foaf/0.1/knows> _:4 ."
+END
+    }
+
+    after do
+      Object.send(:remove_const, "DummyDocument")
+      Object.send(:remove_const, "DummyPerson")
+    end
+
+    it 'should allow access to deep nodes' do
+      document1.creator = [person1, person2]
+      document2.creator = person1
+      person1.knows = person2
+      subject.item = [document1]
+      expect(subject.item.first.creator.first.knows.first.foafname).to eq ['Bob']
+    end
+  end
+end

data/spec/ld4l/foaf_rdf_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe "LD4L::FoafRDF" do
+  describe "#configure" do
+
+    before do
+      LD4L::FoafRDF.configure do |config|
+        config.base_uri = "http://localhost/test/"
+        config.localname_minter = lambda { |prefix=""| prefix+'_configured_'+SecureRandom.uuid }
+      end
+      class DummyPerson < LD4L::FoafRDF::Person
+        configure :type => RDF::FOAF.Person, :base_uri => LD4L::FoafRDF.configuration.base_uri, :repository => :default
+      end
+    end
+    after do
+      LD4L::FoafRDF.reset
+      Object.send(:remove_const, "DummyPerson") if Object
+    end
+
+    it "should return configured value" do
+      config = LD4L::FoafRDF.configuration
+      expect(config.base_uri).to eq "http://localhost/test/"
+      expect(config.localname_minter).to be_kind_of Proc
+    end
+
+    it "should use configured value in Person sub-class" do
+      p = DummyPerson.new('1')
+      expect(p.rdf_subject.to_s).to eq "http://localhost/test/1"
+
+      p = DummyPerson.new(ActiveTriples::LocalName::Minter.generate_local_name(
+                                   LD4L::FoafRDF::Person, 10, 'foo',
+                                   &LD4L::FoafRDF.configuration.localname_minter ))
+      expect(p.rdf_subject.to_s.size).to eq 73
+      expect(p.rdf_subject.to_s).to match /http:\/\/localhost\/test\/foo_configured_[a-zA-Z0-9]{8}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{4}-[a-zA-Z0-9]{12}/
+    end
+  end
+
+  describe ".reset" do
+    before :each do
+      LD4L::FoafRDF.configure do |config|
+        config.base_uri = "http://localhost/test/"
+        config.localname_minter = lambda { |prefix=""| prefix+'_configured_'+SecureRandom.uuid }
+      end
+    end
+
+    it "resets the configuration" do
+      LD4L::FoafRDF.reset
+      config = LD4L::FoafRDF.configuration
+      expect(config.base_uri).to eq "http://localhost/"
+      expect(config.localname_minter).to eq nil
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'ld4l/foaf_rdf'
+require 'pry'
+
+Dir['./spec/support/**/*.rb'].each { |f| require f }
+
+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 = :progress
+end
+
+ActiveTriples::Repositories.add_repository :default, RDF::Repository.new

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: ld4l-foaf_rdf
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- E. Lynette Rayle
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: active_triples-local_name
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: LD4L FOAF RDF provides tools for modeling a person triples based on the
+  FOAF ontology and persisting to a triplestore.
+email:
+- elr37@cornell.edu
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- ".gitignore"
+- ".ruby-gemset"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ld4l-foaf_rdf.gemspec
+- lib/ld4l/foaf_rdf.rb
+- lib/ld4l/foaf_rdf/configuration.rb
+- lib/ld4l/foaf_rdf/person.rb
+- lib/ld4l/foaf_rdf/version.rb
+- spec/ld4l/foaf_rdf/configuration_spec.rb
+- spec/ld4l/foaf_rdf/person_rdf_spec.rb
+- spec/ld4l/foaf_rdf_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/ld4l/foaf_rdf
+licenses:
+- APACHE2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: FOAF RDF models.
+test_files:
+- spec/ld4l/foaf_rdf/configuration_spec.rb
+- spec/ld4l/foaf_rdf/person_rdf_spec.rb
+- spec/ld4l/foaf_rdf_spec.rb
+- spec/spec_helper.rb