qa-ldf 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a949f884516d5b051b47a5b14d23c67043a0d3d3
-  data.tar.gz: 50ca4ecf8a10304ac8a2afa38afd38264c537ebe
+  metadata.gz: 855a7a374246e7b3deb9e2a05f275a7e1ac4b39b
+  data.tar.gz: 6fceb2d6ec1511192f388a7da4edcd37b223088a
 SHA512:
-  metadata.gz: 5ef5befc68d69cf514995bdacaea034fdbb1c03b0c4effe9898f91cd57547ae26585414b40bc158171ae7bb3850ca06c42b5157dac15bd581b2ff106e5e59c22
-  data.tar.gz: 5a1d78db92bfc2de9d80b60292cb5dc0c1d3cc72bc210885529bcd56510ec6a455079e3a9d97df5538056d12cd6844a3d40245bba54bb4acabb10b05073a831e
+  metadata.gz: e3c38a54bd7ec95604666dc08113e18d8f240976b21f2d39dbb40445d954455860dbf79494dd4811083e754494864fd54cd78582f4707b53f7dfdbc23a8e976e
+  data.tar.gz: 951a494528c90e84f66df9747a810e3b9a0a92fb9a6643058e91de475885b3b42c8d12017295daaa918e7c3ebefc3c165776ef7ddd881370301749c49ac7392f

data/.rubocop.yml

@@ -8,6 +8,12 @@ Metric/BlockLength:
     - 'spec/**/*'
     - 'lib/qa/ldf/spec/**/*'
 
+# Class variables are fine. We want the "nasty" behavior described by rubocop 
+# in some cases.
+# https://github.com/bbatsov/ruby-style-guide/blob/master/README.md#no-class-vars
+Style/ClassVars:
+  Enabled: false
+
 # we accept `expect(subject).to receive`
 RSpec/MessageSpies:
   Enabled: false
@@ -19,3 +25,8 @@ RSpec/FilePath:
     - 'spec/support/**/*'
     - 'spec/qa/ldf/authorities/**/*'
     - 'spec/qa/ldf/models/**/*'
+
+# we allow non-Class describes for integration
+RSpec/DescribeClass:  
+  Exclude:
+    - 'spec/integration/**/*'

data/.travis.yml

@@ -1,5 +1,6 @@
 language: ruby
 sudo: false
+script: 'bundle exec rake ci environment=test'
 
 cache:
   bundler: true

data/Gemfile

@@ -10,9 +10,6 @@ end
 
 gem 'pry' unless ENV['CI']
 
-# develop on qa master
-gem 'qa', github: 'projecthydra-labs/questioning_authority', branch: 'master'
-
 gem 'ld_cache_fragment',
     github: 'ActiveTriples/linked-data-fragments',
     branch: 'feature/multi-dataset'

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.0

data/lib/qa/ldf/authorities/lc_names.rb

@@ -10,8 +10,18 @@ module Qa
     # @see LinkedDataFragments::CacheServer
     class LCNames < Authority
       DEFAULT_DATASET_NAME = :lcnames
+      NAMESPACE            = 'http://id.loc.gov/authorities/names/'.freeze
       LC_SUBAUTHORITY      = 'names'.freeze
 
+      register_namespace(namespace: NAMESPACE,
+                         klass:     self)
+
+      ##
+      # @return [String] the URI namespace associated with this authority
+      def self.namespace
+        NAMESPACE
+      end
+
       ##
       # Uses the LC names subauthority as the search provider
       def search_service

data/lib/qa/ldf/authority.rb

@@ -26,6 +26,52 @@ module Qa
       # The default search service
       DEFAULT_SEARCH_SERVICE = Qa::LDF::EmptySearchService
 
