citero 1.0.0.alpha

data/lib/citero/inputs/pnx.rb

@@ -0,0 +1,137 @@
+module Citero
+  module Inputs
+    class Pnx
+
+      attr_reader :csf
+
+      def initialize(raw_data)
+        @pnx_reader = Citero::Inputs::Readers::PnxReader.new(raw_data)
+        construct_csf
+        @csf
+      end
+
+      private
+
+      def construct_csf
+        return @csf unless @csf.nil?
+        @csf = CSF.new
+        @hash = {}
+        add_item_type
+        parse_and_add_creators
+        parse_and_add_publisher
+        pages
+        add_identifiers
+        add_all_other_fields
+        @hash['importedFrom'] = 'PNX'
+        @csf.load_from_hash(@hash)
+      end
+
+
+      def item_type_conversion_hash
+        @item_type_conversion_hash ||= {
+          "audio"   =>    "audioRecording",
+          "video"   =>    "videoRecording",
+          "article" =>    "journalArticle",
+          "books"   =>    "book",
+          "book"    =>    "book",
+          "report"  =>    "report",
+          "webpage" =>    "webpage",
+          "journal" =>    "journal",
+          "map"     =>    "map",
+          "thesis"  =>    "thesis"
+        }
+      end
+
+      def get_item_type(raw_type)
+        return item_type_conversion_hash[raw_type.downcase] if item_type_conversion_hash.include? raw_type.downcase
+        return 'document'
+      end
+
+      def add_item_type
+        @hash["itemType"] = get_item_type(@pnx_reader.type || '')
+      end
+
+      def parse_and_add_creators
+        contributors = []
+
+        creators = @pnx_reader.creator || @pnx_reader.contributor
+        contributors = @pnx_reader.contributor if !@pnx_reader.creator.nil?
+
+        creators = @pnx_reader.addau if (@pnx_reader.creator.to_s.empty? && @pnx_reader.contributor.to_s.empty?)
+        add_creators(creators, "author")
+        add_creators(contributors, "contributor")
+      end
+
+      def add_creators(creators,creator_type)
+        if (creators && !creators.empty?)
+          creators.split(";").each do |name|
+            @hash[creator_type] = [@hash[creator_type], name.strip].flatten.compact
+          end
+        end
+      end
+
+      def add_identifiers
+        if @pnx_reader.identifier?
+          identifiers =  @pnx_reader.identifier.split(";")
+          identifiers.each do |id|
+            if(id.include? "isbn")
+              @hash['isbn'] = [@hash['isbn'], id.scan(/[0-9]+/).to_a.join].flatten.compact
+            else
+              @hash['issn'] = [@hash['issn'], id.scan(/[0-9]+/).to_a.join].flatten.compact
+            end
+          end
+        else
+          @hash['eissn'] = @pnx_reader.eissn unless @pnx_reader.eissn.empty?
+          @hash['issn'] = [@hash['issn'], @pnx_reader.issn].flatten.compact unless @pnx_reader.issn.empty?
+          @hash['isbn'] = [@hash['isbn'], @pnx_reader.isbn].flatten.compact unless @pnx_reader.isbn.empty?
+        end
+      end
+
+      def parse_and_add_publisher
+        if (@pnx_reader.pub.empty? && @pnx_reader.cop.empty? && @pnx_reader.publisher)
+          if @pnx_reader.publisher.include? " : "
+            pub_place =  @pnx_reader.publisher.split(" : ",2).map(&:strip)
+            add_publisher_and_place(nil, pub_place.first)
+          else
+            add_publisher_and_place(@pnx_reader.publisher)
+          end
+        else
+          add_publisher_and_place(@pnx_reader.pub, @pnx_reader.cop)
+        end
+      end
+
+      def add_publisher_and_place(publisher = nil, place = nil)
+        @hash['publisher'] = publisher if publisher
+        @hash['place'] = place if place
+      end
+
+      def pages
+        return unless @pnx_reader.pages
+        raw_pages = @pnx_reader.pages.gsub(/[\(\)\[\]]/, "").gsub(/\D/, " ").strip()
+        @hash['numPages'] = raw_pages.split(" ").first unless raw_pages.empty?
+      end
+
+      def qualified_method_names
+        @qualified_method_names ||= {
+          "title" => "title",
+          "publicationDate" => "publication_date",
+          "journalTitle" => "journal_title",
+          "date" => "date",
+          "language" => "language",
+          "edition" => "edition",
+          "tags" => "tags",
+          "callNumber" => "call_number",
+          "pnxRecordId" => "pnx_record_id",
+          "description" => "description",
+          "notes" => "notes"
+        }
+      end
+
+      def add_all_other_fields
+        qualified_method_names.each do |standard_form, method_name|
+          @hash[standard_form] = @pnx_reader.send(method_name.to_sym) if @pnx_reader.send("#{method_name}?".to_sym)
+        end
+      end
+    end
+  end
+end

data/lib/citero/inputs/readers.rb

@@ -0,0 +1,7 @@
+module Citero
+  module Inputs
+    module Readers
+      require_relative 'readers/pnx_reader'
+    end
+  end
+end

