ld4l-ore_rdf 0.0.4

data/spec/ld4l/ore_rdf/services/aggregation/persist_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe 'LD4L::OreRDF::PersistAggregation' do
+
+  describe "#call" do
+
+    xit "should have tests -- SO WRITE SOME" do
+
+    end
+
+  end
+
+end

data/spec/ld4l/ore_rdf/services/aggregation/resume_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe 'LD4L::OreRDF::ResumeAggregation' do
+
+  describe "#call" do
+
+    xit "should have tests -- SO WRITE SOME" do
+
+    end
+
+    context "when aggregation hasn't been persisted" do
+      xit "should return nil" do
+
+      end
+
+    end
+
+    context "when aggregation doesn't have proxies" do
+      xit "should resume aggregation resource into aggregation and return it" do
+
+      end
+
+
+    end
+
+    context "when aggregation has proxies" do
+      context "and all parts are persisted" do
+        xit "should resume aggregation resource and all proxy resources into aggregation and return it" do
+
+        end
+      end
+
+      context "and some proxies are persisted" do
+        xit "should resume aggregation resource and persisted proxies into aggregation and return it" do
+
+        end
+      end
+
+      context "and no proxies are persisted" do
+        xit "should resume aggregation resource into aggregation and return it" do
+
+        end
+      end
+    end
+  end
+end

