serrano 0.0.7

data/lib/serrano/cn.rb

@@ -0,0 +1,30 @@
+require "serrano/version"
+require "serrano/cnrequest"
+
+##
+# ContentNegotiation - Content Negotiation class
+#
+# @see http://www.crosscite.org/cn/ for details
+module Serrano
+
+  class ContentNegotiation
+
+    attr_accessor :ids
+    attr_accessor :format
+    attr_accessor :style
+    attr_accessor :locale
+
+    def initialize(ids, format = "bibtex", style = "apa", locale = "en-US")
+      self.ids = ids
+      self.format = format
+      self.style = style
+      self.locale = locale
+    end
+
+    def cn
+      CNRequest.new(self.ids, self.format, self.style, self.locale).perform
+    end
+
+  end
+
+end

data/lib/serrano/cnrequest.rb

@@ -0,0 +1,83 @@
+require "faraday"
+require "faraday_middleware"
+require "multi_json"
+require "serrano/errors"
+require "serrano/constants"
+require 'serrano/helpers/configuration'
+
+##
+# Serrano::CNRequest
+#
+# Class to perform HTTP requests to the Crossref API
+module Serrano
+  class CNRequest #:nodoc:
+
+    attr_accessor :ids
+    attr_accessor :format
+    attr_accessor :style
+    attr_accessor :locale
+
+    def initialize(ids, format, style, locale)
+      self.ids = ids
+      self.format = format
+      self.style = style
+      self.locale = locale
+    end
+
+    def perform
+      if !$cn_formats.include? self.format
+        raise "format not one of accepted types"
+      end
+
+      $conn = Faraday.new "http://dx.doi.org/" do |c|
+        c.use FaradayMiddleware::FollowRedirects
+        c.adapter :net_http
+      end
+
+      if self.ids.length == 1
+        return make_request(self.ids, self.format, self.style, self.locale)
+      else
+        coll = []
+        Array(self.ids).each do |x|
+          coll << make_request(x, self.format, self.style, self.locale)
+        end
+        return coll
+      end
+    end
+  end
+end
+
+def make_request(ids, format, style, locale)
+  type = $cn_format_headers.select { |x, _| x.include? format }.values[0]
+
+  if format == "citeproc-json"
+    endpt = "http://api.crossref.org/works/" + ids + "/" + type
+    cr_works = Faraday.new(:url => endpt)
+    res = cr_works.get
+  else
+    if format == "text"
+      type = type + "; style = " + style + "; locale = " + locale
+    end
+
+    res = $conn.get do |req|
+      req.url ids
+      req.headers['Accept'] = type
+    end
+  end
+
+  return res.body
+end
+
+# parser <- cn_types[[self.format]]
+# if (raw) {
+#   content(response, "text")
+# } else {
+#   out <- content(response, "parsed", parser, "UTF-8")
+#   if (format == "text") {
+#     out <- gsub("\n", "", out)
+#   }
+#   if (format == "bibentry") {
+#     out <- parse_bibtex(out)
+#   }
+#   out
+# }

data/lib/serrano/constants.rb

@@ -0,0 +1,36 @@
+require 'net/http'
+
+NETWORKABLE_EXCEPTIONS = [Faraday::Error::ClientError,
+                          URI::InvalidURIError,
+                          Encoding::UndefinedConversionError,
+                          ArgumentError,
+                          NoMethodError,
+                          TypeError]
+
+$cn_formats = ["rdf-xml", "turtle", "citeproc-json",
+	          "citeproc-json-ish", "text", "ris", "bibtex",
+	          "crossref-xml", "datacite-xml", "bibentry",
+	          "crossref-tdm"]
+
+$cn_format_headers = {"rdf-xml" => "application/rdf+xml",
+	          "turtle" => "text/turtle",
+	          "citeproc-json" => "transform/application/vnd.citationstyles.csl+json",
+	          "text" => "text/x-bibliography",
+	          "ris" => "application/x-research-info-systems",
+	          "bibtex" => "application/x-bibtex",
+	          "crossref-xml" => "application/vnd.crossref.unixref+xml",
+	          "datacite-xml" => "application/vnd.datacite.datacite+xml",
+	          "bibentry" => "application/x-bibtex",
+	          "crossref-tdm" => "application/vnd.crossref.unixsd+xml"}
+
+$cn_types = {"rdf-xml" => "text/xml",
+		      "turtle" => "text/plain",
+		      "citeproc-json" => "application/json",
+		      "citeproc-json-ish" => "application/json",
+		      "text" => "text/plain",
+		      "ris" => "text/plain",
+		      "bibtex" => "text/plain",
+		      "crossref-xml" => "text/xml",
+		      "datacite-xml" => "text/xml",
+		      "bibentry" => "text/plain",
+		      "crossref-tdm" => "text/xml"}

