montague 0.2.0

data/lib/montague/version.rb

@@ -0,0 +1,5 @@
+module Montague
+  # Semantic version number
+  #
+  VERSION = "0.2.0"
+end

data/lib/montague/xml_extractor/base.rb

@@ -0,0 +1,58 @@
+module Montague
+  module XMLExtractor
+    # Base XML extractor
+    #
+    class Base
+
+      def initialize(xml)
+         make_doc xml
+      end
+
+      private
+
+      def make_doc(xml)
+        @doc = Nokogiri::XML xml
+        @doc.remove_namespaces!
+      end
+
+      # XPath search for a single value, at a given path.
+      #
+      # @return [String, nil]
+      def xpath_query_for_single_value(path)
+        xpath_result = @doc.xpath(path).text
+        xpath_result.empty? ? nil : xpath_result
+      end
+
+      # XPath search for multiple values, at a given path.
+      #
+      # @return [Array<String>]
+      def xpath_query_for_multi_value(path)
+        xpath_result = @doc.xpath path
+        arr = []
+        xpath_result.each { |i| arr << i.text.strip }
+        arr.uniq
+      end
+
+      def xpath_query(path)
+        @doc.xpath path
+      end
+
+      def root_path
+        '/romeoapi'
+      end
+
+      def header_path
+        File.join root_path, 'header'
+      end
+
+      def journal_path
+        File.join root_path, 'journals/journal'
+      end
+
+      def publisher_path
+        File.join root_path, 'publishers/publisher'
+      end
+
+    end
+  end
+end

data/lib/montague/xml_extractor/header.rb

@@ -0,0 +1,43 @@
+module Montague
+  module XMLExtractor
+    # Header extractor
+    #
+    class Header < Montague::XMLExtractor::Base
+
+      def initialize(xml)
+        super
+      end
+
+      # @return [String, nil]
+      def api_control
+        xpath_query_for_single_value(File.join header_path, 'apicontrol')
+      end
+
+      # @return [Fixnum, nil]
+      def hits
+        xpath_query_for_single_value(File.join header_path, 'numhits').to_i
+      end
+
+      # @return [String, nil]
+      def message
+        xpath_query_for_single_value(File.join header_path, 'message')
+      end
+
+      # @return [String, nil]
+      def outcome
+        xpath_query_for_single_value(File.join header_path, 'outcome')
+      end
+
+      # @return [Montague::Model::Header]
+      def model
+        m = Montague::Model::Header.new
+        m.api_control = api_control
+        m.hits = hits
+        m.message = message
+        m.outcome = outcome
+        m
+      end
+
+    end
+  end
+end

data/lib/montague/xml_extractor/journal.rb

@@ -0,0 +1,31 @@
+module Montague
+  module XMLExtractor
+    # Journal XML extractor
+    #
+    class Journal < Montague::XMLExtractor::Base
+
+      def initialize(xml)
+        super
+      end
+
+      # @return [Array<Montague::Model::Journal>]
+      def models
+        data = []
+        xpath_result = xpath_query journal_path
+        xpath_result.each do |i|
+          journal = Montague::Model::Journal.new
+          journal.title = i.xpath('jtitle').text.strip
+          journal.issn = i.xpath('issn').text.strip
+          data << journal
+        end
+        data
+      end
+
+      # @return [Montague::Model::Journal]
+      def model
+        models.first unless models.empty?
+      end
+
+    end
+  end
+end

data/lib/montague/xml_extractor/publisher.rb