data/lib/citero/inputs/readers/pnx_reader.rb

@@ -0,0 +1,151 @@
+module Citero
+  module Inputs
+    module Readers
+      class PnxReader
+        require 'ox'
+
+        XML_DECLARATION_START = "<?xml"
+        XML_DECLARATION = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
+
+        def initialize(data)
+          Ox.default_options = Ox.default_options.merge({ skip: :skip_none })
+          parse_data = data
+          parse_data = "#{XML_DECLARATION}#{data}" unless data.start_with?(XML_DECLARATION_START)
+          @data = Ox.parse(parse_data)
+        end
+
+        def type
+          @type ||=           get_value_from_pnx("record/display/type")
+        end
+
+        def publisher
+          @publisher =        get_value_from_pnx("record/display/publisher")
+        end
+
+        def language
+          @language ||=       get_value_from_pnx("record/display/language")
+        end
+
+        def edition
+          @edition ||=        get_value_from_pnx("record/display/edition")
+        end
+
+        def pages
+          @pages ||=          get_value_from_pnx("record/display/format")
+        end
+
+        def identifier
+          @identifier ||=     get_value_from_pnx("record/display/identifier")
+        end
+
+        def creator
+          @creator ||=        get_value_from_pnx("record/display/creator")
+        end
+
+        def addau
+          @addau ||=          get_value_from_pnx("record/addata/addau")
+        end
+
+        def contributor
+          @contributor ||=    get_value_from_pnx("record/display/contributor")
+        end
+
+        def call_number
+          @call_number ||=    get_value_from_pnx("record/enrichment/classificationlcc")
+        end
+
+        def pnx_record_id
+          @pnx_record_id ||=  get_value_from_pnx("record/control/recordid")
+        end
+
+        def description
+          @description ||=    get_value_from_pnx("record/display/format")
+        end
+
+        def pub
+          @publisher ||=            get_all_values_from_pnx("record/addata/pub"    )
+        end
+
+        def cop
+          @place_of_publication ||= get_all_values_from_pnx("record/addata/cop"    )
+        end
+
+        def issn
+          @issn ||=                 get_all_values_from_pnx("record/addata/issn"   )
+        end
+
+        def eissn
+          @eissn ||=                get_all_values_from_pnx("record/addata/eissn"  )
+        end
+
+        def isbn
+          @isbn ||=                 get_all_values_from_pnx("record/addata/isbn"   )
+        end
+
+        def title
+          @title ||=                get_all_values_from_pnx("record/display/title" )
+        end
+
+        def journal_title
+          @journal_title ||=        get_all_values_from_pnx("record/addata/jtitle" )
+        end
+
+        def publication_date
+          @publication_date ||= [@data.locate("record/addata/date")].flatten.collect {|d| d&.nodes}.flatten
+        end
+
+        def date
+          @date ||= [@data.locate("record/display/creationdate") , @data.locate("record/search/creationdate")].flatten.collect {|d| d&.nodes}.flatten
+        end
+
+        def tags
+          @tags ||= [
+            @data.locate("record/search/subject")&.collect {|element| element&.nodes}.flatten,
+            @data.locate("record/display/subject")&.collect {|element| element&.nodes}.flatten
+          ].flatten
+          return @tags unless @tags.empty?
+        end
+
+        def notes
+          notes = @data.locate("record/display/description").collect{ |element|
+            element = element.nodes while !element.is_a?(Array)
+            element.collect{|val| val.is_a?(String) ? val : val.value }
+          }.flatten
+
+          @notes ||= notes
+        end
+
+        private
+
+        def get_value_from_pnx(path)
+          @data.locate(path)&.first&.text
+        end
+
+        def get_all_values_from_pnx(path)
+          @data.locate(path).flatten.collect(&:text)
+        end
+
+        def method_missing(method_sym, *arguments, &block)
+          method_str = method_sym.to_s
+          if is_attribute_validator?(method_sym)
+            !send(method_str.chomp('?').to_sym).nil?
+          else
+            super
+          end
+        end
+
+        def respond_to?(method_sym, include_private = false)
+          if is_attribute_validator?(method_sym)
+            true
+          else
+            super
+          end
+        end
+
+        def is_attribute_validator?(method_sym)
+          method_sym.to_s[-1].eql?('?')
+        end
+      end
+    end
+  end
+end

data/lib/citero/outputs.rb

@@ -0,0 +1,9 @@
+module Citero
+  module Outputs
+    require_relative 'outputs/ris'
+    require_relative 'outputs/openurl'
+    require_relative 'outputs/bibtex'
+    require_relative 'outputs/easybib'
+    require_relative 'outputs/refworks_tagged'
+  end
+end

data/lib/citero/outputs/bibtex.rb

