citeproc-rb 0.0.1

data/lib/citeproc/filters/csl_citation/csl_citation_input_filter.rb

@@ -0,0 +1,274 @@
+#  == Synopsis
+#
+#  Resolves CSL variables to a simple Citation model.
+#
+#  == Author
+#
+#  Liam Magee
+#
+#  == Copyright
+#
+#  Copyright (c) 2007, Liam Magee.
+#  Licensed under the same terms as Ruby - see http://www.ruby-lang.org/en/LICENSE.txt.
+#
+
+module CSL
+  class CslInputFilter < Citeproc::InputFilter
+    
+    
+    # Loads the citations from +source+, based on the content_type passed in the +params+.
+    def load_citations(source, params)
+      io = source.read
+      content_type = params[:content_type]
+
+      # Load the citations from the specified content type
+      case content_type.downcase
+      when "yaml"
+        require 'yaml'
+        results = YAML.load(io)
+      when "json"
+        require 'json'
+        results = JSON.parse(io)
+      else
+        raise RuntimeError.new("Unsupported content-type: " + content_type.inspect + ". Must be either YAML or JSON.")
+      end
+
+      results.each do |key, value|
+        citation = load_citation_from_hash(value)
+        @citations[key] = citation
+      end if results
+    end
+    
+    
+    
+    # Loads an individual citation from the +hash+ object
+    def load_citation_from_hash(hash)
+      citation = Citation.new
+      # Much easier, but requires active_support (sudo gem install active_support --include-dependencies)
+      # Overkill for just this method?
+      if require "active_support"
+        hash.each do |k, v|
+          citation.send("#{k.underscore}=", v)
+        end
+      # Long hand... potentially incomplete
+      else
+        citation.type = hash[:type.to_s]
+        citation.title = hash[:title.to_s]
+        citation.container_title = hash[:containerTitle.to_s]
+        citation.collection_title = hash[:collectionTitle.to_s]
+        citation.date_issued = hash[:dateIssued.to_s]
+        citation.date_accessed = hash[:dateAccessed.to_s]
+        citation.publisher = hash[:publisher.to_s]
+        citation.publisher_place = hash[:publisherPlace.to_s]
+        citation.issue = hash[:issue.to_s]
+        citation.url = hash[:url.to_s]
+        citation.pages = hash[:pages.to_s]
+        citation.authors = hash[:authors.to_s]
+        citation.editors = hash[:editors.to_s]
+      end
+      citation
+    end
+    
+    
+
+    def extract_contributor(role, sort_key = nil)
+      contributors = @current_citation.contributors(role, sort_key)
+      contributors.each do |contrib|
+        yield contrib
+      end
+    end
+    
+    
+    
+    # Tests the document class, and returns the corresponding CSL type
+    def resolve_type
+      @current_citation.type
+    end
+    
+    def extract_date(variable)
+      case variable
+      when "issued"
+        convert_date(@current_citation.date_issued)
+      when "event" # Kludgy way of handling event - treat as presentation
+        # @current_citation.presented_at.time.start if @current_citation.presented_at and @current_citation.presented_at.time
+      when "accessed"
+        convert_date(@current_citation.date_accessed)
+      when "container"
+        # @current_citation.belongs_to.date if @current_citation.belongs_to
+      end
+    end
+    
+    def convert_date(date)
+      if date
+        date = date + "-01-01" if date.length == 4
+        Date.parse(date)
+      end
+    end
+    
+
+    # Very simple check on the value of the locator (or, in specific cases, of other document
+    # variables) to determine whether 
+    # It may be be better to simply return the locator value here
+    def extract_label(variable)
+      singular = true
+      if variable == 'page'
+        singlular = (@current_citation.pages and @current_citation.pages.include?('-'))
+        locator_type = variable
+      else
+        locator_type = @current_citation.locator_type
+        case @current_citation.locator_type
+        when 'issue'
+          singlular = (@current_citation.issue and @current_citation.issue.include?('-'))
+        when 'page'
+          singlular = (@current_citation.pages and @current_citation.pages.include?('-'))
+        when 'volume'
+          singlular = (@current_citation.volume and @current_citation.volume.include?('-'))
+        else 
+          singlular = (@current_citation.locator and @current_citation.locator.include?('-'))
+        end
+      end
+      return locator_type,  singular
+    end
+
+
+    
+    def extract_variable(variable)
+      case variable
+    
+      ## the primary title for the cited item
+      when 'author'
+        @current_citation.authors
+    
+      when 'editor'
+        @current_citation.editors
+    
+      ## the primary title for the cited item
+      when 'title'
+        @current_citation.title
+
+      ## the secondary title for the cited item; for a book chapter, this 
+      ## would be a book title, for an article the journal title, etc.
+      when 'container-title'
+        @current_citation.container_title
+
+      ## the tertiary title for the cited item; for example, a series title
+      when 'collection-title'
+        @current_citation.collection_title
+
+      ## title of a related original version; often useful in cases of translation
+      when "original-title"
+        @current_citation.title
+
+      ## the name of the publisher
+      when "publisher"
+        @current_citation.publisher
+
+      ## the location of the publisher
+      when "publisher-place"
+        @current_citation.publisher_place
+
+      ## the name of the archive
+      when "archive"
+        # @current_citation.title
+
+      ## the location of the archive
+      when "archive-place"
+        # @current_citation.title
+
+      ## the location within an archival collection (for example, box and folder)
+      when "archive_location"
+        # @current_citation.title
+
+      ## the name or title of a related event such as a conference or hearing
+      when "event"
+        # @current_citation.presented_at.name if @current_citation.presented_at
+
+      ## the location or place for the related event
+      when "event-place"
+        # @current_citation.presented_at.place.name if @current_citation.presented_at and @current_citation.presented_at.place
+
+      ##
+      when "page"
+        @current_citation.pages
+
+      ## a description to locate an item within some larger container or 
+      ## collection; a volume or issue number is a kind of locator, for example.
+      when "locator"
+        @current_citation.locator
+
+      ## version description
+      when "version"
+        @current_citation.version
+
+      ## volume number for the container periodical
+      when "volume"
+        @current_citation.volume
+
+      ## refers to the number of items in multi-volume books and such
+      when "number-of-volumes"
+        # ??
+
+      ## the issue number for the container publication
+      when "issue"
+        @current_citation.issue
+
+      ##
+      when "chapter-number"
+        @current_citation.number
+
+      ## medium description (DVD, CD, etc.)
+      when "medium"
+        @current_citation.format 
+
+      ## the (typically publication) status of an item; for example "forthcoming"
+      when "status"
+        @current_citation.status
+
+      ## an edition description
+      when "edition"
+        @current_citation.edition
+
+      ##
+      when "genre"
+        @current_citation.genre
+
+      ## a short inline note, often used to refer to additional details of the resource
+      when "note"
+        @current_citation.note
+
+      ## notes made by a reader about the content of the resource
+      when "annote"
+        @current_citation.annote
+
+      ##
+      when "abstract"
+        @current_citation.abstract
+
+      ##
+      when "keyword"
+        @current_citation.keyword
+
+      ## a document number; useful for reports and such
+      when "number"
+        @current_citation.number
+
+      ##
+      when "URL"
+        @current_citation.uri
+
+      ##
+      when "DOI"
+        @current_citation.doi
+
+      ##
+      when "ISBN"
+        @current_citation.isbn10
+        
+        
+      else
+        extract_date(variable)
+      end
+      
+    end
+  end
+end

