qa 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5476914ef50c24ee9e61ae4de9b22256afb74f14
-  data.tar.gz: 14ccb1b89224b5f8b7c92c795ace430059d8f869
+  metadata.gz: 0e22891ac5c80978a68ef9606122e197fb348c47
+  data.tar.gz: dc3f442fa9a2f974100fea8e6ca7f42ae3f0c953
 SHA512:
-  metadata.gz: fedee18c0bfe503d1cc4d9f2d67515a012d28e826bcd0aa64e01e0802649923c1c92529104d52ba8fd2c2ac9b4504a76bf23f72b0670e345ef6dce3a2af231da
-  data.tar.gz: 112f321514ff9bb46fc832f0b3cdb8a60dcc0283f68afc530b0ddafaf156e7501e7d52d7139aa07f1435c3c7fb330d6ac16f0773511c761f6e2f7dbff4c984fd
+  metadata.gz: 972243b9cd33d2267e14cb341765f87e7c0ac83cc3f8252f1b9f18e6a4e0078452e85ee9d58d62b0d31173ae317a054fd7499fdda883b6e5116a51095c5b9d85
+  data.tar.gz: ad6c420a0e4507ff26b191f1c3b455f5eb900d06ca60638f84abf6ecc4f66c681feae69fe210e24c46f7357262554bc899740abd8bcf1de3d92f4efc66c98502

data/README.md

@@ -162,25 +162,34 @@ using the file's name as the sub-authority.  For example, if I create `foo.yml`,
 		  :term: Term 2
 		  :active: false
 