+      class << self
+        @@namespace_map = {}
+
+        ##
+        # Gives an authority class for the given namespace.
+        #
+        # @param namespace [#to_s] a URI-like namespace string
+        #
+        # @return [Authority]
+        def for(namespace:)
+          @@namespace_map.fetch(namespace.to_s) { self }.new
+        end
+
+        ##
+        # @return [String] gives an empty string for no namespace,
+        #   {#for_namespace} returns self in this case
+        def namespace
+          ''
+        end
+
+        ##
+        # @return [Enumerable<String>]
+        def namespaces
+          @@namespace_map.keys
+        end
+
+        ##
+        # Registers a namespace/class pair.
+        #
+        # @param namespace [#to_s] a URI-like namespace string
+        # @param klass     [Class] an authority class
+        #
+        # @return [void]
+        def register_namespace(namespace:, klass:)
+          @@namespace_map[namespace.to_s] = klass
+        end
+
+        ##
+        # Resets the namespaces
+        #
+        # @return [void]
+        def reset_namespaces
+          @@namespace_map = {}
+        end
+      end
+
       ##
       # @!attribute [rw] client
       #   @return [Client]
@@ -60,9 +106,14 @@ module Qa
       # @see Qa::Authorities::Base#find
       # @see Qa::LDF::Client#get
       def find(id)
-        graph = client.get(uri: id, dataset: dataset)
+        mapper.map_resource(id, graph(id))
+      end
 
-        mapper.map_resource(id, graph)
+      ##
+      # @param uri [RDF::URI]
+      # @return [RDF::Enumerable]
+      def graph(uri)
+        client.get(uri: uri, dataset: dataset)
       end
 
       ##

data/lib/qa/ldf/model.rb

@@ -7,6 +7,60 @@ module Qa
     class Model
       include ActiveTriples::RDFSource
 
+      ##
+      # @return [Qa::LDF::Authority]
+      #
+      # @example
+      #   # Regester the namespace with the authority class.
+      #   class MyAuthority < Authority
+      #     register_namespace(namespace: 'http://example.com/my_authority#',
+      #                        klass:     self)
+      #   end
+      #
+      #   model = Qa::LDF::Model.new('http://example.com/my_authority#moomin')
+      #
+      #   model.authority # => #<MyAuthority:0xbad1dea>
+      #
+      def authority
+        Qa::LDF::Authority.for(namespace: authority_namespace)
+      end
+
+      ##
+      # @return [String] the namespace for the authority used by this model
+      #   instance.
+      #
+      # @example
+      #   # Regester the namespace with the authority class.
+      #   class MyAuthority < Authority
+      #     register_namespace(namespace: 'http://example.com/my_authority#',
+      #                        klass:     self)
+      #   end
+      #
+      #   model = Qa::LDF::Model.new('http://example.com/my_authority#moomin')
+      #
+      #   model.authority_namespace # => 'http://example.com/my_authority#'
+      #
+      def authority_namespace
+        return Qa::LDF::Authority.namespace if node?
+
+        Qa::LDF::Authority
+          .namespaces
+          .find { |ns| to_uri.start_with?(ns) }
+      end
+
+      ##
+      # Fetches from the cache client.
+      #
+      # @see ActiveTriples::RDFSource#fetch
+      def fetch
+        insert(authority.graph(to_uri))
+      rescue => e
+        raise e unless block_given?
+        yield(self)
+      ensure
+        self
+      end
+
       class << self
         ##
         # Builds a model from the graph.

data/lib/qa/ldf/spec/authority.rb

@@ -25,6 +25,19 @@ shared_examples 'an ldf authority' do
     end
   end
 
+  it 'is registered' do
+    expect(Qa::LDF::Authority.for(namespace: described_class.namespace))
+      .to be_a described_class
+  end
+
+  describe '.namespace' do
+    it 'returns a namespace string' do
+      unless described_class.namespace == ''
+        expect(RDF::URI(described_class.namespace)).to be_valid
+      end
+    end
+  end
+
   describe '#all' do
     it 'is enumerable' do
       expect(authority.all).to respond_to :each
@@ -72,6 +85,15 @@ shared_examples 'an ldf authority' do
     it 'maps to a json-friendly hash' do
       expect { JSON.generate(authority.find(ldf_uri)) }.not_to raise_error
     end