data/lib/serrano/errors.rb

@@ -0,0 +1,67 @@
+require 'net/http'
+
+def rescue_faraday_error(url, error, options={})
+  details = nil
+  headers = {}
+
+  if error.is_a?(Faraday::Error::TimeoutError)
+    status = 408
+  elsif error.respond_to?('status')
+    status = error[:status]
+  elsif error.respond_to?('response') && error.response.present?
+    status = error.response[:status]
+    details = error.response[:body]
+    headers = error.response[:headers]
+  else
+    status = 400
+  end
+
+  # Some sources use a different status for rate-limiting errors
+  status = 429 if status == 403 && details.include?("Excessive use detected")
+
+  if error.respond_to?('exception')
+    exception = error.exception
+  else
+    exception = ""
+  end
+
+  class_name = class_name_by_status(status) || error.class
+
+  message = parse_error_response(error.message)
+  message = "#{message} for #{url}"
+  message = "#{message} with rev #{options[:data][:rev]}" if class_name == Net::HTTPConflict
+
+  { error: message, status: status }
+end
+
+def parse_error_response(string)
+  if is_json?(string)
+    string = MultiJson.load(string)
+  end
+  string = string['error'] if string.is_a?(Hash) && string['error']
+  string
+end
+
+def is_json?(string)
+  MultiJson.load(string)
+rescue MultiJson::ParseError => e
+  e.data
+  e.cause
+end
+
+def class_name_by_status(status)
+  { 400 => Net::HTTPBadRequest,
+    401 => Net::HTTPUnauthorized,
+    403 => Net::HTTPForbidden,
+    404 => Net::HTTPNotFound,
+    406 => Net::HTTPNotAcceptable,
+    408 => Net::HTTPRequestTimeOut,
+    409 => Net::HTTPConflict,
+    417 => Net::HTTPExpectationFailed,
+    429 => Net::HTTPTooManyRequests,
+    500 => Net::HTTPInternalServerError,
+    502 => Net::HTTPBadGateway,
+    503 => Net::HTTPServiceUnavailable,
+    504 => Net::HTTPGatewayTimeOut }.fetch(status, nil)
+end
+

data/lib/serrano/filterhandler.rb

@@ -0,0 +1,58 @@
+# helper functions
+module Serrano
+  class Request #:nodoc:
+
+    private
+
+    $others = ['license_url','license_version','license_delay','full_text_version','full_text_type',
+               'award_number','award_funder']
+
+    def filter_handler(x = nil)
+      if x.nil?
+        nil
+      else
+        x = stringify(x)
+        nn = x.keys.collect{ |x| x.to_s }
+        if nn.collect{ |x| $others.include? x }.any?
+          nn = nn.collect{ |x|
+            if $others.include? x
+              case x
+              when 'license_url'
+                'license.url'
+              when 'license_version'
+                'license.version'
+              when 'license_delay'
+                'license.delay'
+              when 'full_text_version'
+                'full-text.version'
+              when 'full_text_type'
+                'full-text.type'
+              when 'award_number'
+                'award.number'
+              when 'award_funder'
+                'award.funder'
+              end
+            else
+              x
+            end
+          }
+        end
+
+        newnn = nn.collect{ |x| x.gsub("_", "-") }
+        x = rename_keys(x, newnn)
+        x = x.collect{ |k,v| [k, v].join(":") }.join(',')
+        return x
+      end
+    end
+
+    def stringify(x)
+      (x.keys.map{ |k,v| k.to_s }.zip x.values).to_h
+    end
+
+    def rename_keys(x, y)
+      (y.zip x.values).to_h
+    end
+
+  end
+
+end

data/lib/serrano/filters.rb

