qa-ldf 0.1.0

data/lib/qa/ldf/client.rb

@@ -0,0 +1,39 @@
+module Qa
+  module LDF
+    ##
+    # A client for the LD cache server
+    class Client
+      ##
+      # @yield [Client] yields self to a block if given
+      def initialize
+        yield self if block_given?
+      end
+
+      ##
+      # @param uri     [String] a URI-like string
+      # @param dataset [Symbol]
+      #
+      # @return [RDF::Graph]
+      #
+      # @see RDF::Mutable#load
+      # @see RDF::LinkedDataFragments::CacheServer
+      def get(uri:, dataset: :'')
+        RDF::Graph.load(cache_uri(uri, dataset))
+      end
+
+      private
+
+      ##
+      # @param uri     [String] a URI-like string
+      # @param dataset [Symbol]
+      #
+      # @return [RDF::URI]
+      def cache_uri(uri, dataset)
+        cache_uri = RDF::URI(Qa::LDF::Configuration.instance[:endpoint])
+        cache_uri.query = "subject=#{uri}"
+        cache_uri = cache_uri / 'dataset' / dataset unless dataset.empty?
+        cache_uri
+      end
+    end
+  end
+end

data/lib/qa/ldf/configuration.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+require 'singleton'
+
+module Qa
+  module LDF
+    ##
+    # A singleton configuration class.
+    #
+    # This behaves much like a hash, but guarantees that only one configuration
+    # exists and accepts a block sytax for configuration.
+    #
+    # @example configuring with a configuration hash
+    #   Qa::LDF::Configuration.instance
+    #     .configure!(endpoint: 'http://example.org/ldf/')
+    #
+    # @example configuring with block syntax
+    #   Qa::LDF::Configuration.instance.configure! do |config|
+    #     config[:endpoint] = 'http://example.org/ldf/'
+    #   end
+    #
+    # @see Qa::LDF.config
+    # @see Qa::LDF.configure!
+    class Configuration
+      extend Forwardable
+      include Singleton
+
+      ##
+      # @!macro [attach] def_delegator
+      #   @!method $3()
+      #     Delegates to the underlying options
+      def_delegator :@options, :'[]', :'[]'
+      def_delegator :@options, :'[]=', :'[]='
+      def_delegator :@options, :any?, :any?
+      def_delegator :@options, :each, :each
+      def_delegator :@options, :fetch, :fetch
+      def_delegator :@options, :to_a, :to_a
+      def_delegator :@options, :to_h, :to_h
+
+      ##
+      # @private
+      # @see Singleton
+      def initialize
+        @options = {}
+      end
+
+      ##
+      # @param opts [Hash]
+      #   @option endpoint [String]
+      #
+      # @yield yields self to block
+      # @yieldparam config [Configuration] self
+      def configure!(**opts)
+        @options = opts
+        yield self if block_given?
+        self
+      end
+
+      ##
+      # Empties all configuration options
+      #
+      # @return opts [Hash]
+      def reset!
+        @options = {}
+      end
+    end
+  end
+end

data/lib/qa/ldf/empty_search_service.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+module Qa
+  module LDF
+    ##
+    # A search service that always returns no results.
+    #
+    # @example
+    #   EmptySearchService.new.search('any query') # => {}
+    #
+    class EmptySearchService
+      ##
+      # @see Qa::Authority::Base#search
+      def search(_query)
+        []
+      end
+    end
+  end
+end

data/lib/qa/ldf/json_mapper.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module Qa
+  module LDF
+    ##
+    # A customizable mapper from {RDF::Graph}s to JSON-like hashes for use in
+    # Questioning Authority.
+    #
+    # @todo: Add configuration
+    #
+    # @example maps a graphs to QA JSON objects.
+    #   mapper = JsonMapper.new
+    #
+    #   uri   = 'http://id.loc.gov/authorities/subjects/sh2004002557'
+    #   graph = RDF::Graph.load(uri)
+    #
+    #   mapper.map_resource(uri, graph)
+    #   # => { id:    'http://id.loc.gov/authorities/subjects/sh2004002557',
+    #   #      label: 'Marble Island (Nunavut)' }
+    #
+    class JsonMapper
+      ##
+      # @param uri   [String] a URI-like string
+      # @param graph [RDF::Queryable]
+      #
+      # @return [Hash<Symbol, String>]
+      def map_resource(uri, graph)
+        labels =
+          graph.query(subject:   RDF::URI.intern(uri),
+                      predicate: RDF::Vocab::SKOS.prefLabel).objects
+
+        { id: uri, label: labels.first.to_s }
+      end
+    end
+  end
+end

