citero 1.0.0.alpha

data/lib/citero/outputs/easybib.rb

@@ -0,0 +1,203 @@
+module Citero
+  module Outputs
+    class EasyBib
+      require 'json'
+      def initialize(csf)
+        @csf = csf.csf
+      end
+
+      def to_easybib
+        JSON.generate(create_json)
+      end
+
+      private
+
+      def create_json
+        hashes =[
+          bib_source(@csf["itemType"]),
+          item_object(@csf["itemType"]),
+          pubtype(@csf["itemType"]),
+          main,
+          contributors
+        ]
+        hashes.reduce({},:merge)
+      end
+
+      def bib_source(type)
+        { source: get_type(type) }
+      end
+
+      def item_object(type)
+        { "#{get_type(type)}": title }
+      end
+
+      def title
+        @title ||= { title: @csf['title']  }
+      end
+
+      def pubtype(type)
+        { pubtype: { main: get_pub_type(type) } }
+      end
+
+      def main()
+        { "#{@pub_type}": send(@pub_type.to_sym)  }
+      end
+
+      def pubnonperiodical
+        start = {}
+        start = title if @csf['title']
+        start.merge(construct_json({
+          publisher: "publisher",
+          city: "place",
+          vol: "volume",
+          edition: "edition"
+        })).merge(errata)
+      end
+
+      def pubmagazine
+        title.merge(construct_json({vol: "volume"})).merge(errata)
+      end
+
+      def pubnewspaper
+        title.merge(construct_json({
+              edition: "edition",
+              section: "section",
+              city: "place"
+            })).merge(errata)
+      end
+
+      def pubjournal
+        title.merge(construct_json({
+            issue: "issue",
+              vol: "volume",
+              series: "series"})).merge(errata)
+      end
+
+      def pubonline
+        title.merge(construct_json({
+          inst: "institution",
+          year:"date",
+          url:"url",
+          dayaccessed:"accessDate"
+        }))
+      end
+
+      def pages
+        pages_hash = {}
+        if @csf["numPages"]
+          if @csf["firstPage"]
+            pages_hash = { end: @csf["firstPage"].to_i + @csf["numPages"].to_i }
+          end
+        else
+          if @csf["numPages"]
+            pages_hash = { end: @csf["numPages"].to_i }
+          end
+        end
+        pages_hash.merge(construct_json({ start: "firstPage"}))
+      end
+
+      def errata
+        construct_json({
+          year: "date",
+          start: "firstPage"
+        }).merge(pages)
+      end
+
+      def construct_json(hash)
+        hashes = []
+        hash.each do |key, value|
+          hashes << { "#{key}": @csf[value] } if @csf[value]
+        end
+        hashes.reduce({},:merge)
+      end
+
+      def contributors
+        { contributors: get_contributor_array }
+      end
+
+
+      def get_type(type)
+        return type_map[type.to_sym] if type_map.include?(type.to_sym)
+        return 'book'
+      end
+
+      def get_pub_type(type)
+        @pub_type ||= pub_type_map.include?(type.to_sym) ? pub_type_map[type.to_sym] : 'pubnonperiodical'
+      end
+
+      def author_contributors
+        ['author', 'inventor', 'contributor']
+      end
+
+      def editor_contributors
+        ['editor', 'seriesEditor']
+      end
+
+      def translator_contributors
+        ['translator']
+      end
+
+      def all_contributors
+        [author_contributors, editor_contributors, translator_contributors].flatten
+      end
+
+      def get_csf_contributor_array(contributor_type)
+        [@csf[contributor_type]].compact.flatten
+      end
+
+      def get_contributor_symbol(param)
+        return :author     if author_contributors.include?(param)
+        return :editor     if editor_contributors.include?(param)
+        return :translator if translator_contributors.include?(param)
+      end
+
+      def get_contributor_array
+        contributor_array = []
+        all_contributors.each do |contrib|
+          get_csf_contributor_array(contrib).each do |cont|
+            contributor_array << add_contributor(get_contributor_symbol(contrib), cont)
+          end
+        end
+        contributor_array
+      end
+
+      def add_contributor(contributor_symbol,raw_name)
+        name = Citero::Utils::NameFormatter.new(raw_name)
+        hashes = []
+        hashes << { function: contributor_symbol }
+        hashes << { first: name.first_name } if name.first_name
+        hashes << { middle: name.middle_name } if name.middle_name
+        hashes << { last: name.last_name } if name.last_name
+        hashes.reduce({},:merge)
+      end
+
+      def pub_type_map
+        @pub_type_map ||= {
+           magazineArticle: 'pubmagazine',
+          newspaperArticle: 'pubnewspaper',
+            journalArticle: 'pubjournal',
+                   journal: 'pubjournal',
+                   webpage: 'pubonline'
+        }
+      end
+
+      def type_map
+        @type_map ||= {
+                   journal: 'journal',
+                    report: 'report',
+                  blogPost: 'blog',
+               bookSection: 'chapter',
+           conferencePaper: 'conference',
+                    thesis: 'dissertation',
+            videoRecording: 'film',
+            journalArticle: 'journal',
+           magazineArticle: 'magazine',
+          newspaperArticle: 'newspaper',
+                   artwork: 'painting',
+           computerProgram: 'software',
+                   webpage: 'website'
+        }
+      end
+    end
+  end
+end