@@ -0,0 +1,84 @@
+##
+# Serrano::Filters
+#
+# Information on Crossref API filters
+#
+# @example
+#    # List filter names
+#    Serrano::Filters.names
+#    # List filter values and description
+#    Serrano::Filters.filters
+#    Serrano::Filters.filters['has_funder']
+#    Serrano::Filters.filters['has_funder']['description']
+module Serrano
+  module Filters
+    def self.names
+      $filter_list
+    end
+
+    def self.filters
+      $filter_details
+    end
+  end
+end
+
+$filter_list = [
+  'has_funder','funder','prefix','member','from_index_date','until_index_date',
+  'from_deposit_date','until_deposit_date','from_update_date','until_update_date',
+  'from_first_deposit_date','until_first_deposit_date','from_pub_date','until_pub_date',
+  'has_license','license_url','license_version','license_delay','has_full_text',
+  'full_text_version','full_text_type','public_references','has_references','has_archive',
+  'archive','has_orcid','orcid','issn','type','directory','doi','updates','is_update',
+  'has_update_policy','container_title','publisher_name','category_name','type_name',
+  'from_created_date', 'until_created_date', 'affiliation', 'has_affiliation',
+  'assertion_group', 'assertion', 'article_number', 'alternative_id'
+]
+
+$filter_details = {
+  "has_funder" => { "possible_values" => nil, "description" => "metadata which includes one or more funder entry" },
+  "funder" => { "possible_values" => "{funder_id}", "description" => "metadata which include the {funder_id} in FundRef data" },
+  "prefix" => { "possible_values" => "{owner_prefix}", "description" => "metadata belonging to a DOI owner prefix {owner_prefix} (e.g. '10.1016' )" },
+  "member" => { "possible_values" => "{member_id}", "description" => "metadata belonging to a CrossRef member" },
+  "from_index_date" => { "possible_values" => '{date}', "description" => "metadata indexed since (inclusive) {date}" },
+  "until_index_date" => { "possible_values" => '{date}', "description" => "metadata indexed before (inclusive) {date}" },
+  "from_deposit_date" => { "possible_values" => '{date}', "description" => "metadata last (re)deposited since (inclusive) {date}" },
+  "until_deposit_date" => { "possible_values" => '{date}', "description" => "metadata last (re)deposited before (inclusive) {date}" },
+  "from_update_date" => { "possible_values" => '{date}', "description" => "Metadata updated since (inclusive) {date} Currently the same as 'from_deposit_date'" },
+  "until_update_date" => { "possible_values" => '{date}', "description" => "Metadata updated before (inclusive) {date} Currently the same as 'until_deposit_date'" },
+  "from_created_date" => { "possible_values" => '{date}', "description" => "metadata first deposited since (inclusive) {date}" },
+  "until_created_date" => { "possible_values" => '{date}', "description" => "metadata first deposited before (inclusive) {date}" },
+  "from_pub_date" => { "possible_values" => '{date}', "description" => "metadata where published date is since (inclusive) {date}" },
+  "until_pub_date" => { "possible_values" => '{date}', "description" => "metadata where published date is before (inclusive)  {date}" },
+  "has_license" => { "possible_values" => nil, "description" => "metadata that includes any '<license_ref>' elements" },
+  "license_url" => { "possible_values" => '{url}', "description" => "metadata where '<license_ref>' value equals {url}" },
+  "license_version" => { "possible_values" => '{string}', "description" => "metadata where the '<license_ref>''s 'applies_to' attribute  is '{string}'"},
+  "license_delay" => { "possible_values" => "{integer}", "description" => "metadata where difference between publication date and the '<license_ref>''s 'start_date' attribute is <= '{integer}' (in days"},
+  "has_full_text" => { "possible_values" => nil, "description" => "metadata that includes any full text '<resource>' elements_" },
+  "full_text_version" => { "possible_values" => '{string}' , "description" => "metadata where '<resource>' element's 'content_version' attribute is '{string}'" },
+  "full_text_type" => { "possible_values" => '{mime_type}' , "description" => "metadata where '<resource>' element's 'content_type' attribute is '{mime_type}' (e.g. 'application/pdf')" },
+  "public_references" => { "possible_values" => nil, "description" => "metadata where publishers allow references to be distributed publically" },
+  "has_references" => { "possible_values" => nil , "description" => "metadata for works that have a list of references" },
+  "has_archive" => { "possible_values" => nil , "description" => "metadata which include name of archive partner" },
+  "archive" => { "possible_values" => '{string}', "description" => "metadata which where value of archive partner is '{string}'" },
+  "has_orcid" => { "possible_values" => nil, "description" => "metadata which includes one or more ORCIDs" },
+  "orcid" => { "possible_values" => '{orcid}', "description" => "metadata where '<orcid>' element's value = '{orcid}'" },
+  "issn" => { "possible_values" => '{issn}', "description" => "metadata where record has an ISSN = '{issn}' Format is 'xxxx_xxxx'." },
+  "type" => { "possible_values" => '{type}', "description" => "metadata records whose type = '{type}' Type must be an ID value from the list of types returned by the '/types' resource" },
+  "directory" => { "possible_values" => "{directory}", "description" => "metadata records whose article or serial are mentioned in the given '{directory}'. Currently the only supported value is 'doaj'" },
+  "doi" => { "possible_values" => '{doi}', "description" => "metadata describing the DOI '{doi}'" },
+  "updates" => { "possible_values" => '{doi}', "description" => "metadata for records that represent editorial updates to the DOI '{doi}'" },
+  "is_update" => { "possible_values" => nil, "description" => "metadata for records that represent editorial updates" },
+  "has_update_policy" => { "possible_values" => nil, "description" => "metadata for records that include a link to an editorial update policy" },
+  "container_title" => { "possible_values" => nil, "description" => "metadata for records with a publication title exactly with an exact match" },
+  "publisher_name" => { "possible_values" => nil, "description" => "metadata for records with an exact matching publisher name" },
+  "category_name" => { "possible_values" => nil, "description" => "metadata for records with an exact matching category label" },
+  "type_name" => { "possible_values" => nil, "description" => "metadata for records with an exacty matching type label" },
+  "award_number" => { "possible_values" => "{award_number}", "description" => "metadata for records with a matching award nunber_ Optionally combine with 'award_funder'" },
+  "award_funder" => { "possible_values" => '{funder doi or id}', "description" => "metadata for records with an award with matching funder. Optionally combine with 'award_number'" },
+  "assertion_group" => { "possible_values" => nil, "description" => "metadata for records with an assertion in a particular group" },
+  "assertion" => { "possible_values" => nil, "description" => "metadata for records with a particular named assertion" },
+  "affiliation" => { "possible_values" => nil, "description" => "metadata for records with at least one contributor with the given affiliation" },
+  "has_affiliation" => { "possible_values" => nil, "description" => "metadata for records that have any affiliation information" },
+  "alternative_id" => { "possible_values" => nil, "description" => "metadata for records with the given alternative ID, which may be a publisher_specific ID, or any other identifier a publisher may have provided" },
+  "article_number" => { "possible_values" => nil, "description" => "metadata for records with a given article number" }
+}