data/lib/qa/ldf/model.rb

@@ -0,0 +1,49 @@
+require 'active_triples'
+
+module Qa
+  module LDF
+    ##
+    # A base model for validatable authority values.
+    class Model
+      include ActiveTriples::RDFSource
+
+      class << self
+        ##
+        # Builds a model from the graph.
+        #
+        # @param graph [RDF::Graph]
+        #
+        # @return [Qa::LDF::Model] the built model
+        def from_graph(uri:, graph:)
+          new(uri) << graph
+        end
+
+        ##
+        # Builds a model from a QA result hash.
+        #
+        # @example
+        #   model =
+        #     Qa::LDF::Model.from_qa_result(id:    'http://example.com/moomin',
+        #                                   label: 'Moomin'
+        #   model.to_uri    # => #<RDF::URI:0x... URI:http://example.com/moomin>
+        #   model.rdf_label # => ['Moomin']
+        #
+        #
+        # @param qa_result [Hash<Symbol, String>]
+        #
+        # @return [Qa::LDF::Model] the built model
+        #
+        # @todo Make ActiveTriples::RDFSource#default_labels public or
+        #   protected.
+        def from_qa_result(qa_result:)
+          qa_result.dup
+          model = new(qa_result.delete(:id))
+          model.set_value(model.send(:default_labels).first,
+                          qa_result.delete(:label))
+
+          model
+        end
+      end
+    end
+  end
+end

data/lib/qa/ldf/spec.rb

@@ -0,0 +1,3 @@
+require 'qa/ldf/spec/authority'
+require 'qa/ldf/spec/model'
+require 'qa/ldf/spec/search_service'

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

@@ -0,0 +1,112 @@
+shared_examples 'an ldf authority' do
+  before do
+    unless defined?(authority)
+      raise ArgumentError,
+            "#{authority} must be defined with `let(:authority)` before " \
+            'using LDF::Authority shared examples.'
+    end
+
+    unless defined?(ldf_uri)
+      raise ArgumentError,
+            "#{ldf_uri} must be defined with `let(:ldf_uri)` before using " \
+            'LDF::Authority shared examples.'
+    end
+    unless defined?(ldf_label)
+      raise ArgumentError,
+            "#{ldf_label} must be defined with `let(:ldf_label)` before " \
+            'using LDF::Authority shared examples.'
+    end
+  end
+
+  it 'is aliased to Qa::Authorities' do
+    unless described_class.eql?(Qa::LDF::Authority)
+      name = described_class.to_s.split('::').last.downcase.camelize
+      expect("Qa::Authorities::#{name}".constantize).to eql described_class
+    end
+  end
+
+  describe '#all' do
+    it 'is enumerable' do
+      expect(authority.all).to respond_to :each
+    end
+
+    it 'enumerates the vocabulary'
+  end
+
+  describe '#client' do
+    it 'defaults to an instance of DEFAULT_CLIENT' do
+      expect(described_class.new.client)
+        .to be_a described_class::DEFAULT_CLIENT
+    end
+
+    it 'sets to other instances' do
+      client = described_class::DEFAULT_CLIENT.new
+
+      expect { authority.client = client }
+        .to change { authority.client }
+        .to equal client
+    end
+  end
+
+  describe '#dataset' do
+    it 'defaults DEFAULT_DATASET_NAME' do
+      expect(described_class.new.dataset)
+        .to eq described_class::DEFAULT_DATASET_NAME
+    end
+
+    it 'sets to other symbols' do
+      dataset_name = :new_name
+
+      expect { authority.dataset = dataset_name }
+        .to change { authority.dataset }
+        .to eq dataset_name
+    end
+  end
+
+  describe '#find' do
+    it 'finds a uri' do
+      expect(authority.find(ldf_uri))
+        .to include id: ldf_uri.to_s, label: ldf_label
+    end
+
+    it 'maps to a json-friendly hash' do
+      expect { JSON.generate(authority.find(ldf_uri)) }.not_to raise_error
+    end
+  end
+
+  describe '#mapper' do
+    it 'defaults to an instance of DEFAULT_MAPPER' do
+      expect(described_class.new.mapper)
+        .to be_a described_class::DEFAULT_MAPPER
+    end
+
+    it 'sets to other instances' do
+      mapper = described_class::DEFAULT_MAPPER.new
+
+      expect { authority.mapper = mapper }
+        .to change { authority.mapper }
+        .to equal mapper
+    end
+  end
+
+  describe '#search' do
+    let(:query)    { 'My Fake Query' }
+    let(:response) { { my: 'response' } }
+
+    it 'gives an array' do
+      expect(authority.search('tove')).to respond_to :to_ary
+    end
+
+    it 'gives a json-friendly array' do
+      expect { JSON.generate(authority.search('tove')) }.not_to raise_error
+    end
+
+    it 'searches the search service' do
+      authority.search_service = FakeSearchService.new do |service|
+        service.queries[query] = response
+      end
+
+      expect(authority.search(query)).to eq response
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+shared_examples 'an ldf model' do
+  before do
+    unless defined?(model)
+      raise ArgumentError,
+            "#{model} must be defined with `let(:model)` before " \
+            'using Qa::LDF::Model shared examples.'
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+shared_examples 'an ldf search service' do
+  before do
+    unless defined?(search_service)
+      raise ArgumentError,
+            "#{search_service} must be defined with `let(:search_service)` " \
+            'before using LDF::Authority shared examples.'
+    end
+
+    unless defined?(searches)
+      warn 'You did not provide any valid searches to the ldf search service ' \
+           "shared examples for #{described_class}. Use `let(:searches) = " \
+           '{"query" => {key: "value"} to configure searches to test'
+    end
+  end
+
+  describe '#search' do
+    it 'gives a json-friendly array' do
+      JSON.generate(search_service.search('tove'))
+      expect { JSON.generate(search_service.search('tove')) }.not_to raise_error
+    end
+
+    it 'responds to searches' do
+      if defined?(searches)
+        searches.each do |query, response|
+          expect(search_service.search(query)).to eq response
+        end
+      end
+    end
+  end
+end

