ld4l-ore_rdf 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8e31d9fd5075fcc5d9ca073e2edc850521ff7c2c
-  data.tar.gz: 54e5d4ff97cb4440f19134f7aac22531985ab5c9
+  metadata.gz: 650e31b76de505d43da11cb67a96f9bf3013f5bf
+  data.tar.gz: 64e3f97cb4eef3aa5c9d5a7df26483f4e3b4a16f
 SHA512:
-  metadata.gz: 7afdc0e5c94bc9f31e9ad2129eeb65be6d81fbf1ad8d0441c84169960017eff94f4d3296cd7a5797671318c8412d306145a88cb389eff04d81f1635524cf7b93
-  data.tar.gz: 0f2f08759d02ce86969a0c3b98438f007ee1d343986b5417e9931450a32049f8934cac981142906450b68a7bc5952a6852d9e11ae6bb4a92c11830183a896806
+  metadata.gz: 31ada8c13d62de9c533d8719db93008dfa3204d41786c972b5de28c9678515ddcb6b486eccafdcb7288b8ce7364993adc25545a871c86fc08c7952636d1dab5e
+  data.tar.gz: 05561fe6b9a47f0ce9ce441ecbd738a16c952cc5165a8e18e49b0d7c8a5b8e4e7cecb5dfd5c968f0346b543bc3fc381f6f9375351fe192dace8834c9b1001580

data/.travis.yml

@@ -1,12 +1,14 @@
 language: 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.4
+ - 2.3.0
+ - jruby-9.0.4.0
+ - rbx-2
 matrix:
   allow_failures:
-      - rvm: jruby-19mode
+      - rvm: jruby-9.0.4.0
+      - rvm: rbx-2

data/CHANGES.md

@@ -1,3 +1,7 @@
+0.2.0
+-----
+* Add ability to write to solr index from PersistAggregation service
+
 0.1.0
 -----
 * Updated to work with ActiveTriples 0.5, 0.6, and 0.8.2

data/Gemfile

@@ -1,3 +1,5 @@
 source 'https://rubygems.org'
 
 gemspec
+
+gem 'active-triples', :github => 'ActiveTriples/ActiveTriples', :branch => 'fix206_exclude_othersubj_preds'

data/README.md

@@ -42,6 +42,12 @@ require 'ld4l/ore_rdf'
 # create an in-memory repository
 ActiveTriples::Repositories.add_repository :default, RDF::Repository.new
 