data/lib/serrano/helpers/configuration.rb

@@ -0,0 +1,26 @@
+# taken from: https://viget.com/extend/easy-gem-configuration-variables-with-defaults
+module Configuration
+
+  def configuration
+    yield self
+  end
+
+  def define_setting(name, default = nil)
+    class_variable_set("@@#{name}", default)
+    define_class_method "#{name}=" do |value|
+      class_variable_set("@@#{name}", value)
+    end
+    define_class_method name do
+      class_variable_get("@@#{name}")
+    end
+  end
+
+  private
+
+  def define_class_method(name, &block)
+    (class << self; self; end).instance_eval do
+      define_method name, &block
+    end
+  end
+
+end

data/lib/serrano/mine_utils.rb

@@ -0,0 +1,65 @@
+require 'nokogiri'
+require 'uuidtools'
+
+def detect_type(x)
+  ctype = x.headers['content-type']
+  case ctype
+  when 'text/xml'
+    'xml'
+  when 'text/plain'
+    'plain'
+  when 'application/pdf'
+    'pdf'
+  end
+end
+
+def make_ext(x)
+  case x
+  when 'xml'
+    'xml'
+  when 'plain'
+    'txt'
+  when 'pdf'
+    'pdf'
+  end
+end
+
+def make_path(type)
+  # id = x.split('article/')[1].split('?')[0]
+  # path = id + '.' + type
+  # return path
+  type = make_ext(type)
+  uuid = UUIDTools::UUID.random_create.to_s
+  path = uuid + '.' + type
+  return path
+end
+
+def write_disk(res, path)
+  f = File.new(path, "wb")
+  f.write(res.body)
+  f.close()
+end
+
+def read_disk(path)
+  return File.read(path)
+end
+
+def parse_xml(x)
+  text = read_disk(x)
+  xml = Nokogiri.parse(text)
+  return xml
+end
+
+def parse_plain(x)
+  text = read_disk(x)
+  return text
+end
+
+def parse_pdf(x)
+  raise "not ready yet"
+end
+
+def is_elsevier(x)
+  tmp = x.match 'elsevier'
+  !tmp.nil?
+end