data/lib/citero/outputs/openurl.rb

@@ -0,0 +1,199 @@
+module Citero
+  module Outputs
+    class OpenUrl
+      require 'open-uri'
+      require "erb"
+      require "cgi"
+      def initialize(csf)
+        @csf = csf.csf
+      end
+
+      def to_openurl
+        output = ""
+        output_methods.each do |method_sym|
+          output += send(method_sym)
+        end
+        output.chop if output[-1].eql? "&"
+      end
+
+      private
+
+      def openurl_param(key,value, with_prefix = true, encoded = true)
+        output = ""
+        return output if value.nil?
+        key = "rft.#{key}" if with_prefix
+        if value.is_a?(Array)
+          value.each do |val|
+            val = CGI::escape(val) if encoded
+            output += "#{key}=#{val}&"
+          end
+        else
+          value = CGI::escape(value) if encoded
+          output += "#{key}=#{value}&"
+        end
+        output
+      end
+
+      def output_start
+        output = ""
+        output += openurl_param("ulr_ver", "Z39.88-2004")
+        output += openurl_param("ctx_ver", "Z39.88-2004")
+        if @csf['pnxRecordId']
+          output += openurl_param("rfr_id", "info:sid/primo.exlibrisgroup.com:primo-#{@csf['pnxRecordId']}", false, false)
+        else
+          output += openurl_param("rfr_id", "info:sid/libraries.nyu.edu:citero", false, false)
+        end
+      end
+
+      def output_doi
+        openurl_param('rft_id=info:doi/', @csf['doi'])
+      end
+
+      def output_isbn
+        openurl_param('rft_id=info:isbn/', @csf['isbn'])
+      end
+
+      def output_type
+        if type_output_map[@csf['itemType']]
+          str = openurl_param('rft_val_fmlt', type_output_map[@csf['itemType']], false, false)
+          str += openurl_param('genre', genre_output_map[@csf['itemType']]) if genre_output_map[@csf['itemType']]
+          str
+        else
+          openurl_param('rft_val_fmlt', "info:ofi/fmt:kev:mtx:book", false, false) + openurl_param('genre', "book")
+        end
+      end
+
+      def output_date
+        openurl_param('date', @csf['date'])
+      end
+
+      def output_title
+        openurl_param('title', @csf['title'])
+      end
+
+      def output_author
+        openurl_param('au', @csf['author'])
+      end
+
+      def output_bookTitle
+        openurl_param('btitle', @csf['bookTitle'])
+      end
+
+      def output_publicationTitle
+        openurl_param('jtitle', @csf['publicationTitle'])
+      end
+
+      def output_edition
+        openurl_param('edition', @csf['edition'])
+      end
+
+      def output_contributor
+        openurl_param('contributor', @csf['contributor'])
+      end
+
+      def output_assignee
+        openurl_param('assignee', @csf['assignee'])
+      end
+
+      def output_volume
+        openurl_param('volume', @csf['volume'])
+      end
+
+      def output_reportNumber
+        openurl_param('volume', @csf['reportNumber'])
+      end
+
+      def output_issue
+        openurl_param('issue', @csf['issue'])
+      end
+
+      def output_patentNumber
+        openurl_param('number', @csf['patentNumber'])
+      end
+
+      def output_publisher
+        openurl_param('publisher', @csf['publisher'])
+      end
+
+      def output_place
+        openurl_param('place', @csf['place'])
+      end
+
+      def output_abstractNote
+        openurl_param('description', @csf['abstractNote'])
+      end
+
+      def output_startPage
+        openurl_param('spage', @csf['startPage'])
+      end
+
+      def output_endPage
+        openurl_param('epage', @csf['endPage'])
+      end
+
+      def output_numPages
+        openurl_param('tpages', @csf['numPages'])
+      end
+
+      def output_issn
+        openurl_param('issn', @csf['issn'])
+      end
+
+      def output_tags
+        openurl_param('subject', @csf['tags'])
+      end
+
+      def type_output_map
+        @type_output_map ||= {
+          "bookSection"       => "info:ofi/fmt:kev:mtx:book",
+          "journalArticle"    => "info:ofi/fmt:kev:mtx:journal",
+          "thesis"            => "info:ofi/fmt:kev:mtx:dissertation",
+          "patent"            => "info:ofi/fmt:kev:mtx:patent",
+          "webpage"           => "info:ofi/fmt:kev:mtx:dc"
+        }
+      end
+
+      def genre_output_map
+        @genre_output_map ||= {
+          "bookSection"       => "bookitem",
+          "conferencePaper"   => "conference",
+          "report"            => "report",
+          "document"          => "document",
+          "journalArticle"    => "article",
+          "thesis"            => "dissertation",
+          "patent"            => "patent"
+        }
+      end
+
+      def output_methods
+        @output_methods ||= [
+          :output_start,
+          :output_doi,
+          :output_isbn,
+          :output_type,
+          :output_date,
+          :output_title,
+          :output_author,
+          :output_bookTitle,
+          :output_publicationTitle,
+          :output_edition,
+          :output_contributor,
+          :output_assignee,
+          :output_volume,
+          :output_reportNumber,
+          :output_issue,
+          :output_patentNumber,
+          :output_publisher,
+          :output_place,
+          :output_abstractNote,
+          :output_startPage,
+          :output_endPage,
+          :output_numPages,
+          :output_isbn,
+          :output_issn,
+          :output_tags
+        ]
+      end
+    end
+  end
+end