+# configure the solr url
+ActiveTriples::Solrizer.configure do |config|
+  config.solr_uri = "http://localhost:8983/solr/#/~cores/active_triples"
+end
+
+
 p = LD4L::FoafRDF::Person.new('p4')
 ```
 

data/ld4l-ore_rdf.gemspec

@@ -20,10 +20,11 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency('rdf', '= 1.99.0')
 
-  spec.add_dependency('active-triples', '~> 0.5', '~> 0.6', '~>0.8.2')
-  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_dependency('active-triples')
+  spec.add_dependency('active_triples-local_name')
+  spec.add_dependency('active_triples-solrizer')
+  spec.add_dependency('ld4l-foaf_rdf')
+  spec.add_dependency('doubly_linked_list')
 
   spec.add_development_dependency('pry')
   spec.add_development_dependency('pry-byebug')

data/lib/ld4l/ore_rdf.rb

@@ -1,6 +1,7 @@
 require 'rdf'
 require 'active_triples'
 require 'active_triples/local_name'
+require 'active_triples/solrizer'
 require	'linkeddata'
 require 'doubly_linked_list'
 require 'ld4l/foaf_rdf'
@@ -48,6 +49,7 @@ module LD4L
     autoload :CreateAggregation,      'ld4l/ore_rdf/services/aggregation/create'
     autoload :PersistAggregation,     'ld4l/ore_rdf/services/aggregation/persist'
     autoload :ResumeAggregation,      'ld4l/ore_rdf/services/aggregation/resume'
+    autoload :LoadAggregationFromSolr,'ld4l/ore_rdf/services/aggregation/load_from_solr'
     autoload :DestroyAggregation,     'ld4l/ore_rdf/services/aggregation/destroy'
     autoload :FindAggregations,       'ld4l/ore_rdf/services/aggregation/find'
     autoload :AddAggregatedResource,  'ld4l/ore_rdf/services/aggregation/add_aggregated_resource'
@@ -55,22 +57,6 @@ module LD4L
 
     autoload :CreateProxy,            'ld4l/ore_rdf/services/proxy/create'
     autoload :FindProxies,            'ld4l/ore_rdf/services/proxy/find'
-
-    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/lib/ld4l/ore_rdf/models/aggregation.rb

@@ -3,36 +3,36 @@ module LD4L
   module OreRDF
     class Aggregation < DoublyLinkedList
 
-      @@clear_first_callback  = lambda { |aggregation| aggregation.first_proxy = [] }
-      @@clear_last_callback   = lambda { |aggregation| aggregation.last_proxy  = [] }
+      @@clear_first_callback  = lambda { |aggregation| aggregation.first_proxy = nil }
+      @@clear_last_callback   = lambda { |aggregation| aggregation.last_proxy  = nil }
       @@update_first_callback = lambda { |aggregation, proxies| aggregation.first_proxy = proxies.first }
       @@update_last_callback  = lambda { |aggregation, proxies| aggregation.last_proxy  = proxies.last }
 
-      @@clear_next_callback   = lambda { |proxies, idx| proxies[idx].next_proxy = [] }
-      @@clear_prev_callback   = lambda { |proxies, idx| proxies[idx].prev_proxy = [] }
+      @@clear_next_callback   = lambda { |proxies, idx| proxies[idx].next_proxy = nil }
+      @@clear_prev_callback   = lambda { |proxies, idx| proxies[idx].prev_proxy = nil }
       @@update_next_callback  = lambda { |proxies, idx| proxies[idx].next_proxy = proxies[idx+1] }
       @@update_prev_callback  = lambda { |proxies, idx| proxies[idx].prev_proxy = proxies[idx-1] }
 
       @@find_first_callback   = lambda do |aggregation, proxies|
         first_proxy = aggregation.first_proxy
-        return first_proxy.first   if first_proxy && !first_proxy.empty?
+        return first_proxy unless first_proxy.nil?
 
         # if first isn't set, try to figure out first by looking for an item with prev_proxy == nil
         # NOTE: If multiple items have prev_proxy == nil, it will return the first one it finds.
-        first_idx = proxies.index { |proxy| proxy.prev_proxy == [] }
+        first_idx = proxies.index { |proxy| proxy.prev_proxy.nil? }
         first_idx ? proxies[first_idx] : nil
       end
       @@find_last_callback    = lambda do |aggregation, proxies|
         last_proxy = aggregation.last_proxy
-        return last_proxy.first   if last_proxy && !last_proxy.empty?
+        return last_proxy unless last_proxy.nil?
 
         # if last isn't set, try to figure out last by looking for an item with next_proxy == nil
         # NOTE: If multiple items have next_proxy == nil, it will return the first one it finds.
-        last_idx = proxies.index { |proxy| proxy.next_proxy == [] }
+        last_idx = proxies.index { |proxy| proxy.next_proxy.nil? }
         last_idx ? proxies[last_idx] : nil
       end
-      @@find_next_callback    = lambda { |proxies, current_proxy| current_proxy.next_proxy.first }
-      @@find_prev_callback    = lambda { |proxies, current_proxy| current_proxy.prev_proxy.first }
+      @@find_next_callback    = lambda { |proxies, current_proxy| current_proxy.next_proxy }
+      @@find_prev_callback    = lambda { |proxies, current_proxy| current_proxy.prev_proxy }
 
 
       def self.initialize
@@ -74,24 +74,14 @@ module LD4L
 
       def title
         titles = list_info.title
-        title = ""
-        if list_info.respond_to? 'persistence_strategy'  # >= ActiveTriples 0.8
-          title = titles.first if titles.kind_of?(ActiveTriples::Relation) && titles.size > 0
-        else  # < ActiveTriples 0.8
-          title = titles.first if titles.kind_of?(Array) && titles.size > 0
-        end
-        title
+        titles = titles.to_a if Object::ActiveTriples.const_defined?("Relation") && titles.kind_of?(ActiveTriples::Relation)
+        titles.kind_of?(Array) && titles.size > 0 ? titles.first : ""
       end
 
       def description
         descriptions = list_info.description
-        description = ""
-        if list_info.respond_to? 'persistence_strategy'  # >= ActiveTriples 0.8
-          description = descriptions.first if descriptions.kind_of?(ActiveTriples::Relation) && descriptions.size > 0
-        else  # < ActiveTriples 0.8
-          description = descriptions.first if descriptions.kind_of?(Array) && descriptions.size > 0
-        end
-        description
+        descriptions = descriptions.to_a if Object::ActiveTriples.const_defined?("Relation") && descriptions.kind_of?(ActiveTriples::Relation)
+        descriptions.kind_of?(Array) && descriptions.size > 0 ? descriptions.first : ""
       end
 
       def aggregation_resource
@@ -106,6 +96,15 @@ module LD4L
 #         ActiveModel::Name.new(LD4L::OreRDF::Aggregation)
 #       end
 
+      private
+        def self.get_first_value source, value, as_subject=false
+          val = value
+          val = val.to_a if Object::ActiveTriples.const_defined?("Relation") && val.kind_of?(ActiveTriples::Relation)
+          return nil if val.nil? || val.size <= 0
+          val = val.first if val.is_a? Array
+          val = val.rdf_subject.to_s if as_subject && (val.is_a? ActiveTriples::Resource)
+          val
+        end
     end
   end
 end

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

@@ -21,14 +21,53 @@ module LD4L
       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
+      property :title, :predicate => RDF::DC.title do |index|
+        index.data_type = :text
+        index.as :indexed, :sortable
+      end
+      property :description, :predicate => RDF::DC.description do |index|
+        index.data_type = :text
+        index.as :indexed
+      end
+      property :owner, :predicate => RDFVocabularies::DCTERMS.creator, :class_name => LD4L::FoafRDF::Person do |index|
+        index.data_type = :string
+        index.as :stored, :indexed
+      end
 
       # properties from ORE.Aggregation
-      property :aggregates,   :predicate => RDFVocabularies::ORE.aggregates, :cast => false  # 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
+      property :aggregates, :predicate => RDFVocabularies::ORE.aggregates, :cast => false do |index|
+        index.data_type = :text
+        index.as :stored, :indexed, :multiValued
+      end
+      property :first_proxy_,  :predicate => RDFVocabularies::IANA.first,     :class_name => LD4L::OreRDF::ProxyResource
+      property :last_proxy_,   :predicate => RDFVocabularies::IANA.last,      :class_name => LD4L::OreRDF::ProxyResource
+
+
+      def first_proxy= value
+        value = [] if value.nil?
+        self.first_proxy_ = value
+      end
+
+      def first_proxy
+        OreRDF::Aggregation.get_first_value self, first_proxy_
+      end
+
+      def first_proxy_subject
+        OreRDF::Aggregation.get_first_value self, first_proxy_, true
+      end
+
+      def last_proxy= value
+        value = [] if value.nil?
+        self.last_proxy_ = value
+      end
+
+      def last_proxy
+        OreRDF::Aggregation.get_first_value self, last_proxy_
+      end
+
+      def last_proxy_subject
+        OreRDF::Aggregation.get_first_value self, last_proxy_, true
+      end
 
 
       # --------------------- #
@@ -92,7 +131,35 @@ module LD4L
         # TODO Stubbed to always return false until ordered lists are implemented
         return false
       end
+
+      ##
+      # Generate the solr document hash specific to a aggregation resource.
+      #
+      # @param [Array<LD4L::OreRDF::ProxyResource>] :all_proxies - pass in proxies instead of querying (optional)
+      #
+      # @returns [Hash] solr document
+      #
+      # NOTE: If all_proxies is [], then will try to query from triple store which means that if the proxies have not
+      #       yet been persisted, then they will not be found.
+      # NOTE: This method should not be called directory.  Use LD4L::OreRDF::Aggregation.generate_solr_documents instead.
+      def generate_solr_document( all_proxies=[] )
+        solr_doc = ActiveTriples::Solrizer::IndexingService.new(self).generate_solr_document do |solr_doc|
+          # TODO add owner_name and owner sort field
+          # solr_doc.merge!(:owner_name_ti => owner.name)   # TODO add name to FOAF Gem
+          # solr_doc.merge!(:owner_name_sort_ss => owner.name)
+
+          # add all item_proxies
+          all_proxies = get_items if all_proxies.empty?  # NOTE: get_items depends on aggregation_resource being persisted prior to this call
+          proxy_ids = all_proxies.collect { |item| item.id }
+          solr_doc.merge!(self.class.item_proxies_solr_name => proxy_ids)
+          solr_doc
+        end
+        solr_doc
+     end
+
+      def self.item_proxies_solr_name
+        :item_proxies_ssm
+      end
     end
   end
 end
-

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

@@ -8,11 +8,64 @@ module LD4L
       # configure :base_uri => LD4L::OreRDF.configuration.base_uri, repository => :default
       configure :type => RDFVocabularies::ORE.Proxy, :base_uri => LD4L::OreRDF.configuration.base_uri, :repository => :default
 
-      property :proxy_for,     :predicate => RDFVocabularies::ORE.proxyFor,  :cast => false
-      property :proxy_in,      :predicate => RDFVocabularies::ORE.proxyIn,   :class_name => LD4L::OreRDF::AggregationResource
-      property :next_proxy,    :predicate => RDFVocabularies::IANA.next,     :class_name => LD4L::OreRDF::ProxyResource
-      property :prev_proxy,    :predicate => RDFVocabularies::IANA.prev,     :class_name => LD4L::OreRDF::ProxyResource
-      property :contributor,   :predicate => RDF::DC.contributor,            :class_name => LD4L::FoafRDF::Person   # TODO User who added this item to the Aggregation (default=Aggregation's owner)
+      property :proxy_for_,   :predicate => RDFVocabularies::ORE.proxyFor,  :cast => false
+      property :proxy_in_,    :predicate => RDFVocabularies::ORE.proxyIn,   :class_name => LD4L::OreRDF::AggregationResource
+      property :next_proxy_,  :predicate => RDFVocabularies::IANA.next,     :class_name => LD4L::OreRDF::ProxyResource
+      property :prev_proxy_,  :predicate => RDFVocabularies::IANA.prev,     :class_name => LD4L::OreRDF::ProxyResource
+      property :contributor,  :predicate => RDF::DC.contributor,            :class_name => LD4L::FoafRDF::Person   # TODO User who added this item to the Aggregation (default=Aggregation's owner)
+
+
+      def proxy_for= value
+        value = [] if value.nil?
+        self.proxy_for_ = value
+      end
+
+      def proxy_for
+        OreRDF::Aggregation.get_first_value self, proxy_for_
+      end
+
+      def proxy_for_subject
+        OreRDF::Aggregation.get_first_value self, proxy_for_, true
+      end
+
+      def proxy_in= value
+        value = [] if value.nil?
+        self.proxy_in_ = value
+      end
+
+      def proxy_in
+        OreRDF::Aggregation.get_first_value self, proxy_in_
+      end
+
+      def proxy_in_subject
+        OreRDF::Aggregation.get_first_value self, proxy_in_, true
+      end
+
+      def next_proxy= value
+        self.next_proxy_ = value
+        value = [] if value.nil?
+      end
+
+      def next_proxy
+        OreRDF::Aggregation.get_first_value self, next_proxy_
+      end
+
+      def next_proxy_subject
+        OreRDF::Aggregation.get_first_value self, next_proxy_, true
+      end
+
+      def prev_proxy= value
+        value = [] if value.nil?
+        self.prev_proxy_ = value
+      end
+
+      def prev_proxy
+        OreRDF::Aggregation.get_first_value self, prev_proxy_
+      end
+
+      def prev_proxy_subject
+        OreRDF::Aggregation.get_first_value self, prev_proxy_, true
+      end
 
 
       # --------------------- #
@@ -28,15 +81,17 @@ module LD4L
       def self.get_range( aggregation, start=0, limit=nil )
         # TODO: Stubbed to return all items.  Need to implement start and limit features.
 
-        # argument validation
-        # raise ArgumentError, 'Argument must be a string with at least one character'  unless
-        #     tag_value.kind_of?(String) && tag_value.size > 0
+        raise ArgumentError, 'aggregation must be Aggregation or AggregationResource'  unless
+            aggregation.kind_of?(LD4L::OreRDF::Aggregation) || aggregation.kind_of?(LD4L::OreRDF::AggregationResource)
+
+        aggregation_resource = aggregation
+        aggregation_resource = aggregation.list_info if aggregation.kind_of?(LD4L::OreRDF::Aggregation)
 
         graph = ActiveTriples::Repositories.repositories[repository]
         query = RDF::Query.new({
                                  :proxy => {
                                    RDF.type =>  RDFVocabularies::ORE.Proxy,
-                                   RDFVocabularies::ORE.proxyIn => aggregation,
+                                   RDFVocabularies::ORE.proxyIn => aggregation_resource,
                                  }
                                })
 
@@ -44,8 +99,8 @@ module LD4L
         results = query.execute(graph)
         results.each do |r|
           proxy_uri = r.to_hash[:proxy]
-          if aggregation.list_info.respond_to? 'persistence_strategy'  # >= ActiveTriples 0.8
-            proxy = LD4L::OreRDF::ProxyResource.new(proxy_uri,aggregation.list_info)
+          if aggregation_resource.respond_to? 'persistence_strategy'  # >= ActiveTriples 0.8
+            proxy = LD4L::OreRDF::ProxyResource.new(proxy_uri,aggregation_resource)
           else # < ActiveTriples 0.8
             proxy = LD4L::OreRDF::ProxyResource.new(proxy_uri)
           end

data/lib/ld4l/ore_rdf/services/aggregation/add_aggregated_resource.rb

@@ -23,27 +23,19 @@ module LD4L
             resource.kind_of?(String) || resource.kind_of?(RDF::URI)
 
         # make sure resource is a String - HANGING ERROR will occur if set as RDF::URI
-        resource = resource.to_s         if      resource.kind_of?(RDF::URI)
+        resource = resource.to_s if resource.kind_of?(RDF::URI)
 
         # validate aggregation is of correct type
         raise ArgumentError, "aggregation is not LD4L::OreRDF::Aggregation" unless
             aggregation.kind_of?(LD4L::OreRDF::Aggregation)
 
-
-        # aggregates = get_values('aggregates')
-        # aggregates << resource_uri
-        # set_value('aggregates',aggregates)
-
-        aggregates = aggregation.aggregates.dup
-        aggregates << resource
-        aggregation.aggregates = aggregates
+        aggregation.aggregates << resource
 
         LD4L::OreRDF::CreateProxy.call(
             :resource        => resource,
             :aggregation     => aggregation,
             :insert_position => insert_position)
       end
-
     end
   end
 end

data/lib/ld4l/ore_rdf/services/aggregation/find.rb

@@ -19,8 +19,8 @@ module LD4L
       #   all_aggs = LD4L::OreRDF.FindAggregations
       def self.call( options={} )
         repository = options[:repository] || :default
-        raise ArgumentError, 'repository must be a symbol' unless repository.kind_of?(Symbol)
-        raise ArgumentError, 'repository must be a registered repository' unless
+        raise ArgumentError, "repository (#{repository}) is not a symbol" unless repository.kind_of?(Symbol)
+        raise ArgumentError, "repository (#{repository}) is not a registered repository" unless
             ActiveTriples::Repositories.repositories.has_key?(repository)
 
         resume = options[:resume] || false