data/lib/citeproc/formatters/base_formatter.rb

@@ -0,0 +1,115 @@
+#  == Synopsis
+#
+#  Formats a series of document references according to a given CSL style.
+#
+#  == Author
+#
+#  Liam Magee
+#
+#  == Copyright
+#
+#  Copyright (c) 2008, Liam Magee.
+#  Licensed under the same terms as Ruby - see http://www.ruby-lang.org/en/LICENSE.txt.
+#
+ 
+module Citeproc
+  
+  class BaseFormatter
+    def format(node)
+      result = ''
+      if node.is_a?(Array)
+        node.each do |n|
+          tmp = format(n)
+          if tmp
+            result << tmp
+            result << "\n"
+          end
+        end
+      elsif node
+        a = ''
+        b = []
+        a << delimit_node(node.element, node.results)
+        node.children.compact.each{|c| b << format(c) } 
+        a << delimit_node(node.element, b)
+
+        result = format_node(node.element, a)
+      end
+      result
+    end
+    
+
+  private
+
+    def format_node(formatter, text)
+      return text if !formatter.is_a?(Formatting)
+      return '' if !text or text.empty?
+      results = ''
+      
+      results << formatter.prefix if formatter.prefix and !text.start_with?(formatter.prefix)
+      results << '"' if formatter.quotes
+ 
+      # Add the actual text
+      results << format_text(text, formatter.text_case)
+      
+      results << '"' if formatter.quotes
+      results << formatter.suffix if formatter.suffix and !text.end_with?(formatter.suffix)
+
+      results
+    end
+
+    # The following performs direct text changes - should be toggled off for mark-up?
+    #lowercase, uppercase, capitalize-first, capitalize-all, title, sentence.
+    def format_text(text, textcase)
+      case textcase
+      when "lowercase"
+        text.downcase!
+      when "uppercase"
+        text.upcase!
+      when "capitalize-first"
+        text[0] = text[0..0].upcase
+        # Need to separate out these cases
+      when "capitalize-all", "title", "sentence"
+        # Tries a simple exclusion of common words from title capitalisation
+        # Suffers from a lack of internationalisation...
+        text = text.split(' ').collect{|t| 
+          t.capitalize unless t == text.split(' ')[0] and ['and', 'the', 'a', 'of', 'by', 'to', 'at'].include?(t) 
+        }.join(' ')
+      end
+      text
+    end
+    
+    
+    def delimit_node(node, elements)
+      results = ""
+      clean = elements.compact.reject{|e| e if e.to_s.strip.empty?}
+      len = clean.length - 1
+      delim = node.is_a?(Delimiter)
+      (0..len).each do |i|
+        case i
+        when 0
+        # Do nothing
+        when len 
+          if delim
+            if node.delimiter_precedes_last and node.delimiter_precedes_last == "never"
+              # Still do nothing
+            elsif delim and node.delimiter
+              results << node.delimiter
+            end
+            if node.and == "text"
+              results.strip!
+              results << " and "
+            elsif node.and == "symbol"
+              results.strip!
+              results << " & "
+            end
+          end
+        else
+          results << node.delimiter if delim and node.delimiter
+        end
+        # Finally, add the content
+        results << clean[i].to_s
+      end
+      results
+    end
+  end
+end