data/spec/ld4l/ore_rdf/services/proxy/create_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe 'LD4L::OreRDF::CreateProxy' do
+
+   describe "#call" do
+    it "should create a LD4L::OreRDF::ProxyResource instance" do
+      aggregation  = LD4L::OreRDF::Aggregation.new
+      proxy = LD4L::OreRDF::CreateProxy.call(
+          resource:    RDF::URI("http://example.org/individual/b1"),
+          aggregation: aggregation)
+      expect(proxy).to be_kind_of LD4L::OreRDF::ProxyResource
+    end
+
+    context "when id is not passed in" do
+      it "should generate an id with random ending" do
+        aggregation  = LD4L::OreRDF::Aggregation.new
+        proxy = LD4L::OreRDF::CreateProxy.call(
+            resource:    RDF::URI("http://example.org/individual/b1"),
+            aggregation: aggregation)
+        uri = proxy.rdf_subject.to_s
+        expect(uri).to start_with "#{LD4L::OreRDF::ProxyResource.base_uri}#{LD4L::OreRDF::ProxyResource.localname_prefix}"
+        id = uri[uri.length-36..uri.length]
+        expect(id).to be_kind_of String
+        expect(id.length).to eq 36
+        expect(id).to match /[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
+
+      it "should set property values" do
+        aggregation  = LD4L::OreRDF::Aggregation.new
+        proxy = LD4L::OreRDF::CreateProxy.call(
+            resource:    RDF::URI("http://example.org/individual/b1"),
+            aggregation: aggregation)
+        expect(proxy.proxy_for.first.rdf_subject.to_s).to eq "http://example.org/individual/b1"
+        expect(proxy.proxy_in.first).to eq aggregation.aggregation_resource
+        expect(proxy.next_proxy).to eq []
+        expect(proxy.prev_proxy).to eq []
+        # expect(proxy.contentContent.first.rdf_subject.to_s).to eq "http://example.org/individual/b1"
+        # expect(proxy.index).to eq []
+        # expect(proxy.nextItem).to eq []
+        # expect(proxy.previousItem).to eq []
+        expect(proxy.contributor).to eq []
+      end
+    end
+
+    context "when partial id is passed in" do
+      it "should generate an id ending with partial id" do
+        aggregation  = LD4L::OreRDF::Aggregation.new
+        proxy = LD4L::OreRDF::CreateProxy.call(
+            id:          "123",
+            resource:    RDF::URI("http://example.org/individual/b1"),
+            aggregation: aggregation)
+        expect(proxy.rdf_subject.to_s).to eq "#{LD4L::OreRDF::ProxyResource.base_uri}123"
+      end
+
+      it "should set property values" do
+        aggregation  = LD4L::OreRDF::Aggregation.new
+        proxy = LD4L::OreRDF::CreateProxy.call(
+            id:          "123",
+            resource:    RDF::URI("http://example.org/individual/b1"),
+            aggregation: aggregation)
+        expect(proxy.proxy_for.first.rdf_subject.to_s).to eq "http://example.org/individual/b1"
+        expect(proxy.proxy_in.first).to eq aggregation.aggregation_resource
+        expect(proxy.next_proxy).to eq []
+        expect(proxy.prev_proxy).to eq []
+        # expect(proxy.contentContent.first.rdf_subject.to_s).to eq "http://example.org/individual/b1"
+        # expect(proxy.index).to eq []
+        # expect(proxy.nextItem).to eq []
+        # expect(proxy.previousItem).to eq []
+        expect(proxy.contributor).to eq []
+      end
+    end
+
+    context "when URI id is passed in" do
+      it "should use passed in id" do
+        aggregation  = LD4L::OreRDF::Aggregation.new
+        proxy = LD4L::OreRDF::CreateProxy.call(
+            id:          "http://example.org/individual/ag123",
+            resource:    RDF::URI("http://example.org/individual/b1"),
+            aggregation: aggregation)
+        expect(proxy.rdf_subject.to_s).to eq "http://example.org/individual/ag123"
+      end
+
+      it "should set property values" do
+        aggregation  = LD4L::OreRDF::Aggregation.new
+        proxy = LD4L::OreRDF::CreateProxy.call(
+            id:          "http://example.org/individual/ag123",
+            resource:    RDF::URI("http://example.org/individual/b1"),
+            aggregation: aggregation)
+        expect(proxy.proxy_for.first.rdf_subject.to_s).to eq "http://example.org/individual/b1"
+        expect(proxy.proxy_in.first).to eq aggregation.aggregation_resource
+        expect(proxy.next_proxy).to eq []
+        expect(proxy.prev_proxy).to eq []
+        # expect(proxy.itemContent.first.rdf_subject.to_s).to eq "http://example.org/individual/b1"
+        # expect(proxy.index).to eq []
+        # expect(proxy.nextItem).to eq []
+        # expect(proxy.previousItem).to eq []
+        expect(proxy.contributor).to eq []
+      end
+    end
+
+    context "when collection is unordered" do
+      context "and insert_position is missing" do
+        xit "should add item without setting ordered properties" do
+          pending "this needs to be implemented"
+        end
+      end
+
+      context "and insert position is passed in" do
+        xit "should convert the list from unordered to ordered" do
+          pending "this needs to be implemented"
+        end
+
+        xit "should set ordered properties for new item" do
+          pending "this needs to be implemented"
+        end
+
+        xit "should not change any other items in the collection" do
+          # TODO Is this really the behavior we want when converting from unordered to ordered?
+          pending "this needs to be implemented"
+        end
+      end
+    end
+
+    context "when collection is ordered" do
+      context "and insert_position is missing" do
+        xit "should append item to the end of the collection" do
+          pending "this needs to be implemented"
+        end
+      end
+
+      context "and insert position is passed in" do
+        xit "should set ordered properties for new item" do
+          pending "this needs to be implemented"
+        end
+
+        xit "should not change any other items in the collection" do
+          # TODO Is this really the behavior we want for ordered lists to be partially ordered?
+          pending "this needs to be implemented"
+        end
+      end
+    end
+  end
+end

data/spec/ld4l/ore_rdf/services/proxy/find_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe 'LD4L::OreRDF::FindProxies' do
+
+  describe "#call" do
+
+    context "when repository is empty" do
+      before do
+        ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+      end
+      it "should return an empty array" do
+        proxies = LD4L::OreRDF::FindProxies.call(
+            :aggregation => 'http://example.org/NON-EXISTING-AGGREGATION' )
+        expect(proxies).to eq []
+      end
+    end
+
+    context "when repository has one aggregation with one proxy" do
+      before do
+        p = LD4L::FoafRDF::Person.new("http://vivo.cornell.edu/individual/JohnSmith")
+        p.persist!
+
+        ag1 = LD4L::OreRDF::CreateAggregation.call(
+            id:          "http::/example.org/ag1",
+            title:       "Aggregation 1",
+            description: "Test description of aggregation 1.",
+            owner:       p )
+        LD4L::OreRDF::AddAggregatedResources.call(
+            ag1,
+            [RDF::URI("http://example.org/individual/b11")])
+        LD4L::OreRDF::PersistAggregation.call(ag1)
+      end
+      after do
+        ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+      end
+
+      it "should return an array with 1 value" do
+        proxies = LD4L::OreRDF::FindProxies.call(
+            :aggregation => 'http::/example.org/ag1' )
+        expect(proxies.size).to eq 1
+        expect(proxies.first).to be_a_kind_of RDF::URI
+        pr = LD4L::OreRDF::ProxyResource.new(proxies.first)
+        expect(pr.proxy_in.first.rdf_subject).to eq RDF::URI("http::/example.org/ag1")
+        expect(pr.proxy_for.first.rdf_subject).to eq RDF::URI("http://example.org/individual/b11")
+      end
+    end
+
+    context "when repository has multiple aggregations with proxies" do
+      before do
+        p = LD4L::FoafRDF::Person.new("http://vivo.cornell.edu/individual/JohnSmith")
+        p.persist!
+
+        ag1 = LD4L::OreRDF::CreateAggregation.call(
+            id:          "http::/example.org/ag1",
+            title:       "Aggregation 1",
+            description: "Test description of aggregation 1.",
+            owner:       p )
+        LD4L::OreRDF::AddAggregatedResources.call(
+            ag1,
+            [RDF::URI("http://example.org/individual/b11"),
+             RDF::URI("http://example.org/individual/b12"),
+             RDF::URI("http://example.org/individual/b13")])
+        LD4L::OreRDF::PersistAggregation.call(ag1)
+
+        ag2 = LD4L::OreRDF::CreateAggregation.call(
+            id:          "http::/example.org/ag2",
+            title:       "Aggregation 2",
+            description: "Test description of aggregation 2.",
+            owner:       p )
+        LD4L::OreRDF::AddAggregatedResources.call(
+            ag2,
+            [RDF::URI("http://example.org/individual/b21"),
+             RDF::URI("http://example.org/individual/b22"),
+             RDF::URI("http://example.org/individual/b23")])
+        LD4L::OreRDF::PersistAggregation.call(ag2)
+
+        ag3 = LD4L::OreRDF::CreateAggregation.call(
+            id:          "http::/example.org/ag3",
+            title:       "Aggregation 3",
+            description: "Test description of aggregation 3.",
+            owner:       p )
+        LD4L::OreRDF::AddAggregatedResources.call(
+            ag3,
+            [RDF::URI("http://example.org/individual/b31"),
+             RDF::URI("http://example.org/individual/b32"),
+             RDF::URI("http://example.org/individual/b33")])
+        LD4L::OreRDF::PersistAggregation.call(ag3)
+      end
+      after do
+        ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+      end
+
+      xit "should find aggregation by rdf_subject" do
+
+
+        # TODO not sure how to write the criteria for this test
+
+
+        # proxies = LD4L::OreRDF::FindAggregations.call(
+        #     :aggregation => "http::/example.org/ag2",
+        #     :criteria    => { :subject => "http::/example.org/individual/v21" }  )
+        # expect(proxies).not_to include "http::/example.org/ag1"
+        # expect(proxies).not_to include "http::/example.org/ag2"
+        # expect(proxies).to include "http::/example.org/ag3"
+        # expect(proxies.size).to eq 1
+      end
+
+      it "should find proxies by criteria (aka proxy_for)" do
+        proxies = LD4L::OreRDF::FindProxies.call(
+            :aggregation => 'http::/example.org/ag2',
+            :criteria => { RDFVocabularies::ORE.proxyFor => RDF::URI("http://example.org/individual/b22") } )
+        expect(proxies.size).to eq 1
+        expect(proxies.first).to be_a_kind_of RDF::URI
+        pr = LD4L::OreRDF::ProxyResource.new(proxies.first)
+        expect(pr.proxy_for.first.rdf_subject).to eq RDF::URI("http://example.org/individual/b22")
+        expect(pr.proxy_in.first.rdf_subject).to eq RDF::URI("http::/example.org/ag2")
+      end
+
+      it "should find all proxies for aggregation" do
+        proxies = LD4L::OreRDF::FindProxies.call(
+            :aggregation => 'http::/example.org/ag3' )
+        expect(proxies.size).to eq 3
+        proxy_for = []
+        proxies.each do |p|
+          expect(p).to be_a_kind_of RDF::URI
+          pr = LD4L::OreRDF::ProxyResource.new(p)
+          proxy_for << pr.proxy_for.first.rdf_subject
+          expect(pr.proxy_in.first.rdf_subject).to eq RDF::URI("http::/example.org/ag3")
+        end
+        expect(proxy_for).to include RDF::URI("http://example.org/individual/b31")
+        expect(proxy_for).to include RDF::URI("http://example.org/individual/b32")
+        expect(proxy_for).to include RDF::URI("http://example.org/individual/b33")
+      end
+
+    end
+
+  end
+end

data/spec/ld4l/ore_rdf_spec.rb

@@ -0,0 +1,53 @@
+require "spec_helper"
+
+describe "LD4L::OreRDF" do
+  describe "#configure" do
+
+    before do
+      LD4L::OreRDF.configure do |config|
+        config.base_uri = "http://localhost/test/"
+        config.localname_minter = lambda { |prefix=""| prefix+'_configured_'+SecureRandom.uuid }
+      end
+      class DummyAggregation < LD4L::OreRDF::AggregationResource
+        configure :type => RDFVocabularies::ORE.Aggregation, :base_uri => LD4L::OreRDF.configuration.base_uri, :repository => :default
+      end
+    end
+    after do
+      LD4L::OreRDF.reset
+      Object.send(:remove_const, "DummyAggregation") if Object
+    end
+
+    it "should return configured value" do
+      config = LD4L::OreRDF.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 = DummyAggregation.new('1')
+      expect(p.rdf_subject.to_s).to eq "http://localhost/test/1"
+
+      oa = DummyAggregation.new(ActiveTriples::LocalName::Minter.generate_local_name(
+                 LD4L::OreRDF::AggregationResource, 10, 'foo',
+                 &LD4L::OreRDF.configuration.localname_minter ))
+      expect(oa.rdf_subject.to_s.size).to eq 73
+      expect(oa.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::OreRDF.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::OreRDF.reset
+      config = LD4L::OreRDF.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,23 @@
+require 'coveralls'
+Coveralls.wear!
+
+require 'bundler/setup'
+Bundler.setup
+
+require 'ld4l/ore_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,259 @@
+--- !ruby/object:Gem::Specification
+name: ld4l-ore_rdf
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- E. Lynette Rayle
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-18 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
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !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: ld4l-foaf_rdf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: doubly_linked_list
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !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: coveralls
+  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 ORE RDF provides tools for modeling list triples based on the ORE
+  ontology and persisting to a triplestore.
+email:
+- elr37@cornell.edu
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- ".coveralls.yml"
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ld4l-ore_rdf.gemspec
+- lib/ld4l/ore_rdf.rb
+- lib/ld4l/ore_rdf/configuration.rb
+- lib/ld4l/ore_rdf/models/aggregation.rb
+- lib/ld4l/ore_rdf/models/aggregation_resource.rb
+- lib/ld4l/ore_rdf/models/proxy_resource.rb
+- lib/ld4l/ore_rdf/services/aggregation/add_aggregated_resource.rb
+- lib/ld4l/ore_rdf/services/aggregation/add_aggregated_resources.rb
+- lib/ld4l/ore_rdf/services/aggregation/create.rb
+- lib/ld4l/ore_rdf/services/aggregation/destroy.rb
+- lib/ld4l/ore_rdf/services/aggregation/destroy_with_id.rb
+- lib/ld4l/ore_rdf/services/aggregation/find.rb
+- lib/ld4l/ore_rdf/services/aggregation/persist.rb
+- lib/ld4l/ore_rdf/services/aggregation/resume.rb
+- lib/ld4l/ore_rdf/services/proxy/create.rb
+- lib/ld4l/ore_rdf/services/proxy/find.rb
+- lib/ld4l/ore_rdf/version.rb
+- lib/ld4l/ore_rdf/vocab/co.rb
+- lib/ld4l/ore_rdf/vocab/dcterms.rb
+- lib/ld4l/ore_rdf/vocab/iana.rb
+- lib/ld4l/ore_rdf/vocab/ore.rb
+- spec/ld4l/ore_rdf/configuration_spec.rb
+- spec/ld4l/ore_rdf/models/aggregation_resource_spec.rb
+- spec/ld4l/ore_rdf/models/aggregation_spec.rb
+- spec/ld4l/ore_rdf/models/proxy_resource_spec.rb
+- spec/ld4l/ore_rdf/services/aggregation/add_aggregated_resource_spec.rb
+- spec/ld4l/ore_rdf/services/aggregation/add_aggregated_resources_spec.rb
+- spec/ld4l/ore_rdf/services/aggregation/create_spec.rb
+- spec/ld4l/ore_rdf/services/aggregation/destroy_spec.rb
+- spec/ld4l/ore_rdf/services/aggregation/find_spec.rb
+- spec/ld4l/ore_rdf/services/aggregation/persist_spec.rb
+- spec/ld4l/ore_rdf/services/aggregation/resume_spec.rb
+- spec/ld4l/ore_rdf/services/proxy/create_spec.rb
+- spec/ld4l/ore_rdf/services/proxy/find_spec.rb
+- spec/ld4l/ore_rdf_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/ld4l/ore_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: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.3
+signing_key: 
+specification_version: 4
+summary: ORE RDF models.
+test_files:
+- spec/ld4l/ore_rdf/configuration_spec.rb
+- spec/ld4l/ore_rdf/models/aggregation_resource_spec.rb
+- spec/ld4l/ore_rdf/models/aggregation_spec.rb
+- spec/ld4l/ore_rdf/models/proxy_resource_spec.rb
+- spec/ld4l/ore_rdf/services/aggregation/add_aggregated_resource_spec.rb
+- spec/ld4l/ore_rdf/services/aggregation/add_aggregated_resources_spec.rb
+- spec/ld4l/ore_rdf/services/aggregation/create_spec.rb
+- spec/ld4l/ore_rdf/services/aggregation/destroy_spec.rb
+- spec/ld4l/ore_rdf/services/aggregation/find_spec.rb
+- spec/ld4l/ore_rdf/services/aggregation/persist_spec.rb
+- spec/ld4l/ore_rdf/services/aggregation/resume_spec.rb
+- spec/ld4l/ore_rdf/services/proxy/create_spec.rb
+- spec/ld4l/ore_rdf/services/proxy/find_spec.rb
+- spec/ld4l/ore_rdf_spec.rb
+- spec/spec_helper.rb