-# Experimental Features
-
-## Medical Subject Headings (MeSH)
+### Medical Subject Headings (MeSH)
 
 Provides autocompletion of [MeSH terms](http://www.nlm.nih.gov/mesh/introduction.html). This
 implementation is simple, and only provides *descriptors* and does not implement *qualifiers* (in
 the technical MeSH sense of these terms). The terms are stored in a local database, which is then
 queried to provide the suggestions.
 
-### Loading Terms
+To use, run the included rake task to copy over the relevant database migrations into your application:
+
+    rake qa:install:migrations
+
+Then, create the tables in your database
+
+    rake db:migrate
+
+Now that you've setup your application to use MeSH terms, you'll now need to load the tems into your
+database so you can query them locally.
 
 To import the mesh terms into the local database, first download the MeSH descriptor dump in ASCII
-format  (see [http://www.nlm.nih.gov/mesh/filelist.html][]). Once you have this file, the rake task
-`mesh:import` will load the entire file of terms into the database. It does not do an update (yet!).
+format. You can read about doing this [here](http://www.nlm.nih.gov/mesh/filelist.html). Once you have this file, use the
+following rake task to load the terms into your database:
 
     MESH_FILE=path/to/mesh.txt rake mesh:import
 
 This may take a few minutes to finish.
 
+**Note:** Updating the tables with new terms is currently not supported.
+
 # Developer Notes
 
 [How to Contribute](./CONTRIBUTING.md)
@@ -188,12 +197,17 @@ This may take a few minutes to finish.
 To develop this gem, clone the repository, then run:
 
     bundle install
-    rake
+    rake ci
+
+This will install the gems, create a dummy application under spec/internal and run the tests.  After you've made changes, 
+make sure you've included tests and run the test suite with a new sample application:
+
+    rake engine_cart:clean
+    rake ci
 
-This will install the gems, create a dummy application under spec/internal and run the tests.  After you've made changes, remove the entire spec/internal
-directory so that further tests and run against a new dummy application.
+Commit your features into a new branch and submit a pull request.
 
-## Compatability
+## Compatibility
 
 Currently, it is compatible with Rails 4.0 and 4.1 under both Ruby 2.0 and 2.1.
 
@@ -201,17 +215,6 @@ Currently, it is compatible with Rails 4.0 and 4.1 under both Ruby 2.0 and 2.1.
 
 For help with Questioning Authority, contact <hydra-tech@googlegroups.com>.
 
-# Original Authors
-
-* [Stephen Anderson](https://github.com/scande3)
-* [Don Brower](https://github.com/dbrower)
-* [Jim Coble](https://github.com/coblej)
-* [Mike Durbin](https://github.com/mikedurbin)
-* [Randall Floyd](https://github.com/stormfin)
-* [Eric James](https://github.com/yulgit1)
-* [Mike Stroming](https://github.com/mstroming)
-* [Adam Wead](https://github.com/awead)
-
 ### Special thanks to...
 
 [Jeremy Friesen](https://github.com/jeremyf) who gave us the name for our gem.

data/Rakefile

@@ -1,7 +1,7 @@
 #!/usr/bin/env rake
 require 'bundler/gem_tasks'
-require 'rspec/core/rake_task'
 require 'engine_cart/rake_task'
+require 'rspec/core/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
 

data/app/controllers/qa/terms_controller.rb

@@ -4,74 +4,38 @@
 
 class Qa::TermsController < ApplicationController
 
-  before_action :check_search_params, only:[:search]
-  before_action :check_vocab_param, :check_authority, :check_sub_authority
+  before_action :check_vocab_param, :init_authority
+  before_action :check_query_param, only: :search
 
-  #search that returns all results
+  # If the subauthority supports it, return a list of all terms in the authority
   def index
-    #initialize the authority and run the search. if there's a sub-authority and it's valid, include that param
-    @authority = authority_class.constantize.new
-    @authority.search(params[:q], params[:sub_authority])
-
-    respond_to do |format|
-      format.html { render :layout => false, json: @authority.results }
-      format.json { render :layout => false, json: @authority.results }
-      format.js   { render :layout => false, :text => @authority.results }
-    end
+    render json: @authority.all
   end
 
+  # Return a list of terms based on a query
   def search
-    #convert wildcard to be URI encoded
-    params[:q].gsub!("*", "%2A")
-
-    #initialize the authority and run the search. if there's a sub-authority and it's valid, include that param
-    @authority = authority_class.constantize.new
-    @authority.search(params[:q], params[:sub_authority])
-
-    respond_to do |format|
-      format.html { render :layout => false, :text => @authority.results.to_json }
-      format.json { render :layout => false, :text => @authority.results.to_json }
-      format.js   { render :layout => false, :text => @authority.results }
-    end
-
+    terms = @authority.search(url_search)
+    render json: terms
   end
 
+  # If the subauthority supports it, return all the information for a given term
   def show
-    check_sub_authority
-    authority = authority_class.constantize.new
-    result = authority.full_record(params[:id], params[:sub_authority])
-
-    respond_to do |format|
-      format.html { render :layout => false, :text => result.to_json }
-      format.json { render :layout => false, :text => result.to_json }
-      format.js   { render :layout => false, :text => result }
-    end
+    term = @authority.find(params[:id])
+    render json: term
   end
 
   def check_vocab_param
-    unless params[:vocab].present?
-      head :bad_request
-    end
+    head :not_found unless params[:vocab].present?
   end
 
-  def check_search_params
-    unless params[:q].present? && params[:vocab].present?
-      head :bad_request
-    end
+  def init_authority
+    @authority = authority_class.constantize.new(params[:sub_authority])
+  rescue
+    head :not_found
   end
 
-  def check_authority
-    begin
-      authority_class.constantize
-    rescue
-      head :bad_request
-    end
-  end
-
-  def check_sub_authority
-    unless params[:sub_authority].nil?
-      head :bad_request unless authority_class.constantize.authority_valid?(params[:sub_authority])
-    end
+  def check_query_param
+    head :not_found unless params[:q].present?
   end
 
   private
@@ -80,4 +44,9 @@ class Qa::TermsController < ApplicationController
     "Qa::Authorities::"+params[:vocab].capitalize
   end
 
+  # converts wildcards into URL-encoded characters
+  def url_search
+    params[:q].gsub("*", "%2A")
+  end
+
 end

data/config/routes.rb

@@ -1,9 +1,6 @@
 Qa::Engine.routes.draw do
-  match "/search/:vocab" => "terms#search", :via=>:get
-  match "/search/:vocab/:sub_authority" => "terms#search", :via=>:get
-  match "/terms/:vocab" => "terms#index", :via=>:get
-  match "/terms/:vocab/:sub_authority" => "terms#index", :via=>:get
-  match "/terms" => "terms#index", :via=>:get
-  match "/show/:vocab/:id" => "terms#show", :via=>:get
-  match "/show/:vocab/:sub_authority/:id" => "terms#show", :via=>:get
+  get "/terms/:vocab(/:sub_authority)",  controller: :terms, action: :index
+  get "/search/:vocab(/:sub_authority)", controller: :terms, action: :search
+  get "/show/:vocab/:id",                controller: :terms, action: :show
+  get "/show/:vocab/:sub_authority/:id", controller: :terms, action: :show
 end

data/lib/qa/authorities.rb

@@ -2,9 +2,11 @@ module Qa::Authorities
   extend ActiveSupport::Autoload
 
   autoload :Base
+  autoload :Getty
   autoload :Loc
+  autoload :LocSubauthority
   autoload :Local
-  autoload :Subauthority, 'qa/authorities/local/subauthority'
+  autoload :LocalSubauthority
   autoload :Mesh
   autoload :MeshTools
   autoload :Oclcts

data/lib/qa/authorities/base.rb

@@ -2,21 +2,40 @@ require 'deprecation'
 
 module Qa::Authorities
   class Base
+    extend Deprecation
 
-    # do an autocomplete search
-    def search(query, sub_authority=nil)
+    attr_accessor :sub_authority
+
+    # Registers the authority and its sub-authority if it has one
+    def initialize *args
+      if args.first
+        raise "Invalid sub-authority" unless sub_authorities.include?(args.first)
+      end
+    end
+
+    # By default, an authority has no subauthorities unless they
+    # are defined by the subclassed authority.
+    def sub_authorities
+      []
     end
 
-    # return information on a specific record
-    def get_full_record(id, sub_authority=nil)
+    # By default, #all is not implemented.
+    # If the subclassed authority does have this feature
+    # then you will overide the #all method in the subclassed authority.
+    # TODO: need to set some kind of error here
+    def all
     end
 
-    def self.authority_valid?(sub_authority)
-      sub_authority == nil || sub_authorities.include?(sub_authority)
+    # By default, #find is not implemented.
+    # If the subclassed authority does have this feature
+    # then you will overide the #find method in the subclassed authority.
+    # TODO: need to set some kind of error here
+    def find id
     end
 
-    def self.sub_authorities
-      [] #Overwrite if you have sub_authorities
+    def full_record id, sub_authority=nil
+      Deprecation.warn(".full_record is deprecated. Use .find instead")
+      find(id)
     end
 
   end

data/lib/qa/authorities/getty.rb

@@ -0,0 +1,56 @@
+require 'uri'
+
+module Qa::Authorities
+  class Getty < WebServiceBase
+
+    def initialize *args
+      super
+      @sub_authority ||= args.first
+      raise "No sub-authority provided" if sub_authority.nil?
+    end
+
+    def sub_authorities
+      [ "aat" ]
+    end
+
+    def search q
+      parse_authority_response(json(build_query_url(q)))
+    end
+
+    # get_json is not ideomatic, so we'll make an alias
+    def json(*args)
+      get_json(*args)
+    end
+
+    def build_query_url q
+      untainted = q.gsub(/[\w\s-]/, '')
+      sparql = "PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
+                SELECT * WHERE { ?s skos:prefLabel ?name .
+                  ?s skos:inScheme <http://vocab.getty.edu/#{@sub_authority}/> .
+                  ?s rdf:type <http://vocab.getty.edu/ontology#Concept> .
+                  FILTER regex(?name, \"#{untainted}\", \"i\") .
+                  FILTER langMatches( lang(?name), \"EN\" ) .
+                } LIMIT 10"
+      "http://vocab.getty.edu/sparql.json?query=#{URI.escape(sparql)}&_implicit=false&implicit=true&_equivalent=false&_form=%2Fsparql"
+    end
+
+    def find id
+      json(find_url(id))
+    end
+
+    def find_url id
+      "http://vocab.getty.edu/#{@sub_authority}/#{id}.json"
+    end
+
+    private
+
+    # Reformats the data received from the LOC service
+    def parse_authority_response(response)
+      response['results']['bindings'].map do |result|
+        { 'id' => result['s']['value'], 'label' => result['name']['value'] }
+      end
+    end
+
+  end
+end
+

data/lib/qa/authorities/loc.rb

@@ -1,97 +1,44 @@
 require 'uri'
 
 module Qa::Authorities
-  class Loc < Qa::Authorities::WebServiceBase
-    extend Deprecation
+  class Loc < WebServiceBase
 
-    # Initialze the Loc class with a query and get the http response from LOC's server.
-    # This is set to a JSON object
-    def initialize
-    end
-
-    def search(q, sub_authority=nil)
-      if ! (sub_authority.nil?  || Loc.sub_authorities.include?(sub_authority))
-        @raw_response = nil
-        @response = nil
-        return
-      end
+    include Qa::Authorities::LocSubauthority
 
-      q = URI.escape(q)
-      authority_fragment = sub_authorityURL(sub_authority)
-      query_url =  "http://id.loc.gov/search/?q=#{q}&q=#{authority_fragment}&format=json"
-      @raw_response = get_json(query_url)
-      @response = parse_authority_response(@raw_response)
+    def initialize *args
+      super
+      @sub_authority ||= args.first
+      raise "No sub-authority provided" if sub_authority.nil?
     end
 
-    def self.sub_authority_table
-      @sub_authority_table ||=
-        begin
-          vocab_base_url = 'cs%3Ahttp%3A%2F%2Fid.loc.gov%2Fvocabulary%2F'
-          authority_base_url = 'cs%3Ahttp%3A%2F%2Fid.loc.gov%2Fauthorities%2F'
-          datatype_base_url = 'cs%3Ahttp%3A%2F%2Fid.loc.gov%2Fdatatypes%2F'
-          vocab_preservation_base_url = 'cs%3Ahttp%3A%2F%2Fid.loc.gov%2Fvocabulary%2Fpreservation%2F'
-          {
-            'subjects' => authority_base_url,
-            'names' => authority_base_url,
-            'classification' => authority_base_url,
-            'childrensSubjects' => authority_base_url,
-            'genreForms' => authority_base_url,
-            'graphicMaterials' => vocab_base_url,
-            'organizations' => vocab_base_url,
-            'relators' => vocab_base_url,
-            'countries' => vocab_base_url,
-            'geographicAreas' => vocab_base_url,
-            'languages' => vocab_base_url,
-            'iso639-1' => vocab_base_url,
-            'iso639-2' => vocab_base_url,
-            'iso639-5' => vocab_base_url,
-            'edtf' => datatype_base_url,
-            'preservation' => vocab_base_url,
-            'actionsGranted' => vocab_base_url,
-            'agentType' => vocab_base_url,
-            'contentLocationType' => vocab_preservation_base_url,
-            'copyrightStatus' => vocab_preservation_base_url,
-            'cryptographicHashFunctions' => vocab_preservation_base_url,
-            'environmentCharacteristic' => vocab_preservation_base_url,
-            'environmentPurpose' => vocab_preservation_base_url,
-            'eventRelatedAgentRole' => vocab_preservation_base_url,
-            'eventRelatedObjectRole' => vocab_preservation_base_url,
-            'eventType' => vocab_preservation_base_url,
-            'formatRegistryRole' => vocab_preservation_base_url,
-            'hardwareType' => vocab_preservation_base_url,
-            'inhibitorTarget' => vocab_preservation_base_url,
-            'inhibitorType' => vocab_preservation_base_url,
-            'objectCategory' => vocab_preservation_base_url,
-            'preservationLevelRole' => vocab_preservation_base_url,
-            'relationshipSubType' => vocab_preservation_base_url,
-            'relationshipType' => vocab_preservation_base_url,
-            'rightsBasis' => vocab_preservation_base_url,
-            'rightsRelatedAgentRole' => vocab_preservation_base_url,
-            'signatureEncoding' => vocab_preservation_base_url,
-            'signatureMethod' => vocab_preservation_base_url,
-            'softwareType' => vocab_preservation_base_url,
-            'storageMedium' => vocab_preservation_base_url
-          }
-        end
+    def sub_authorities
+      authorities + vocabularies + datatypes + preservation
     end
 
+    def search q
+      @raw_response = get_json(build_query_url(q))
+      parse_authority_response
+    end
 
-    def sub_authorityURL(sub_authority)
-      base_url = Loc.sub_authority_table[sub_authority]
-      return "" if base_url.nil?
-      base_url + URI.escape(sub_authority)
+    def build_query_url q
+      escaped_query = URI.escape(q)
+      authority_fragment = get_url_for_authority(sub_authority) + URI.escape(sub_authority)
+      return "http://id.loc.gov/search/?q=#{escaped_query}&q=#{authority_fragment}&format=json"
     end
 
-    def self.authority_valid?(authority)
-      self.sub_authorities.include?(authority)
+    def find id
+      get_json(find_url(id))
     end
 
-    def self.sub_authorities
-      @sub_authorities ||= sub_authority_table.keys
+    def find_url id
+      "http://id.loc.gov/authorities/#{@sub_authority}/#{id}.json"
     end
 
-    def parse_authority_response(raw_responses)
-      raw_responses.select {|response| response[0] == "atom:entry"}.map do |response|
+    private
+
+    # Reformats the data received from the LOC service
+    def parse_authority_response
+      @raw_response.select {|response| response[0] == "atom:entry"}.map do |response|
         loc_response_to_qa(response_to_struct(response))
       end
     end
@@ -101,7 +48,7 @@ module Qa::Authorities
     # Note that this is a pretty naive conversion.  There should probably just
     # be a class that properly translates and stores the various pieces of
     # data, especially if this logic could be useful in other auth lookups.
-    def response_to_struct(response)
+    def response_to_struct response
       result = response.each_with_object({}) do |result_parts, result|
         next unless result_parts[0]
         key = result_parts[0].sub('atom:', '').sub('dcterms:', '')
@@ -121,63 +68,12 @@ module Qa::Authorities
     end
 
     # Simple conversion from LoC-based struct to QA hash
-    def loc_response_to_qa(data)
+    def loc_response_to_qa data
       {
         "id" => data.id || data.title,
         "label" => data.title
       }
     end
 
-    def find_record_in_response(raw_response, id)
-      raw_response.each do |single_response|
-        next if single_response[0] != "atom:entry"
-        single_response.each do |result_part|
-          if (result_part[0] == 'atom:title' ||
-              result_part[0] == 'atom:id') && id == result_part[2]
-            return single_response
-          end
-        end
-      end
-      return nil
-    end
-
-    def get_full_record(id, sub_authority)
-      Deprecation.warn(Loc, "get_full_record is deprecated and will be removed in 0.1.0. Use full_record instead", caller)
-      full_record(id, sub_authority)
-    end
-
-    def full_record(id, sub_authority)
-      search(id, sub_authority)
-      full_record = find_record_in_response(@raw_response, id)
-
-      if full_record.nil?
-        # record not found
-        return {}
-      end
-
-      parsed_result = {}
-      full_record.each do |section|
-        if section.class == Array
-          label = section[0].split(':').last.to_s
-          case label
-          when 'title', 'id', 'updated', 'created'
-            parsed_result[label] = section[2]
-          when 'link'
-            if section[1]['type'] != nil
-              parsed_result[label + "||#{section[1]['type']}"] = section[1]["href"]
-            else
-              parsed_result[label] = section[1]["href"]
-            end
-          when 'author'
-            author_list = []
-            #FIXME: Find example with two authors to better understand this data.
-            author_list << section[2][2]
-            parsed_result[label] = author_list
-          end
-        end
-      end
-      parsed_result
-    end
-
   end
 end