linked_vocabs 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8afd0f6c1a9ef5c1b998260ea65516f997d8450e
+  data.tar.gz: 16715bdd289fed07c8a13b0ad1c0efeef41167d0
+SHA512:
+  metadata.gz: 7be672326fb2ee98c5d39407f26d461b008c798e8ba6a6f5aa8318cc3132341f7fb7b4002f476c1113158587ede9a283ef1fb1909fa974c0e3f91ec3b376debc
+  data.tar.gz: 8c26071cf7e3bfbe01bcfd5168c4d6706d32a18c4e3ead87e882f1c69bc631676c210c3d47b13d573a07c7061c9be6e4f627d8d2f169b931f5199d894c1e9979

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'pry'
+# Specify your gem's dependencies in hybag.gemspec
+gemspec
+

data/LICENSE.txt

@@ -0,0 +1,191 @@
+Apache License
+Version 2.0, January 2004
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+"License" shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+"Licensor" shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+"Legal Entity" shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, "control" means (i) the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the
+outstanding shares, or (iii) beneficial ownership of such entity.
+
+"You" (or "Your") shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+"Source" form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+"Object" form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+"Work" shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+"Derivative Works" shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+"Contribution" shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+"submitted" means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as "Not a Contribution."
+
+"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+2. Grant of Copyright License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+3. Grant of Patent License.
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+4. Redistribution.
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+You must give any other recipients of the Work or Derivative Works a copy of
+this License; and
+You must cause any modified files to carry prominent notices stating that You
+changed the files; and
+You must retain, in the Source form of any Derivative Works that You distribute,
+all copyright, patent, trademark, and attribution notices from the Source form
+of the Work, excluding those notices that do not pertain to any part of the
+Derivative Works; and
+If the Work includes a "NOTICE" text file as part of its distribution, then any
+Derivative Works that You distribute must include a readable copy of the
+attribution notices contained within such NOTICE file, excluding those notices
+that do not pertain to any part of the Derivative Works, in at least one of the
+following places: within a NOTICE text file distributed as part of the
+Derivative Works; within the Source form or documentation, if provided along
+with the Derivative Works; or, within a display generated by the Derivative
+Works, if and wherever such third-party notices normally appear. The contents of
+the NOTICE file are for informational purposes only and do not modify the
+License. You may add Your own attribution notices within Derivative Works that
+You distribute, alongside or as an addendum to the NOTICE text from the Work,
+provided that such additional attribution notices cannot be construed as
+modifying the License.
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+5. Submission of Contributions.
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+6. Trademarks.
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty.
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+8. Limitation of Liability.
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability.
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets "[]" replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same "printed page" as the copyright notice for easier identification within
+third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   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,27 @@
+# Linked Vocabularies
+
+Linked Data Controlled Vocabularies for ActiveFedora::Rdf
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'linked_vocabs'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install linked_vocabs
+
+## Usage
+
+## Contributing
+
+1. Fork it
+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 new Pull Request

data/Rakefile

@@ -0,0 +1,17 @@
+#!/usr/bin/env rake
+
+require 'linked_vocabs'
+
+desc "Generate Vocabularies"
+
+task :gen_vocabs do
+  LinkedVocabs.vocabularies.each_key do |name|
+    puts "Generating vocabulary at lib/rdf/#{name}.rb"
+    begin
+      LinkedVocabs.load_vocabulary(name)
+    rescue
+      puts "Failed to load #{name}: #{$!.message}"
+      puts $!.backtrace
+    end
+  end
+end

data/lib/linked_vocabs.rb