data/lib/citeproc/formatters/xhtml_formatter.rb

@@ -0,0 +1,144 @@
+#  == Synopsis
+#
+#  Formats a series of document references according to a given CSL style.
+#
+#  == Author
+#
+#  Liam Magee
+#
+#  == Copyright
+#
+#  Copyright (c) 2008, Liam Magee.
+#  Licensed under the same terms as Ruby - see http://www.ruby-lang.org/en/LICENSE.txt.
+#
+ 
+module Citeproc
+  
+  class XhtmlFormatter
+    
+    def format(node)
+      result = ''
+      if node.is_a?(Array)
+        node.each do |n|
+          tmp = format(n)
+          if tmp
+            result << "<div>"
+            result << tmp
+            result << "</div>\n"
+          end
+        end
+      elsif node
+        a = ''
+        b = []
+        a << delimit_node(node.element, node.results)
+        node.children.compact.each{|c| b << format(c) } 
+        a << delimit_node(node.element, b)
+
+        result = format_node(node.element, a)
+      end
+      result
+    end
+    
+
+  private
+
+    def format_node(formatter, text)
+      return text if !formatter.is_a?(Formatting)
+      return '' if !text or text.empty?
+      results = ''
+			
+      text_content = format_text(text, formatter.text_case)
+      already_spanned = text_content.starts_with?("<span") and text_content.ends_with?("</span>")
+
+      
+      if !already_spanned
+        # Note: these attributes should only apply to certain kinds of formatters, i.e. those based on mark-up 
+        results << '<span' # Could be block/inline/div - needs to be conditional on both 'display' attribute and mark-up variant (XHTML, XSL-FO)
+        style = ''			
+        style << "font-family: #{formatter.font_family}; " if formatter.font_family
+        style << "font-style: #{formatter.font_style}; " if formatter.font_style
+        style << "font-variant: #{formatter.font_variant}; " if formatter.font_variant
+        style << "font-weight: #{formatter.font_weight}; " if formatter.font_weight
+        style << "text-decoration: #{formatter.text_decoration}; " if formatter.text_decoration
+        style << "text-transform: #{formatter.text_transform}; " if formatter.text_transform
+        style << "vertical-align: #{formatter.vertical_align}; " if formatter.vertical_align
+        style << "enforce-case: #{formatter.enforce_case}; " if formatter.enforce_case
+        display = formatter.formatting[:display.to_s]
+        style << "display: #{display}; " if display
+        style << "quotes: #{formatter.quotes}; " if formatter.quotes 
+        results << %Q' style="#{style}"' if !style.empty?
+        results << ">"
+      end
+
+      results << formatter.prefix if formatter.prefix and !text.start_with?(formatter.prefix)
+      results << '"' if formatter.quotes
+ 
+      # Add the actual text
+      results << text_content
+      
+      results << '"' if formatter.quotes
+      results << formatter.suffix if formatter.suffix and !text.end_with?(formatter.suffix)
+      
+			if !already_spanned
+	      results << "</span>"
+			end
+
+      results
+    end
+
+    # The following performs direct text changes - should be toggled off for mark-up?
+    #lowercase, uppercase, capitalize-first, capitalize-all, title, sentence.
+    def format_text(text, textcase)
+      case textcase
+      when "lowercase"
+        text.downcase!
+      when "uppercase"
+        text.upcase!
+      when "capitalize-first"
+        text[0] = text[0..0].upcase
+        # Need to separate out these cases
+      when "capitalize-all", "title", "sentence"
+        # Tries a simple exclusion of common words from title capitalisation
+        # Suffers from a lack of internationalisation...
+        text = text.split(' ').collect{|t| 
+          t.capitalize unless t == text.split(' ')[0] and ['and', 'the', 'a', 'of', 'by', 'to', 'at'].include?(t) 
+        }.join(' ')
+      end
+      text
+    end
+    
+    
+    def delimit_node(node, elements)
+      results = ""
+      clean = elements.compact.reject{|e| e if e.to_s.strip.empty?}
+      len = clean.length - 1
+      delim = node.is_a?(Delimiter)
+      (0..len).each do |i|
+        case i
+        when 0
+        # Do nothing
+        when len 
+          if delim
+            if node.delimiter_precedes_last and node.delimiter_precedes_last == "never"
+              # Still do nothing
+            elsif delim and node.delimiter
+              results << node.delimiter
+            end
+            if node.and == "text"
+              results.strip!
+              results << " and "
+            elsif node.and == "symbol"
+              results.strip!
+              results << " &amp; "
+            end
+          end
+        else
+          results << node.delimiter if delim and node.delimiter
+        end
+        # Finally, add the content
+        results << clean[i].to_s
+      end
+      results
+    end
+  end
+end