@@ -0,0 +1,164 @@
+module Montague
+  module XMLExtractor
+    # Publisher XML extractor
+    #
+    class Publisher < Montague::XMLExtractor::Base
+
+      def initialize(xml)
+        super
+      end
+
+      # @return [String]
+      def name_alias
+        xpath_query_for_single_value '/publisher/alias'
+      end
+
+      # @return [Array<String>]
+      def conditions
+        xpath_query_for_multi_value '/publisher/conditions/condition'
+      end
+
+      # @return [Array<Montague::Model::CopyrightLink>]
+      def copyright_links
+        data = []
+        xpath_result = xpath_query '/publisher/copyrightlinks/copyrightlink'
+        xpath_result.each do |i|
+          copyright_link = Montague::Model::CopyrightLink.new
+          copyright_link.text = i.xpath('copyrightlinktext').text.strip
+          copyright_link.url = i.xpath('copyrightlinkurl').text.strip
+          data << copyright_link if copyright_link.data?
+        end
+        data
+      end
+
+      # @return [String] Allows for dummy ID string when there is no RoMEO entry with numeric ID
+      def id
+        xpath_query_for_single_value('/publisher/@id').to_s
+      end
+
+      # Publisher compliance with the open access mandates of research funding agencies
+      # @return [Array<Montague::Model::Mandate>]
+      def mandates
+        xpath_result = xpath_query '/publisher/mandates/mandate'
+        data = []
+        xpath_result.each do |i|
+          mandate = Montague::Model::Mandate.new
+          funder = Montague::Model::Funder.new
+          funder.name = i.xpath('funder/fundername').text.strip
+          funder.acronym = i.xpath('funder/funderacronym').text.strip
+          mandate.funder = funder if funder.data?
+          mandate.publisher_complies = i.xpath('publishercomplies').text.strip
+          mandate.compliance_type = i.xpath('compliancetype').text.strip
+          mandate.selected_titles = i.xpath('selectedtitles').text.strip
+          data << mandate if mandate.data?
+        end
+        data
+      end
+
+      # @return [String, nil]
+      def name
+        xpath_query_for_single_value '/publisher/name'
+      end
+
+
+      # @return [Montague::Model::PaidAccess, nil]
+      def paid_access
+        xpath_result = xpath_query '/publisher/paidaccess'
+        if !xpath_result.empty?
+          paid_access = Montague::Model::PaidAccess.new
+          paid_access.url = xpath_result.xpath('paidaccessurl').text.strip
+          paid_access.name = xpath_result.xpath('paidaccessname').text.strip
+          paid_access.notes = xpath_result.xpath('paidaccessnotes').text.strip
+          paid_access
+        end
+      end
+
+      # @return (see #prints)
+      def pre_prints
+        paths = {
+          archiving: 'preprints',
+          permission: 'prearchiving',
+          restrictions: 'prerestrictions'
+        }
+        prints paths
+      end
+
+      # @return (see #prints)
+      def post_prints
+        paths = {
+          archiving: 'postprints',
+          permission: 'postarchiving',
+          restrictions: 'postrestrictions'
+        }
+        prints paths
+      end
+
+      # @return [Montague::Model::Archiving, nil]
+      def pdf_version
+        paths = {
+          archiving: 'pdfversion',
+          permission: 'pdfarchiving',
+          restrictions: 'pdfrestrictions'
+        }
+        prints paths
+      end
+
+      # @return [String, nil]
+      def romeo_colour
+       xpath_query_for_single_value '/publisher/romeocolour'
+      end
+
+      # @return [Array<Montague::Model::Publisher>]
+      def models
+        data = []
+        xpath_result = xpath_query publisher_path
+        xpath_result.each do |i|
+          xml_extractor = Montague::XMLExtractor::Publisher.new i.to_s
+          # puts i.to_s
+          data << xml_extractor.package_model
+        end
+        data
+      end
+
+      # @return [Montague::Model::Publisher]
+      def model
+        models.first unless models.empty?
+      end
+
+      # @return [Montague::Model::Publisher]
+      def package_model
+        m = Montague::Model::Publisher.new
+        m.alias = name_alias
+        m.conditions =  conditions
+        m.copyright_links = copyright_links
+        m.id = id
+        m.mandates = mandates
+        m.name = name
+        m.paid_access = paid_access
+        m.pdf_version = pdf_version
+        m.pre_prints = pre_prints
+        m.post_prints = post_prints
+        m.romeo_colour = romeo_colour
+        m
+      end
+
+      private
+
+      # @return [Montague::Model::Archiving, nil]
+      def prints(paths)
+        xpath_result = xpath_query "/publisher/#{paths[:archiving]}"
+        if !xpath_result.empty?
+          archiving = Montague::Model::Archiving.new
+          archiving.permission = xpath_result.xpath(paths[:permission]).text.strip
+          archiving.restrictions = []
+          restrictions = xpath_result.xpath paths[:restrictions]
+          restrictions.each do |i|
+            archiving.restrictions << i.text.strip if !i.text.empty?
+          end
+          archiving
+        end
+      end
+
+    end
+  end
+end