@@ -0,0 +1,75 @@
+require 'active_triples'
+require 'active_model'
+require 'rdf/cli/vocab-loader'
+
+Dir['./lib/rdf/*.rb'].each { |f| require f }
+
+require 'linked_vocabs/version'
+require 'linked_vocabs/validators'
+require 'linked_vocabs/controlled'
+
+module LinkedVocabs
+  
+  def vocabularies
+    @vocabularies ||= {
+      :dcmitype       => { :prefix => 'http://purl.org/dc/dcmitype/', :source => 'http://dublincore.org/2012/06/14/dctype.rdf' },
+      :geonames       =>  { :prefix => 'http://sws.geonames.org/', :strict => false, :fetch => false },
+      :lcsh           =>  { :prefix => 'http://id.loc.gov/authorities/subjects/', :strict => false, :fetch => false }
+    }
+  end
+  module_function :vocabularies
+
+  def add_vocabulary(name, prefix, args = {})
+    name = name.to_sym
+    source = args.delete :source
+    strict = args.delete :strict
+    fetch = args.delete :fetch
+    raise "Unexpected arguments #{args.keys}. Accepted parameters are :source, :strict, and :fetch." unless args.empty?
+    vocabularies[name] = { 
+      :prefix => prefix.to_s,
+      :strict => strict,
+      :fetch => fetch
+    }
+    vocabularies[name][:source] = source if source
+    vocabularies[name][:strict] = false if vocabularies[name][:strict].nil? or !source
+    vocabularies[name][:fetch] = false if vocabularies[name][:fetch].nil? or !source
+  end
+  module_function :add_vocabulary
+
+  # Based closely on https://github.com/ruby-rdf/rdf/blob/develop/Rakefile 
+  def load_vocabulary(name, path = 'lib/rdf/')
+    raise "Unregistered vocabulary #{name}" unless vocabularies.has_key? name
+    v = vocabularies[name]
+    out = StringIO.new
+    class_name = name.to_s.upcase
+    if v.fetch(:fetch, true)
+      loader = RDF::VocabularyLoader.new(class_name)
+      loader.uri = v[:prefix]
+      loader.source = v[:source] if v[:source]
+      loader.extra = v[:extra] if v[:extra]
+      loader.strict = v.fetch(:strict, true)
+      loader.output = out
+      loader.run
+    else
+      out.print %(# -*- encoding: utf-8 -*-
+        # This file generated automatically using vocab-fetch from #{v.fetch(:source, v[:prefix])}
+        require 'rdf'
+        module RDF
+          class #{class_name} < RDF::#{"Strict" if v.fetch(:strict, true)}Vocabulary("#{v[:prefix]}")
+            # terms not fetched by vocab-fetch
+          end
+        end
+        ).gsub(/^        /, '')
+    end
+    out.rewind
+    File.open(File.join(path, "#{name}.rb"), "w") {|f| f.write out.read}
+  end
+  module_function :load_vocabulary
+  
+  def load_all
+    vocabularies.each_key do |name|
+      load_vocabulary(name)
+    end
+  end
+  module_function :load_all
+end

data/lib/linked_vocabs/controlled.rb

