ld4l-ore_rdf 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 42f818dcf199be0185f9263e59b29021005da3ff
+  data.tar.gz: ee3b57a06cf31f8cff3960671084125dc36c97c0
+SHA512:
+  metadata.gz: 4d14dc0c0b6fd35c6dfe8cf219f4fb76634c9e068e6d5cb1de12a1b85aabd309460ec6d29c8a5f0940f5c8935fd983ab61f4f422df04695b0f12dd252d060a7b
+  data.tar.gz: 3138b70ced75abfd2cda84bef5ad24acfa5a3f2c58ab01828397234669533261574890c67b0a47d0708544d832d4f6a6465afc7effbe19213cf3f8bfe3697b21

data/.coveralls.yml

@@ -0,0 +1 @@
+service_name: travis-ci

data/.gitignore

@@ -0,0 +1,25 @@
+*.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
+.ruby-gemset
+.ruby-version

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+bundler_args: --without debug
+script: "bundle exec rspec spec"
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.1.1
+  - jruby-19mode
+matrix:
+  allow_failures:
+      - rvm: jruby-19mode

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

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,171 @@
+#LD4L::OreRDF
+
+[![Build Status](https://travis-ci.org/ld4l/ore_rdf.png?branch=rework_with_service_objects)](https://travis-ci.org/ld4l/ore_rdf) 
+[![Coverage Status](https://coveralls.io/repos/ld4l/ore_rdf/badge.png?branch=rework_with_service_objects)](https://coveralls.io/r/ld4l/ore_rdf?branch=rework_with_service_objects)
+[![Gem Version](https://badge.fury.io/rb/ld4l-ore_rdf.svg)](http://badge.fury.io/rb/ld4l-ore_rdf)
+[![Dependency Status](https://www.versioneye.com/ruby/ld4l-ore_rdf/0.0.3/badge.svg)](https://www.versioneye.com/ruby/ld4l-ore_rdf/0.0.3)
+
+
+
+LD4L ORE RDF provides tools for modeling list triples based on the ORE 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-ore_rdf'
+    
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install ld4l-ore_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/ore_rdf'
+
+# create an in-memory repository
+ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
+
+p = LD4L::FoafRDF::Person.new('p4')
+```
+
+#### Example: Aggregation with items individually
+```
+agg10 = LD4L::OreRDF::CreateAggregation.call( :id=>'agg10', :title=>'My Resources', :description=>'Resources that I like', :owner=>p )
+
+LD4L::OreRDF::AddAggregatedResource.call( agg10,'http://exmple.org/resource_1')
+LD4L::OreRDF::AddAggregatedResource.call( agg10'http://exmple.org/resource_2')
+LD4L::OreRDF::AddAggregatedResource.call( agg10,'http://exmple.org/resource_3')
+
+LD4L::OreRDF::PersistAggregation.call(agg10)
+
+puts agg10.dump :ttl
+
+# To resume the aggregation at a later time, use...
+agg = LD4L::OreRDF::ResumeAggregation.call( 'agg10' )
+```
+
+#### Example: Aggregation with items as array
+```
+agg11 = LD4L::OreRDF::CreateAggregation.call( :id=>'agg11', :title=>'More Resources', :description=>'More resources that I like', :owner=>p )
+
+resources = [ 'http://exmple.org/resource_5', 'http://exmple.org/resource_6', 'http://exmple.org/resource_7' ]
+LD4L::OreRDF::AddAggregatedResources.call( agg11,resources)
+
+LD4L::OreRDF::PersistAggregation.call(agg11)
+
+puts agg11.dump :ttl
+
+# To resume the aggregation at a later time, use...
+agg = LD4L::OreRDF::ResumeAggregation.call( 'agg10' )
+```
+
+#### Example: Find all aggregations
+```
+# Find all and return only the URIs for each aggregation
+aggregation_uris = LD4L::OreRDF::FindAggregations.call
+
+# Find all and return title and description
+aggregation_properties = LD4L::OreRDF::FindAggregations.call(
+    :properties => { :title => RDF::DC.title, :description => RDF::DC.description } )
+
+```
+
+
+### 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::OreRDF.configure do |config|
+  config.base_uri = "http://example.org/"
+end
+
+a = LD4L::OreRDF::AggregationResource.new(ActiveTriples::LocalName::Minter.generate_local_name(
+              LD4L::OreRDF::AggregationResource, 10, {:prefix=>'ag'} ))
+
+puts a.dump :ttl
+```
+NOTE: If base_uri is not used, you need to restart your interactive environment (e.g. irb, pry).  Once the 
+  Aggregation 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 an aggregation with configured base_uri and default minter.*
+```
+<http://example.org/ag45c9c85b-25af-4c52-96a4-cf0d8b70a768> a <http://www.openarchives.org/ore/terms/Aggregation> .
+```
+
+*Example usage using configured base_uri and configured localname_minter.*
+```
+LD4L::OreRDF.configure do |config|
+  config.base_uri = "http://example.org/"
+  config.localname_minter = lambda { |prefix=""| prefix+'_configured_'+SecureRandom.uuid }
+end
+
+a = LD4L::OreRDF::AggregationResource.new(ActiveTriples::LocalName::Minter.generate_local_name(
+              LD4L::OreRDF::AggregationResource, 10, 'ag',
+              &LD4L::OreRDF.configuration.localname_minter ))
+
+puts a.dump :ttl
+```
+NOTE: If base_uri is not used, you need to restart your interactive environment (e.g. irb, pry).  Once the 
+  Aggregation 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 an aggregation with configured base_uri and configured minter.*
+```
+<http://example.org/ag_configured_6498ba05-8b21-4e8c-b9d4-a6d5d2180966> a <http://www.openarchives.org/ore/terms/Aggregation> .
+   ```
+
+
+### Models
+
+The LD4L::OreRDF 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::OreRDF::AggregationResource - Implements the Aggregation class in the ORE ontology.
+1. LD4L::OreRDF::ProxyResource - Implements the Proxy class in the ORE ontology.
+
+### Ontologies
+
+The listed ontologies are used to represent the primary metadata about aggregation lists.
+Other ontologies may also be used that aren't listed.
+ 
+* [ORE](http://www.openarchives.org/ore/1.0/vocabulary)
+* [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-ore_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-ore_rdf.gemspec

@@ -0,0 +1,45 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ld4l/ore_rdf/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ld4l-ore_rdf"
+  spec.version       = LD4L::OreRDF::VERSION
+  spec.authors       = ["E. Lynette Rayle"]
+  spec.email         = ["elr37@cornell.edu"]
+  spec.platform      = Gem::Platform::RUBY
+  spec.summary       = %q{ORE RDF models.}
+  spec.description   = %q{LD4L ORE RDF provides tools for modeling list triples based on the ORE ontology and persisting to a triplestore.}
+  spec.homepage      = "https://github.com/ld4l/ore_rdf"
+  spec.license       = "APACHE2"
+  spec.required_ruby_version     = '>= 1.9.3'
+
+  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')
+
+  spec.add_dependency('active-triples', '~> 0.5')
+  spec.add_dependency('active_triples-local_name', '~> 0.1')
+  spec.add_dependency('ld4l-foaf_rdf', '~> 0.0')
+  spec.add_dependency('doubly_linked_list', '~> 0.0')
+
+  spec.add_development_dependency('pry')
+  # spec.add_development_dependency('pry-byebug')    # Works with ruby > 2
+  # spec.add_development_dependency('pry-debugger')  # Works with ruby < 2
+  spec.add_development_dependency('rdoc')
+  spec.add_development_dependency('rspec')
+  spec.add_development_dependency('coveralls')
+  spec.add_development_dependency('guard-rspec')
+  spec.add_development_dependency('webmock')
+
+  spec.extra_rdoc_files = [
+      "LICENSE.txt",
+      "README.md"
+  ]
+end
+

data/lib/ld4l/ore_rdf/configuration.rb

@@ -0,0 +1,41 @@
+module LD4L
+  module OreRDF
+    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/ore_rdf/models/aggregation.rb

@@ -0,0 +1,50 @@
+require 'active_model'
+module LD4L
+  module OreRDF
+    class Aggregation < DoublyLinkedList
+
+      def self.initialize
+        super
+      end
+
+      def initialize(*args)
+        new_args = args[0].dup unless args.empty?
+        unless args.empty?
+          new_args[:items]     = new_args[:proxy_resources]      if new_args.is_a?(Hash) && new_args.key?(:proxy_resources)
+          new_args[:list_info] = new_args[:aggregation_resource] if new_args.is_a?(Hash) && new_args.key?(:aggregation_resource)
+          new_args.delete(:proxy_resources)
+          new_args.delete(:aggregation_resource)
+        end
+        super(new_args)
+      end
+
+      def id
+        list_info.rdf_subject.to_s
+      end
+
+      def title
+        titles = list_info.title
+        titles.kind_of?(Array) && titles.size > 0 ? titles[0] : ""
+      end
+
+      def description
+        descriptions = list_info.description
+        descriptions.kind_of?(Array) && descriptions.size > 0 ? descriptions[0] : ""
+      end
+
+      def aggregation_resource
+        list_info
+      end
+
+      def proxy_resources
+        @list
+      end
+
+#       def self.model_name
+#         ActiveModel::Name.new(LD4L::OreRDF::Aggregation)
+#       end
+
+    end
+  end
+end
+

data/lib/ld4l/ore_rdf/models/aggregation_resource.rb

@@ -0,0 +1,98 @@
+module LD4L
+  module OreRDF
+    class AggregationResource < ActiveTriples::Resource
+
+      class << self; attr_reader :localname_prefix end
+      @localname_prefix="ag"
+
+      # TODO... Can we change type from Set to List to go from unordered list to ordered list?
+      # TODO    Should properties for ordered lists be blocked until the list is turned into an ordered list?
+      # TODO    Can you go from an ordered list back to an unordered list?
+      # TODO    Can you apply order to only parts of the list, or does applying order imply all items are now ordered?
+      # TODO    If all items are now ordered, what is the process for going through all subitems and adding order information?
+
+
+      # TODO... items are not persisted when this class is persisted because there is not connection from this class to the items
+      # TODO    Either the persist! method needs to be overridden to also save the items (which would also require an items attribute to hold them)
+      # TODO    OR the item property needs to be uncommented allowing the built in functionality to save them.
+      # TODO    DOWNSIDE: items and aggregators could get out of sync.  Then which is right?  Could be a problem with the first option too.
+
+
+      configure :type => RDFVocabularies::ORE.Aggregation, :base_uri => LD4L::OreRDF.configuration.base_uri, :repository => :default
+
+      # extended properties for LD4L implementation
+      property :title,       :predicate => RDF::DC.title
+      property :description, :predicate => RDF::DC.description
+      property :owner,       :predicate => RDFVocabularies::DCTERMS.creator, :class_name => LD4L::FoafRDF::Person
+
+      # properties from ORE.Aggregation
+      property :aggregates,   :predicate => RDFVocabularies::ORE.aggregates   # multiple values
+      property :first_proxy,  :predicate => RDFVocabularies::IANA.first,     :class_name => LD4L::OreRDF::ProxyResource
+      property :last_proxy,   :predicate => RDFVocabularies::IANA.last,      :class_name => LD4L::OreRDF::ProxyResource
+
+
+      # --------------------- #
+      #    HELPER METHODS     #
+      # --------------------- #
+
+
+      ########### NEED TO MOVE TO SERVICE OBJECT ####################
+
+
+      # Returns an array the items in the aggregation.
+      # TODO: How to begin at start and limit to number of returned items, effectively handling ranges of data.
+      def get_items_content(start=nil,limit=nil)
+        # TODO: Stubbed to return all items.
+        get_values('aggregates')
+      end
+
+      # Returns an array of persisted LD4L::OreRDF::ProxyResource instances for the items in the`` aggregation.
+      def get_items(start=nil,limit=nil)
+        LD4L::OreRDF::ProxyResource.get_range(self, start, limit)
+      end
+
+      # Get the persisted LD4L::OreRDF::ProxyResource instance that holds the content
+      # NOTE: Not implemented.
+      def find_item_with_content(content)
+        # TODO Stubbed - Requires definition and implementation
+      end
+
+      # Return the content at the specified position in an ordered collection
+      def get_item_content_at(position)
+        # TODO Stubbed - Required definition and implementation
+      end
+
+      # Return the LD4L::OreRDF::ProxyResource instance for the item at the specified position in an ordered collection
+      def get_item_at(position)
+        # TODO Stubbed - Required definition and implementation
+      end
+
+      # Determine if the content is already in the aggregation
+      def has_item_content?(content)
+        # TODO Stubbed - Requires definition and implementation
+      end
+
+      # Determine if an item exists at the specified position in the ordered aggregation
+      def has_item_at?(position)
+        # TODO Stubbed - Requires definition and implementation
+      end
+
+      # Destroy the item with the content and remove content from the aggregation
+      def destroy_item_with_content(content)
+        # TODO Stubbed - Requires definition and implementation
+      end
+
+      # Destroy the item at specified position and remove content from the aggregation
+      def destroy_item_at(position)
+        # TODO Stubbed - Requires definition and implementation
+      end
+
+      # Determine if the aggregation holds an ordered list of items
+      def is_ordered?
+        # TODO Stubbed to always return false until ordered lists are implemented
+        return false
+      end
+    end
+  end
+end
+