+
+    context 'when dataset is not assigned' do
+      before { authority.dataset = nil }
+
+      it 'finds a uri' do
+        expect(authority.find(ldf_uri))
+          .to include id: ldf_uri.to_s, label: ldf_label
+      end
+    end
   end
 
   describe '#mapper' do

data/lib/qa/ldf/spec/model.rb

@@ -5,5 +5,111 @@ shared_examples 'an ldf model' do
             "#{model} must be defined with `let(:model)` before " \
             'using Qa::LDF::Model shared examples.'
     end
+
+    unless defined?(id)
+      raise ArgumentError,
+            "#{id} must be defined with `let(:id)` before " \
+            'using Qa::LDF::Model shared examples.'
+    end
+  end
+
+  let(:label)     { 'moomin' }
+
+  define :be_term do |expected|
+    match { |actual| expect(actual.to_term).to eq expected }
+  end
+
+  describe '.from_graph' do
+    let(:graph) do
+      graph = RDF::Graph.new
+      graph.insert(*statements)
+      graph
+    end
+
+    let(:statements) do
+      [RDF::Statement(RDF::URI(id),  RDF::Vocab::SKOS.prefLabel, label),
+       RDF::Statement(RDF::URI(id),  RDF::Vocab::DC.title, 'Moomin Papa'),
+       RDF::Statement(RDF::Node.new, RDF::Vocab::DC.title, 'Moomin Papa')]
+    end
+
+    it 'builds a model with the id as uri' do
+      expect(described_class.from_graph(uri: id, graph: graph))
+        .to be_term RDF::URI(id)
+    end
+
+    it 'builds a model with the label as label' do
+      expect(described_class.from_graph(uri: id, graph: graph))
+        .to have_attributes rdf_label: a_collection_containing_exactly(label)
+    end
+
+    it 'contains passed graph' do
+      expect(described_class.from_graph(uri: id, graph: graph).statements)
+        .to include(*statements)
+    end
+  end
+
+  describe '.from_qa_result' do
+    let(:json_hash) { { id: id, label: label, papa: 'moomin papa' } }
+
+    it 'builds a model with the id as uri' do
+      expect(described_class.from_qa_result(qa_result: json_hash))
+        .to be_term RDF::URI(id)
+    end
+
+    it 'builds a model with the label as label' do
+      expect(described_class.from_qa_result(qa_result: json_hash))
+        .to have_attributes rdf_label: a_collection_containing_exactly(label)
+    end
+  end
+
+  describe '#authority' do
+    it 'returns an authority' do
+      expect(model.authority).to respond_to(:find).with(1).argument
+    end
+
+    it 'returns the base authority for undefined namespace' do
+      expect(model.authority.dataset)
+        .to eq Qa::LDF::Authority::DEFAULT_DATASET_NAME
+    end
+
+    context 'with a namespaced uri' do
+      let(:ns)    { 'http://id.loc.gov/authorities/names/' }
+      let(:id)    { ns + 'n83175996' }
+      let(:klass) { Class.new(Qa::LDF::Authority) }
+
+      before do
+        Qa::LDF::Authority.register_namespace(namespace: ns, klass: klass)
+      end
+
+      after { Qa::LDF::Authority.reset_namespaces }
+
+      it 'knows its authority' do
+        expect(model.authority).to be_a klass
+      end
+    end
+  end
+
+  describe '#fetch' do
+    let(:ns)    { 'http://example.com/moomin_auth/' }
+    let(:id)    { ns + 'moomin' }
+
+    let(:klass) do
+      Class.new(Qa::LDF::Authority) do
+        register_namespace(namespace: 'http://example.com/moomin_auth',
+                           klass:     self)
+
+        def initialize
+          @client = FakeClient.new
+        end
+      end
+    end
+
+    before { klass }
+
+    it 'populates the graph from the client' do
+      expect { model.fetch }
+        .to change { model.statements }
+        .from(be_empty)
+    end
   end
 end