data/lib/citero/outputs/refworks_tagged.rb

@@ -0,0 +1,52 @@
+module Citero
+  module Outputs
+    class RefworksTagged < Ris
+      def initialize(csf)
+        super(csf)
+        @csf = csf.csf
+      end
+
+      def to_refworks_tagged
+        ris = to_ris
+        output = ""
+        ris.each_line do |line|
+          output = "#{output}#{ris_to_refworks_tagged(line)}"
+        end
+        output
+      end
+
+      private
+
+      def ris_to_refworks_tagged(line)
+        key,val = line.split('-',2).collect {|x| x.strip }
+        key = tag_map[key] if tag_map[key]
+        val = type_map[val] if key.eql?('RT')
+        "#{key} #{val}\n"
+      end
+
+      def tag_map
+        @tag_map ||= {
+          'TY' => 'RT',
+          'CY' => 'PP',
+          'DP' => 'DS',
+          'ET' => 'ED',
+          'KW' => 'K1',
+          'N1' => 'NO',
+          'PY' => 'YR',
+          'TI' => 'T1'
+        }
+      end
+
+      def type_map
+        @type_map ||= {
+          'JOUR' => 'Journal Article',
+          'THES' => 'Dissertation',
+          'BOOK' => 'Book, whole',
+          'RPRT' => 'Report',
+          'CHAP' => 'Book, section',
+          'ELEC' => 'Webpage'
+        }
+      end
+    end
+  end
+end