data/lib/montague/xml_extractor/xml_extractor.rb

@@ -0,0 +1,13 @@
+require 'nokogiri'
+require 'montague/xml_extractor/base'
+require 'montague/xml_extractor/publisher'
+require 'montague/xml_extractor/header'
+require 'montague/xml_extractor/journal'
+
+module Montague
+  # An XMLExtractor manages the extraction of metadata from XML into Ruby
+  # data structures.
+  #
+  module XMLExtractor
+  end
+end

data/montague.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'montague/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'montague'
+  spec.version       = Montague::VERSION
+  spec.authors       = 'Adrian Albin-Clark'
+  spec.email         = 'a.albin-clark@lancaster.ac.uk'
+  spec.summary       = %q{Wrapper for the SHERPA/RoMEO API.}
+  spec.homepage      = 'https://github.com/lulibrary/montague'
+  spec.license       = 'MIT'
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '~> 2.1'
+  spec.add_runtime_dependency 'http', '~> 2.0'
+  spec.add_runtime_dependency 'nokogiri', '~> 1.6'
+  spec.add_development_dependency 'minitest-reporters', '~> 1.1'
+end

data/test/test_helper.rb

@@ -0,0 +1,102 @@
+require 'minitest/autorun'
+require 'minitest/reporters'
+Minitest::Reporters.use!
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib)
+
+require 'montague'
+
+def config
+  {
+      api_key: ENV['MONTAGUE_API_KEY'],
+  }
+end
+
+def asserts_publisher(x)
+
+  # puts x.inspect
+
+  assert_instance_of Montague::Model::Publisher, x
+
+  assert_instance_of String, x.alias if x.alias
+
+  assert_instance_of Array, x.conditions
+  x.conditions.each { |i| assert_instance_of String, i}
+
+  assert_instance_of Array, x.copyright_links
+  x.copyright_links.each { |i| assert_instance_of Montague::Model::CopyrightLink, i}
+
+  assert_instance_of String, x.id
+
+  assert_instance_of Array, x.mandates
+
+  assert_instance_of String, x.name
+  refute_empty x.name
+
+  assert_instance_of Montague::Model::PaidAccess, x.paid_access if x.paid_access
+  # assert_equal true, x.paid_access.data?
+
+  assert_instance_of Montague::Model::Archiving, x.pdf_version
+  assert_equal true, x.pdf_version.data?
+
+  assert_instance_of Montague::Model::Archiving, x.post_prints
+  assert_equal true, x.post_prints.data?
+
+  assert_instance_of Montague::Model::Archiving, x.pre_prints
+  assert_equal true, x.pre_prints.data?
+
+  assert_instance_of String, x.romeo_colour
+  refute_empty x.romeo_colour
+end
+
+def asserts_journal(x)
+  assert_instance_of Montague::Model::Journal, x
+
+  assert_instance_of String, x.issn if x.issn
+
+  assert_instance_of String, x.title
+  refute_empty x.title
+end
+
+def asserts_header(x)
+  assert_instance_of Montague::Model::Header, x
+
+  assert_instance_of Fixnum, x.hits
+
+  assert_instance_of String, x.message if x.message
+
+  assert_instance_of String, x.outcome
+  refute_empty x.outcome
+end
+
+def asserts_journal_report(x)
+  assert_instance_of Montague::Model::JournalReport, x
+  assert_instance_of HTTP::Response, x.http_response
+  asserts_header x.header
+  asserts_journal x.journal if x.journal
+end
+
+def asserts_journals_report(x)
+  assert_instance_of Montague::Model::JournalsReport, x
+  assert_instance_of HTTP::Response, x.http_response
+  asserts_header x.header
+  x.journals.each { |i| asserts_journal i }
+end
+
+def asserts_publishers_report(x)
+  x.publishers.each { |i| asserts_publisher i }
+  assert_instance_of HTTP::Response, x.http_response
+  asserts_header x.header
+end
+
+def asserts_publisher_report(x)
+  asserts_publisher x.publisher
+  assert_instance_of HTTP::Response, x.http_response
+  asserts_header x.header
+end
+
+def asserts_publisher_found(x)
+  assert_equal true, x.respond_to?(:publisher)
+  refute_nil x.publisher
+end