data/qa-ldf.gemspec

@@ -24,6 +24,7 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency 'qa', '~> 0.11.0'
 
+  spec.add_development_dependency 'active-fedora',     '~> 11.0'
   spec.add_development_dependency 'guard',             '~> 2.14'
   spec.add_development_dependency 'ld_cache_fragment', '~> 0.1'
   spec.add_development_dependency 'rake',              '~> 12.0'

data/spec/integration/active_fedora_model_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'active_fedora'
+
+# Tests the main boundaries to ActiveFedora. This should be considered
+# incomplete, at best. We haven't exhastively analyzed relevant AF behavior.
+describe 'ActiveFedora integration' do
+  subject(:af_model) { af_model_class.new }
+
+  let(:value_uri) { RDF::URI('http://id.loc.gov/authorities/names/n83175996') }
+  let(:af_model_class) do
+    Class.new(ActiveFedora::Base) do
+      property :programmer,
+               predicate:  RDF::Vocab::MARCRelators.prg,
+               class_name: Qa::LDF::Model
+    end
+  end
+
+  before { af_model.programmer = [value_uri] }
+
+  define :be_term do |expected|
+    match { |actual| expect(actual.to_term).to eq expected }
+  end
+
+  it 'builds value as a model' do
+    expect(af_model.programmer)
+      .to contain_exactly(an_instance_of(Qa::LDF::Model))
+  end
+
+  it 'builds value with correct rdf term' do
+    af_model.programmer = [value_uri]
+    expect(af_model.programmer).to contain_exactly(be_term(value_uri))
+  end
+
+  describe 'retrieving from the server' do
+    include_context 'with cache server'
+
+    let(:statement) do
+      RDF::Statement(value_uri, RDF::URI('http://example.com/p'), :o)
+    end
+
+    let(:stub) do
+      stub_request(:get, value_uri.to_s)
+        .to_return(body:    statement.to_ntriples,
+                   headers: { 'Content-Type' => 'text/turtle' })
+    end
+
+    # touch the stub
+    before { stub }
+
+    it 'value can retrieve its graph from the cache' do
+      af_model.programmer = [value_uri]
+
+      af_model.programmer.first.fetch
+      expect(stub).to have_been_requested
+    end
+  end
+end

data/spec/qa/ldf/authority_spec.rb

@@ -14,6 +14,16 @@ describe Qa::LDF::Authority do
     auth
   end
 
+  shared_context 'with registered namespaces' do
+    let(:ns)       { 'http://example.com/auth/' }
+    let(:subclass) { Class.new(described_class) }
+
+    before do
+      subclass.register_namespace(namespace: ns, klass: subclass)
+    end
+    after { subclass.reset_namespaces }
+  end
+
   let(:ldf_label)    { 'Marble Island (Nunavut)' }
   let(:ldf_uri)      { 'http://id.loc.gov/authorities/subjects/sh2004002557' }
 
@@ -21,6 +31,57 @@ describe Qa::LDF::Authority do
     [RDF::URI(ldf_uri), RDF::Vocab::SKOS.prefLabel, RDF::Literal(ldf_label)]
   end
 
+  describe '.for' do
+    let(:ns)       { 'http://example.com/auth/' }
+    let(:subclass) { Class.new(described_class) }
+
+    before { subclass.register_namespace(namespace: ns, klass: subclass) }
+    after  { subclass.reset_namespaces }
+
+    it 'returns registered classes from namespaces' do
+      expect(described_class.for(namespace: ns)).to be_a subclass
+    end
+  end
+
+  describe '.namespaces' do
+    it 'returns empty namespaces list' do
+      expect(described_class.namespaces).to be_empty
+    end
+
+    context 'when namespaces are registered' do
+      include_context 'with registered namespaces'
+
+      it 'returns populated namespaces list' do
+        expect(described_class.namespaces).to contain_exactly ns
+      end
+    end
+  end
+
+  describe '.register_namespace' do
+    let(:ns)       { 'http://example.com/auth/' }
+    let(:subclass) { Class.new(described_class) }
+
+    after { subclass.reset_namespaces }
+
+    it 'adds to namespace registry' do
+      expect { subclass.register_namespace(namespace: ns, klass: subclass) }
+        .to change { described_class.for(namespace: ns) }
+        .from(described_class)
+        .to(subclass)
+    end
+  end
+
+  describe '.reset_namespaces' do
+    include_context 'with registered namespaces'
+
+    it 'clears the namespace list' do
+      expect { subclass.reset_namespaces }
+        .to change { described_class.for(namespace: ns) }
+        .from(subclass)
+        .to(described_class)
+    end
+  end
+
   describe '#dataset' do
     it 'defaults an empty string symbol' do
       expect(described_class.new.dataset).to eq :''