@@ -0,0 +1,174 @@
+module Citero
+  module Outputs
+    class Bibtex
+      def initialize(csf)
+        @csf = csf.csf
+      end
+
+      def to_bibtex
+        "@#{bibtex_type}{#{cite_key}#{bibtex_fields}\n}"
+      end
+
+      def bibtex_type
+        export_type_map[@csf['itemType']] || 'misc'
+      end
+
+      def cite_key
+        [cite_key_author, cite_key_title, cite_key_date].compact.join('_')
+      end
+
+      def bibtex_fields
+        start = [""]
+        start << creators unless creators.empty?
+        start << publisher
+        export_field_map.each do |key,value|
+          start << map_to_bibtex_value(value,key)
+        end
+        start << note
+        start << tags
+        start << publicationTitle
+        start << pages
+        start << webpage
+        start.compact.join(",\n\t")
+      end
+
+      def publisher
+        return map_to_bibtex_value("publisher","school") if @csf['itemType'].eql?("thesis")
+        return map_to_bibtex_value("report","institution") if @csf['itemType'].eql?("report")
+        map_to_bibtex_value("publisher","publisher")
+      end
+
+      # TODO gotta concat these tags
+      def note
+        map_to_bibtex_value('annote', 'note')
+      end
+
+      def tags
+        map_to_bibtex_value('keywords', 'tags')
+      end
+
+      def publicationTitle
+        if ['bookSection', 'conferencePaper'].include? @csf['itemType']
+          map_to_bibtex_value('booktitle', 'publicationTitle')
+        else
+          map_to_bibtex_value('journal', 'publicationTitle')
+        end
+      end
+
+      def join_names(name)
+        [name].flatten.collect do |name|
+          Citero::Utils::NameFormatter.new(name).to_standardized
+        end.join(' and ')
+      end
+
+      def creators
+        ['author', 'inventor', 'contributor', 'editor',
+          'seriesEditor', 'translator'].collect do |creator|
+            name = join_names(@csf[creator])
+            creator = 'editor' if creator.eql?('seriesEditor')
+            add_to_bibtex_output(creator, name)
+        end.compact
+      end
+
+      def pages
+        add_to_bibtex_output('pages', @csf['pages']&.gsub("-", "--"))
+        add_to_bibtex_output('numPages', @csf['numPages']&.gsub(",", "\\,"))
+      end
+
+      def webpage
+        # Gotta see what this is supposed to be..
+        add_to_bibtex_output('howpublished','website') if @csf['itemType'].eql? 'webpage'
+      end
+
+      def expects_number_value?(key,value)
+        (/\A[-+]?\d+\z/ === value) && !['numPages','isbn','issn'].include?(key)
+      end
+
+      def add_to_bibtex_output(key,value)
+        return if value.nil? || !value.class.eql?(Array) && value.strip.empty?
+        value = value.join(', ') if value.class.eql?(Array)
+        output = "#{key} = "
+        value = "{#{value}}" unless expects_number_value?(key,value)
+        output = "#{output}#{value}"
+      end
+
+      def map_to_bibtex_value(key,csf_key)
+        value = @csf[csf_key]
+        add_to_bibtex_output(key,value)
+      end
+
+      def cite_key_author_last_name(name)
+        name = name.first if name.is_a? Array
+        Citero::Utils::NameFormatter.new(name).last_name&.downcase
+      end
+
+      def cite_key_author
+        cite_key_author_last_name(@csf['author']) || cite_key_author_last_name(@csf['contributor'])
+      end
+
+      def cite_key_title_first_non_stop_word(title)
+        title = title.first if title.is_a? Array
+        title&.downcase&.gsub(/^((a+|the+|on+)\s)+/,"")&.split(" ")&.first
+      end
+
+      def cite_key_title
+        cite_key_title_first_non_stop_word(@csf["title"])
+      end
+
+      def cite_key_date
+        @csf['date']&.first&.gsub(/[^0-9]/,'') || "????"
+      end
+
+      def export_type_map
+        @export_type_map ||= {
+          "book"              => "book",
+          "bookSection"       => "incollection",
+          "journalArticle"    => "article",
+          "magazineArticle"   => "article",
+          "newspaperArticle"  => "article",
+          "thesis"            => "phdthesis",
+          "manuscript"        => "unpublished",
+          "patent"            => "patent",
+          "letter"            => "misc",
+          "interview"         => "misc",
+          "film"              => "misc",
+          "artwork"           => "misc",
+          "webpage"           => "misc",
+          "conferencePaper"   => "inproceedings",
+          "report"            => "techreport"
+        }
+      end
+
+      def export_field_map
+        @export_field_map ||= {
+          "attachments"     => "file",
+          "extra"           => "note",
+          "accessDate"      => "urldate",
+          "reportNumber"    => "number",
+          "seriesNumber"    => "number",
+          "patentNumber"    => "number",
+          "issue"           => "number",
+          "place"           => "address",
+          "section"         => "chapter",
+          "rights"          => "copyright",
+          "isbn"            => "isbn",
+          "issn"            => "issn",
+          "title"           => "title",
+          "date"            => "date",
+          "callNumber"      => "iccn",
+          "archiveLocation" => "location",
+          "shortTitle"      => "shorttitle",
+          "doi"             => "doi",
+          "abstractNote"    => "abstract",
+          "country"         => "nationality",
+          "edition"         => "edition",
+          "language"        => "language",
+          "type"            => "type",
+          "series"          => "series",
+          "volume"          => "volume",
+          "assignee"        => "assignee"
+        }
+      end
+    end
+  end
+end