citero 1.0.0.alpha

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a420fcb5e2a2984a8075c248070be78ba1523017
+  data.tar.gz: 8728f7f6805f7713e84e4586606a31f7c5af7bb9
+SHA512:
+  metadata.gz: 0c5fd7a6553dd5be250cbf512f5f9fca8e5ac5c6c60d184797913992d9cc4cdb49fba005bdc1b25f37de2aae93f43391544d1abbec917a8c416ce4190ccff599
+  data.tar.gz: b8663ea856531cc639cda15902992d0caeb7b2a6855be5595a72607a939d5ba21fad9909677ec4fcf047dbccc0f293624713151768d3539cb387af516f2515f2

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/README.md

@@ -0,0 +1,27 @@
+Citero-ruby
+==========
+Ruby repository for the [Citero](https://github.com/NYULibraries/citero) project.
+
+Citero is a program that allows for mapping of data inputs from various systems into one normalized metadata schema
+tentatively known as *Citero Standard Form*, or *CSF*. From the normalized schema, *CSF*, it can produce another output
+format for use by another system.
+
+Citero-ruby is a complete rewrite of the Java project in Ruby.
+
+Currently Supported Formats/Systems
+===================================
+
+How to install
+==============
+
+How to run
+==========
+
+API Considerations
+==========
+
+Exceptions
+==========
+
+CSF
+=====

data/Rakefile

@@ -0,0 +1,7 @@
+begin
+  require 'rspec/core/rake_task'
+  require 'bundler/gem_tasks'
+  RSpec::Core::RakeTask.new(:spec)
+  task :default => :spec
+rescue LoadError
+end

data/lib/citero.rb

@@ -0,0 +1,123 @@
+module Citero
+  require_relative 'citero/version'
+  require_relative 'citero/csf'
+  require_relative 'citero/inputs'
+  require_relative 'citero/outputs'
+  require_relative 'citero/utils'
+
+  def self.from_formats
+    [:csf, :openurl, :pnx]
+  end
+
+  def self.to_formats
+    [:csf, :ris, :openurl, :bibtex, :easybib, :refworks_tagged]
+  end
+
+  def self.citation_styles
+    []
+  end
+
+  def self.map(input)
+    @input = input
+    self
+  end
+
+  def self.from_(format)
+    @from_format = format.to_sym
+    self
+  end
+
+  def self.csf
+    return nil unless @from_format
+    case @from_format
+      when :csf
+        data = @input
+        data = csf_string_to_hash(data) if data.kind_of?(String)
+        from = Citero::CSF.new(data)
+      when :openurl
+        from = Citero::Inputs::OpenUrl.new(@input)
+      when :pnx
+        from = Citero::Inputs::Pnx.new(@input)
+      else
+        raise ArgumentError
+    end
+    return from.csf
+  end
+
+  def self.to_(format)
+    @to_format = format.to_sym
+
+    case @from_format
+      when :csf
+        data = @input
+        data = csf_string_to_hash(data) if data.kind_of?(String)
+        from = Citero::CSF.new(data)
+      when :openurl
+        from = Citero::Inputs::OpenUrl.new(@input)
+      when :pnx
+        from = Citero::Inputs::Pnx.new(@input)
+      else
+        raise ArgumentError
+    end
+
+    case @to_format
+      when :ris
+        return Citero::Outputs::Ris.new(from).to_ris
+      when :openurl
+        return Citero::Outputs::OpenUrl.new(from).to_openurl
+      when :bibtex
+        return Citero::Outputs::Bibtex.new(from).to_bibtex
+      when :easybib
+        return Citero::Outputs::EasyBib.new(from).to_easybib
+      when :refworks_tagged
+        return Citero::Outputs::RefworksTagged.new(from).to_refworks_tagged
+      when :csf
+        str = ""
+        from.csf.each do |k,v|
+          if v.kind_of?(Array)
+            v.each do |va|
+              str = "#{str}#{k}: #{va.gsub('.','\.').gsub(',','\,')}\n"
+            end
+          else
+            str = "#{str}#{k}: #{v.gsub('.','\.').gsub(',','\,')}\n"
+          end
+        end
+        return str.chomp
+    end
+  end
+
+  private
+
+  def self.csf_string_to_hash(string)
+    hash = {}
+    string.lines.map(&:strip).each do |line|
+      k,v = line.split(':',2).map(&:strip)
+      hash[k] = [hash[k],v].compact.flatten
+    end
+    hash
+  end
+
+  def self.method_missing(method_sym, *arguments, &block)
+    super unless respond_to?(method_sym, *arguments, &block)
+    method_str = method_sym.to_s
+    if (method_str.include? "to_")
+      to_(method_str.split('_',2).last)
+    elsif (method_str.include? "from_")
+      from_(method_str.split('_',2).last)
+    else
+      super
+    end
+  end
+
+  def self.respond_to?(method_sym, *arguments, &block)
+    method_arr = method_sym.to_s.split('_',2)
+    return super unless method_arr.size > 1
+    if method_arr.first.eql?("from")
+      return self.from_formats.include?(method_arr.last.to_sym)
+    end
+    if method_arr.first.eql?("to")
+      return self.to_formats.include?(method_arr.last.to_sym)
+    end
+    super
+  end
+end

data/lib/citero/csf.rb

@@ -0,0 +1,31 @@
+module Citero
+  class CSF
+    extend Forwardable
+    def_delegators :@data, :[], :[]=, :size, :each, :inspect, :to_s
+    attr_reader :data
+    alias_method :csf, :data
+
+    def initialize(hash = nil)
+      @data = Hash.new
+      load_from_hash(hash) unless hash.nil?
+    end
+
+    def load_from_hash(hash)
+      hash.each_pair do |key,value|
+        next if value.nil?
+        self.send(:[]=, key, value)
+      end
+    end
+
+    def []=(key,value)
+      @data[key] = element_or_list(@data[key], value)
+    end
+
+    private
+    def element_or_list(new_value, old_value)
+      temp_arr = [new_value, old_value].flatten.compact
+      return temp_arr.first if temp_arr.size == 1
+      return temp_arr
+    end
+  end
+end

data/lib/citero/inputs.rb

@@ -0,0 +1,7 @@
+module Citero
+  module Inputs
+    require_relative 'inputs/readers'
+    require_relative 'inputs/pnx'
+    require_relative 'inputs/openurl'
+  end
+end

data/lib/citero/inputs/openurl.rb

@@ -0,0 +1,272 @@
+module Citero
+  module Inputs
+    class OpenUrl
+      require 'open-uri'
+      require 'cgi'
+
+      attr_reader :csf, :params
+
+      def initialize(raw_data)
+        @raw_data = raw_data
+        construct_csf
+      end
+
+      private
+
+      def construct_csf
+        @csf    = CSF.new
+        url     = @raw_data
+        @params = CGI.parse(CGI::unescape(URI.parse(url).query))
+        remove_blanks_from_params
+
+        hash = [
+          {"itemType" => item_type},
+          rft_id,
+          map_one_to_one_fields,
+          isbn,
+          # rfr_id,
+          btitle,
+          atitle,
+          jtitle,
+          stitle,
+          title,
+          date,
+          author,
+          issn,
+          inventor,
+          authors,
+          publisher,
+          thesis_elements,
+          patent_elements,
+          webpage_elements,
+          {"importedFrom" => "OpenURL"}
+        ].compact.reduce({}, :merge)
+
+        @csf.load_from_hash(hash)
+      end
+
+      def remove_blanks_from_params
+        @params.each do |key,values|
+          values = values.uniq.compact.reject(&:empty?)
+          if values.empty?
+            @params.delete(key)
+          else
+            @params[key] = values
+          end
+        end
+      end
+
+
+      def get_format(openurl_format)
+        return simple_types[openurl_format] if simple_types.has_key?(openurl_format)
+        return get_book_format(openurl_format)
+      end
+
+      def get_book_format(openurl_format)
+        return 'document' unless openurl_format.eql?('info:ofi/fmt:kev:mtx:book')
+        return book_type[params['rft.genre']] if book_type.has_key?(params['rft.genre'])
+        return 'book'
+      end
+
+      def item_type
+        get_format(params["rft_val_fmt"].first)
+      end
+
+      def book_type
+        {
+          "bookitem" => "bookSection",
+          "conference" => "conferencePaper",
+          "proceeding" => "conferencePaper",
+          "report" => "report",
+          "document" => "document"
+        }
+      end
+
+      def simple_types
+        {
+          "info:ofi/fmt:kev:mtx:journal" => "journalArticle",
+          "info:ofi/fmt:kev:mtx:dissertation" => "thesis",
+          "info:ofi/fmt:kev:mtx:patent" => "patent",
+          "info:ofi/fmt:kev:mtx:dc" => "webpage",
+          "info:ofi/fmt:kev:mtx:audio" => "audioRecording"
+        }
+      end
+
+      def key_mappings
+        {
+          'rft.type'        =>  'itemType',
+          'rft.description' =>  'abstractNote',
+          'rft.rights'      =>  'rights',
+          'rft.language'    =>  'language',
+          'rft.subject'     =>  'tags',
+          'rft.source'      =>  'publicationTitle',
+          'rft.pub'         =>  'publisher',
+          'rft.publisher'   =>  'publisher',
+          'rft.place'       =>  'place',
+          'rft.edition'     =>  'edition',
+          'rft.series'      =>  'series',
+          'rft.volume'      =>  'volume',
+          'rft.issue'       =>  'issue',
+          'rft.inventor'    =>  'inventor',
+          'rft.contributor' =>  'contributor',
+          'rft.aucorp'      =>  'author',
+          'rft.pages'       =>  'pages',
+          'rft.spage'       =>  'startPage',
+          'rft.epage'       =>  'endPage',
+          'rft.tpages'      =>  'numPage'
+        }
+      end
+
+      def map_one_to_one_fields
+        arr = []
+        key_mappings.each do |k,v|
+          arr << create_sub_hash(v,k)
+        end
+        arr.compact.reduce({}, :merge)
+      end
+
+
+      def rft_id
+        rft_id = params['rft_id'].first
+        return if rft_id.nil?
+        if rft_id.start_with? 'info:doi/' || rft_id.start_with?('urn.isbn/')
+          return { "isbn" => rft_id[9..-1] } unless rft_id[9..-1].empty?
+        end
+        return { "url" => rft_id, "accessDate" => "" } if rft_id.match /^https?:\/\/.*/
+        return {}
+      end
+
+      def rfr_id
+        return { "rfr_id" => params['rfr_id'].first } if params['rfr_id'].first
+        return {}
+      end
+
+      def create_formatted_sub_hash(key, value)
+        return nil unless key and value and !value.empty?
+        return { key => value }
+      end
+
+      def create_sub_hash(key,value)
+        create_formatted_sub_hash(key, params[value])
+      end
+
+      def btitle
+        key = 'title'             if ['book','report'].include?(item_type)
+        key = 'publicationTitle'  if ['bookSection','conferencePaper'].include?(item_type)
+        create_sub_hash(key, 'rft.btitle')
+      end
+
+      def atitle
+        key = 'title' if ['journalArticle','bookSection','conferencePaper'].include?(item_type)
+        create_sub_hash(key, 'rft.atitle')
+      end
+
+      def jtitle
+        key = 'publicationTitle' if ['journalArticle'].include?(item_type)
+        create_sub_hash(key, 'rft.jtitle')
+      end
+
+      def stitle
+        key = 'journalAbbreviation' if ['journalArticle'].include?(item_type)
+        create_sub_hash(key, 'rft.stitle')
+      end
+
+      def title
+        key = 'title'
+        key = 'publicationTitle' if ['journalArticle','bookSection','conferencePaper'].include? item_type
+        create_sub_hash(key, 'rft.title')
+      end
+
+      def date
+        key = "date"
+        key = "issueDate" if item_type.eql? "patent"
+        create_sub_hash(key , 'rft.date')
+      end
+
+      def issn
+        issn = [params['rft.issn'], params['rft.eissn']].flatten.compact.uniq.reject(&:empty?)
+        create_formatted_sub_hash("issn", issn)
+      end
+
+      def author
+        first_name = params['rft.aufirst'].first&.strip
+        last_name = params['rft.aulast'].first&.strip
+
+        name = "#{last_name}," if last_name
+        name = "#{name} #{first_name}".strip
+
+        name = nil if name.empty?
+        output_name = name || params['rft.au'] || params['rft.creator']
+
+        if first_name and last_name
+          return create_formatted_sub_hash("author", [output_name,output_name])
+        end
+        create_formatted_sub_hash("author", output_name)
+      end
+
+      def inventor
+        first_name = params['rft.invfirst'].first
+        last_name = params['rft.invlast'].first
+        name = Citero::Utils::NameFormatter.new("#{first_name} #{last_name}")
+        output_name = name.to_standardized || params['rft.inventor']
+        create_formatted_sub_hash("author", output_name)
+      end
+
+      def authors
+        authors = ['rft.au', 'rft.creator', 'rft.addau'].collect{|key| params[key]}.flatten.collect(&:to_s)
+        authors.reject!(&:empty?)
+        create_formatted_sub_hash('author',  authors ) unless authors.empty?
+      end
+
+      def isbn
+        create_sub_hash("isbn", 'rft.isbn')
+      end
+
+      def publisher
+        publisher = [params['rft.pub'], params['rft.publisher']].flatten
+        create_formatted_sub_hash("publisher", publisher)
+      end
+
+
+      def thesis_elements
+        hash = []
+        hash << create_sub_hash("publisher", "rft.inst")
+        hash << create_sub_hash("type", "rft.degree")
+        merged = hash.compact.reduce({}, :merge)
+        return nil if merged.empty?
+        merged
+      end
+
+      def patent_elements
+        hash = []
+        hash << create_sub_hash("assignee", "rft.assignee")
+        hash << create_sub_hash("patentNumber", "rft.number")
+        hash << create_sub_hash("date", "rft.appldate")
+        merged = hash.compact.reduce({}, :merge)
+        return nil if merged.empty?
+        merged
+      end
+
+      def webpage_elements
+        hash = []
+        hash << create_sub_hash("abstractNote", "rft.description")
+        hash << create_sub_hash("rights", "rft.rights")
+        hash << create_sub_hash("language", "rft.language")
+        hash << create_sub_hash("tags", "rft.subject")
+        hash << create_sub_hash("itemType", "rft.type")
+        hash << create_sub_hash("publicationTitle", "rft.source")
+        unless params["rft.identifier"].empty?
+          identifier = params["rft.identifier"].first
+          hash << create_formatted_sub_hash("isbn",  (identifier - 'isbn').strip) if identifier.start_with? 'isbn'
+          hash << create_formatted_sub_hash("issn",  (identifier - 'issn').strip) if identifier.start_with? 'issn'
+          hash << create_formatted_sub_hash("doi", (identifier - 'urn:doi:').strip) if  identifier.start_with? 'urn:doi:'
+          hash << create_formatted_sub_hash("url", identifier.strip) if identifier.match /^https?:\/\/.*/
+        end
+        merged = hash.compact.reduce({}, :merge)
+        return nil if merged.empty?
+        merged
+      end
+
+    end
+  end
+end