data/lib/qa/ldf/version.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+module Qa
+  module LDF
+    ##
+    # Gives the current version, parsed from `VERSION`.
+    #
+    # @example
+    #   "The current version is: #{Qa::LDF::VERSION}"
+    #
+    module VERSION
+      FILE = File.expand_path('../../../../VERSION', __FILE__)
+      MAJOR, MINOR, TINY = File.read(FILE).chomp.split('.')
+      STRING = [MAJOR, MINOR, TINY].compact.join('.').freeze
+
+      ##
+      # @return [String]
+      def self.to_s
+        STRING
+      end
+
+      ##
+      # @return [String]
+      def self.to_str
+        STRING
+      end
+
+      ##
+      # @return [Array(String, String, String, String)]
+      def self.to_a
+        [MAJOR, MINOR, TINY].compact
+      end
+    end
+  end
+end

data/qa-ldf.gemspec

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby -rubygems
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |spec|
+  spec.authors       = ['Tom Johnson']
+  spec.email         = ['tom@curationexperts.com']
+
+  spec.name          = 'qa-ldf'
+  spec.homepage      = 'http://github.com/curationexperts/qa-ldf'
+  spec.description   = 'Questioning Authority cached with a Linked Data ' \
+                       'Fragment.'
+  spec.summary       = 'Provides a bridge between questioning authority and ' \
+                       'a caching linked data fragment for URI authorities.'
+
+  spec.version       = File.read('VERSION').chomp
+  spec.date          = File.mtime('VERSION').strftime('%Y-%m-%d')
+  spec.license       = 'Apache-2.0'
+
+  spec.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = %w(lib)
+
+  spec.required_ruby_version = '>= 2.2.2'
+
+  spec.add_dependency 'qa', '~> 0.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'
+  spec.add_development_dependency 'rspec',             '~> 3.5'
+  spec.add_development_dependency 'rubocop-rspec',     '1.10.0'
+  spec.add_development_dependency 'sham_rack',         '~> 1.4'
+  spec.add_development_dependency 'webmock',           '~> 2.3', '>= 2.3.2'
+  spec.add_development_dependency 'yard',              '~> 0'
+end