@@ -0,0 +1,199 @@
+require 'linkeddata'
+require 'active_model'
+require 'active_support/core_ext/module/delegation'
+
+module LinkedVocabs
+  ##
+  # Adds add support for controlled vocabularies and
+  # QuestioningAuthority to RdfResource classes.
+  # @TODO: introduce graph context for provenance
+  module Controlled
+    
+    def self.included(klass)
+      klass.extend ClassMethods
+      klass.property :hiddenLabel, :predicate => RDF::SKOS.hiddenLabel
+      klass.validates_with LinkedVocabs::Validators::AuthorityValidator
+    end
+
+    def qa_interface
+      self.class.qa_interface
+    end
+    delegate :search, :get_full_record, :response, :results, :to => :qa_interface
+
+    
+    # Override set_subject! to find terms when (and only when) they
+    # exist in the vocabulary
+    def set_subject!(uri_or_str)
+      vocab_matches = []
+      begin
+        uri = get_uri(uri_or_str)
+        uri_or_str = uri
+      rescue RuntimeError, NoMethodError
+      end
+
+      self.class.vocabularies.each do |vocab, config|
+        if uri_or_str.start_with? config[:prefix]
+          # @TODO: is it good to need a full URI for a non-strict vocab?
+          return super if config[:strict] == false
+          uri_stub = uri_or_str.to_s.gsub(config[:prefix], '')
+          return super(config[:class].send(uri_stub)) if config[:class].respond_to? uri_stub
+        else
+          # this only matches if the term is explictly defined
+          # @TODO: what about the possibility of terms like "entries" or
+          # "map" which are methods but not defined properties?  does
+          # this need to be patched in RDF::Vocabulary or am I missing
+          # something?
+          vocab_matches << config[:class].send(uri_or_str) if config[:class].respond_to? uri_or_str
+        end
+      end
+      return super if vocab_matches.empty?
+      uri_or_str = vocab_matches.first
+      return super if self.class.uses_vocab_prefix?(uri_or_str) and not uri_or_str.kind_of? RDF::Node
+    end
+    
+    def in_vocab?
+      return false unless self.class.uses_vocab_prefix?(rdf_subject.to_s)
+      self.class.vocabularies.each do |vocab, config|
+        return false if rdf_subject == config[:prefix]
+        return false if config[:class].strict? and not config[:class].respond_to? rdf_subject.to_s.gsub(config[:prefix], '').to_sym
+      end
+      true
+    end
+
+    def rdf_label
+      labels = Array(self.class.rdf_label)
+      labels += default_labels
+      labels.each do |label|
+        values = get_values(label) if values.blank?
+        return values unless values.empty?
+      end
+      node? ? [] : [rdf_subject.to_s]
+    end
+
+    ##
+    #  Class methods for adding and using controlled vocabularies
+    module ClassMethods
+      def use_vocabulary(name, opts={})
+        raise ControlledVocabularyError, "Vocabulary undefined: #{name.to_s.upcase}" unless LinkedVocabs.vocabularies.include? name
+        opts[:class] = name_to_class(name) unless opts.include? :class
+        opts.merge! LinkedVocabs.vocabularies[name.to_sym]
+        vocabularies[name] = opts
+      end
+
+      def vocabularies
+        @vocabularies ||= {}.with_indifferent_access
+      end
+
+      ##
+      # @return [Array<RDF::URI>] terms allowable by the registered StrictVocabularies
+      #
+      # Note: this does not necessarily list *all the term* allowable
+      # by the class. Non-strict RDF::Vocabularies are not included in
+      # this method's output.
+      def list_terms
+        terms = []
+        vocabularies.each do |vocab, config|
+          next unless config[:class].respond_to? :properties
+          terms += config[:class].properties.select { |s| s.start_with? config[:class].to_s }
+        end
+        terms
+      end
+
+      ##
+      # Gets data for all vocabularies used and loads it into the
+      # configured repository. After running this new (and reloaded)
+      # RdfResource objects of this class will have data from their
+      # source web document.
+      def load_vocabularies
+        vocabularies.each do |name, config|
+          load_vocab(name)
+        end
+      end
+
+      def uses_vocab_prefix?(str)
+        vocabularies.each do |vocab, config|
+          return true if str.start_with? config[:prefix]
+        end
+        false
+      end
+
+      def qa_interface
+        @qa_interface ||= QaRDF.new(self)
+      end
+
+      private
+
+      def name_to_class(name)
+        "RDF::#{name.upcase.to_s}".constantize
+      end
+
+      def load_vocab(name)
+        return nil unless LinkedVocabs.vocabularies[name.to_sym].include? :source
+        cache = ActiveTriples::Repositories.repositories[repository]
+        graph = RDF::Graph.new(:data => cache, :context => LinkedVocabs.vocabularies[name.to_sym][:source])
+        graph.load(LinkedVocabs.vocabularies[name.to_sym][:source])
+        graph
+      end
+
+      ##
+      # Implement QuestioningAuthority API
+      class QaRDF
+        attr_accessor :response, :raw_response
+
+        def initialize(parent=nil)
+          @parent = parent
+        end
+
+        ##
+        # Not a very smart sparql search. It's mostly intended to be
+        # overridden in subclasses, but it could also stand to be a bit
+        # better as a baseline RDF vocab search.
+        def search(q, sub_authority=nil)
+          @sparql = SPARQL::Client.new(ActiveTriples::Repositories.repositories[@parent.repository])
+          self.response = sparql_starts_search(q)
+          return response unless response.empty?
+          self.response = sparql_contains_search(q)
+        end
+
+        def results
+          response
+        end
+
+        def get_full_record(id, sub_authority)
+        end
+        
+        private
+
+          def sparql_starts_search(q)
+            query = @sparql.query("SELECT DISTINCT ?s ?p ?o WHERE { ?s ?p ?o. FILTER(strstarts(lcase(?o), '#{q.downcase}'))}")
+            solutions_from_sparql_query(query)
+          end
+
+          def sparql_contains_search(q)
+            query = @sparql.query("SELECT DISTINCT ?s ?p ?o WHERE { ?s ?p ?o. FILTER(contains(lcase(?o), '#{q.downcase}'))}")
+            solutions_from_sparql_query(query)
+          end
+          
+          def solutions_from_sparql_query(query)
+            # @TODO: labels should be taken from ActiveTriples::Resource.
+            # However, the default labels there are hidden behind a private method. 
+            labels = [RDF::SKOS.prefLabel,
+                      RDF::DC.title,
+                      RDF::RDFS.label]
+            labels << @parent.rdf_label unless @parent.rdf_label.nil?
+
+            solutions = query.map { |solution| solution if @parent.uses_vocab_prefix? solution[:s] }.compact
+            label_solutions = solutions.map { |solution| build_hit(solution) if labels.include? solution[:p] }.compact
+            return label_solutions.uniq unless label_solutions.empty?
+            solutions.map { |solution| build_hit(solution) }.compact.uniq
+          end
+           
+          def build_hit(solution)
+            { :id => solution[:s].to_s, :label => solution[:o].to_s }
+          end
+      end
+    end
+
+    class ControlledVocabularyError < StandardError; end
+  end
+end