data/spec/qa/ldf/model_spec.rb

@@ -1,53 +1,8 @@
 require 'spec_helper'
 
 describe Qa::LDF::Model do
-  define :be_term do |expected|
-    match { |actual| expect(actual.to_term).to eq expected }
-  end
+  subject(:model) { described_class.new(id) }
+  let(:id)        { 'http://example.com/authority/moomin' }
 
-  let(:id)    { 'http://example.com/authority/moomin' }
-  let(:label) { 'moomin' }
-
-  describe '.from_graph' do
-    let(:graph) do
-      graph = RDF::Graph.new
-      graph.insert(*statements)
-      graph
-    end
-
-    let(:statements) do
-      [RDF::Statement(RDF::URI(id),  RDF::Vocab::SKOS.prefLabel, label),
-       RDF::Statement(RDF::URI(id),  RDF::Vocab::DC.title, 'Moomin Papa'),
-       RDF::Statement(RDF::Node.new, RDF::Vocab::DC.title, 'Moomin Papa')]
-    end
-
-    it 'builds a model with the id as uri' do
-      expect(described_class.from_graph(uri: id, graph: graph))
-        .to be_term RDF::URI(id)
-    end
-
-    it 'builds a model with the label as label' do
-      expect(described_class.from_graph(uri: id, graph: graph))
-        .to have_attributes rdf_label: a_collection_containing_exactly(label)
-    end
-
-    it 'contains passed graph' do
-      expect(described_class.from_graph(uri: id, graph: graph).statements)
-        .to include(*statements)
-    end
-  end
-
-  describe '.from_qa_result' do
-    let(:json_hash) { { id: id, label: label, papa: 'moomin papa' } }
-
-    it 'builds a model with the id as uri' do
-      expect(described_class.from_qa_result(qa_result: json_hash))
-        .to be_term RDF::URI(id)
-    end
-
-    it 'builds a model with the label as label' do
-      expect(described_class.from_qa_result(qa_result: json_hash))
-        .to have_attributes rdf_label: a_collection_containing_exactly(label)
-    end
-  end
+  it_behaves_like 'an ldf model'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qa-ldf
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Tom Johnson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-02-23 00:00:00.000000000 Z
+date: 2017-03-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: qa
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.11.0
+- !ruby/object:Gem::Dependency
+  name: active-fedora
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
@@ -177,6 +191,7 @@ files:
 - lib/qa/ldf/version.rb
 - qa-ldf.gemspec
 - spec/contracts/qa_loc_as_search_service_spec.rb
+- spec/integration/active_fedora_model_spec.rb
 - spec/qa/ldf/authorities/lc_names_spec.rb
 - spec/qa/ldf/authority_spec.rb
 - spec/qa/ldf/client_spec.rb
@@ -217,6 +232,7 @@ summary: Provides a bridge between questioning authority and a caching linked da
   fragment for URI authorities.
 test_files:
 - spec/contracts/qa_loc_as_search_service_spec.rb
+- spec/integration/active_fedora_model_spec.rb
 - spec/qa/ldf/authorities/lc_names_spec.rb
 - spec/qa/ldf/authority_spec.rb
 - spec/qa/ldf/client_spec.rb