citeproc-ruby 0.0.1

data/README.md

@@ -0,0 +1,78 @@
+CiteProc-Ruby
+=============
+
+CiteProc-Ruby is a CSL 1.0 ([Citation Style Language](http://citationstyles.org/))
+Processor written in Ruby.
+
+A word of caution: this release of CiteProc-Ruby is purely experimental; the API
+is not complete and liable to change frequently. This release is expected to
+work in Ruby version 1.9.2.
+
+
+Quickstart
+----------
+
+		$ [sudo] gem install citeproc-ruby
+		$ irb
+		>> require 'citeproc'
+		>> book = {
+			'author' => [{ 'given' => 'Edgar Allen', 'family' => 'Poe' }],
+			'title' => 'Poetry, Tales, and Selected Essays',
+			'type' => 'book',
+			'issued' => { 'date-parts' => [[1996]] },
+			'editor' => [{ 'family' => 'Quinn', 'given' => 'Patrick F.'}, { 'family' => 'Thompson', 'given' => 'G.R.' }],
+			'publisher' => 'Library of America',
+			'publisher-place' => 'New York'
+		}
+		>> CiteProc.process(book)
+		=> "Poe, E. A. (1996). Poetry, Tales, and Selected Essays.  (P. F. Quinn & G. R. Thompson, Eds.). New York: Library of America."
+		>> CiteProc.process(book, :format => :html)
+		=> "Poe, E. A. (1996). <i>Poetry, Tales, and Selected Essays</i>.  (P. F. Quinn &#38; G. R. Thompson, Eds.). New York: Library of America."
+		>> CiteProc.process(book, :mode => :citation)
+		=> ["(Poe, 1996)"]
+		>> CiteProc.process(book, :style => "https://github.com/citation-style-language/styles/raw/master/chicago-author-date.csl")
+		=> "Poe, Edgar Allen. 1996. Poetry, Tales, and Selected Essays. Ed. Patrick F. Quinn and G.R. Thompson. New York: Library of America."
+
+
+The RSpec examples are a valuable resource of usage examples.
+
+
+Credits
+-------
+
+CiteProc-Ruby was written by [Sylvester Keil](http://sylvester.keil.or.at);
+thanks to the excellent documentation and specifications of the
+[CSL](http://citationstyles.org), [citeproc-js](http://bitbucket.org/fbennett/citeproc-js/wiki/Home),
+the [citeproc-test suite](https://bitbucket.org/bdarcus/citeproc-test), and the
+kind feedback and support at the [xbiblio mailing list](http://sourceforge.net/mail/?group_id=117435).
+
+
+License
+-------
+
+Copyright 2009-2011 Sylvester Keil. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+ 1. Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+
+ 2. Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER ``AS IS'' AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+The views and conclusions contained in the software and documentation are
+those of the authors and should not be interpreted as representing official
+policies, either expressed or implied, of the copyright holder.

data/lib/citeproc.rb

@@ -0,0 +1,100 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'open-uri'
+
+require 'logging'
+require 'nokogiri'
+require 'json'
+
+#require 'activesupport'
+
+require 'unicode_utils/upcase'
+require 'unicode_utils/downcase'
+
+module CiteProc
+
+  @log = Logging.logger[self.name]
+  @log.add_appenders(Logging.appenders.stderr)
+  
+  @log.level = ENV.has_key?('DEBUG') ? :debug : :info
+  
+  class << self
+    def log(*args)
+      return @log if args.empty?
+      
+      level, message, exception = args
+      
+      @log.send(level, [message, exception && exception.message || nil].compact.join(': '))
+      @log.debug exception.backtrace[0,10].join("\n\t") unless exception.nil?
+    end
+  end
+  
+end
+
+# Load debugger
+require 'ruby-debug'
+Debugger.start
+
+require 'extensions/core'
+require 'support/attributes'
+require 'support/tree'
+
+require 'csl/node'
+require 'csl/term'
+require 'csl/locale'
+require 'csl/nodes'
+require 'csl/sort'
+require 'csl/renderer'
+require 'csl/style'
+
+require 'citeproc/version'
+require 'citeproc/variable'
+require 'citeproc/name'
+require 'citeproc/date'
+require 'citeproc/data'
+require 'citeproc/selector'
+require 'citeproc/item'
+require 'citeproc/bibliography'
+require 'citeproc/formatter'
+require 'citeproc/processor'
+
+# Load filter and format plugins
+Dir.glob("#{File.expand_path('..', __FILE__)}/plugins/formats/*.rb").each do |format|
+  require format
+end
+
+require 'plugins/formats/default'
+
+Dir.glob("#{File.expand_path('..', __FILE__)}/plugins/filters/*.rb").each do |format|
+  require format
+end
+
+
+# Top-level CSL utility functions
+
+module CiteProc
+
+  module_function
+  
+  def default_format; Format.default; end
+
+  def process(*arguments, &block); Processor.process(*arguments, &block); end
+  
+end
+
+module CSL
+  
+  module_function
+  
+  def default_locale
+    Locale.new(Locale.default)
+  end
+  
+  def default_style
+    Style.new(Style.default)
+  end
+  
+  def process(*arguments, &block); CiteProc.process(*arguments, &block); end
+  
+end

data/lib/citeproc/bibliography.rb

@@ -0,0 +1,57 @@
+module CiteProc
+  
+  # A bibliography is an array of bibliographic entries and, optionally,
+  # a list of errors. The bibliography should be format agnostic; it is
+  # simply encapsulates two lists.
+  class Bibliography
+    
+    def initialize(*args)
+      args.each { |argument| parse_argument(argument) }
+      
+      yield self if block_given?
+    end
+
+    def data; @data ||= []; end
+    def errors; @errors ||= []; end
+    def options; @options ||= {}; end
+
+    # @data proxy
+    [:[], :[]=, :<<, :map, :each, :empty?, :push, :pop, :unshift, :+, :concat].each do |method_id|
+      define_method method_id do |*args, &block|
+        @data.send(method_id, *args, &block)
+      end
+    end
+
+    def to_json
+      [options.merge('bibliography-errors' => errors), data].to_json
+    end
+    
+    def to_s
+      [options['bibstart'] || '<div class="csl-bib-body">', data.map { |d| "  <div class=\"csl-entry\">#{d}</div>" }, options['bibend'] || '</div>'].flatten.join("\n")
+    end
+    
+    protected
+    
+    def parse_argument(argument)
+      case
+      when argument.is_a?(String)
+        parse_argument(JSON.parse(argument))
+      when argument.is_a?(Hash)
+        parse_attributes(argument)
+      when argument.is_a?(Array) && argument.length == 2 && argument[0].is_a?(Hash) && argument[1].is_a?(Array)
+        parse_attributes(argument[0])
+        @data = argument[1]
+      when argument.is_a?(Array)
+        @data = argument
+      else
+        CiteProc.log.warn "failed to initialize Bibliography from argument #{ argument.inspect }." unless argument.nil?
+      end
+    end
+    
+    def parse_attributes(attributes)
+      @errors = attributes.delete('bibliography-errors') || []
+      @options = {}.merge(attributes)
+    end
+    
+  end
+end

data/lib/citeproc/data.rb

@@ -0,0 +1,149 @@
+module CiteProc
+
+
+  # == CiteProc::Data
+  #
+  # A minimal citation data object, used as input by both the
+  # processCitationCluster() and appendCitationCluster() command, has the
+  # following form:
+  #
+  # {
+  #    "citationItems": [ { "id": "ITEM-1" } ],
+  #    "properties": {"noteIndex": 1 }
+  # }
+  #
+  # The citationItems array is a list of one or more citation item objects,
+  # each containing an id used to retrieve the bibliographic details of the
+  # target resource. A citation item object may contain one or more
+  # additional optional values:
+  #
+  # * locator: a string identifying a page number or other pinpoint location
+  #   or range within the resource;
+  # * label: a label type, indicating whether the locator is to a page, a
+  #   chapter, or other subdivision of the target resource. Valid labels are
+  #   defined in the link CSL specification.
+  # * suppress-author: if true, author names will not be included in the
+  #   citation output for this cite;
+  # * author-only: if true, only the author name will be included in the
+  #   citation output for this cite -- this optional parameter provides a
+  #   means for certain demanding styles that require the processor output
+  #   to be divided between the main text and a footnote.
+  # * prefix: a string to print before this cite item;
+  # * suffix: a string to print after this cite item.
+  #
+  # In the properties portion of a citation, the noteIndex value indicates
+  # the footnote number in which the citation is located within the
+  # document. Citations within the main text of the document have a
+  # noteIndex of zero.
+  #
+  # The processor will add a number of data items to a citation during
+  # processing. Values added at the top level of the citation structure
+  # include:
+  #
+  # * citationID: A unique ID assigned to the citation, for internal use by
+  #   the processor. This ID may be assigned by the calling application, but
+  #   it must uniquely identify the citation, and it must not be changed
+  #   during processing or during an editing session.
+  # * sortedItems: This is an array of citation objects and accompanying
+  #   bibliographic data objects, sorted as required by the configured
+  #   style. Calling applications should not need to access the data in this
+  #   array directly.
+  #
+  # Values added to individual citation item objects may include:
+  #
+  # * sortkeys: an array of sort keys used by the processor to produce the
+  #   sorted list in sortedItems. Calling applications should not need to
+  #   touch this array directly.
+  # * position: an integer flag that indicates whether the cite item should
+  #   be rendered as a first reference, an immediately-following reference
+  #   (i.e. ibid), an immediately-following reference with locator
+  #   information, or a subsequent reference.
+  # * first-reference-note-number: the number of the noteIndex of the first
+  #   reference to this resource in the document.
+  # * near-note: a boolean flag indicating whether another reference to this
+  #   resource can be found within a specific number of notes, counting back
+  #   from the current position. What is "near" in this sense is
+  #   style-dependent.
+  # * unsorted: a boolean flag indicating whether sorting imposed by the
+  #   style should be suspended for this citation. When true, cites are
+  #   rendered in the order in which they are presented in citationItems.
+  #
+  class CitationData
+    include Support::Attributes
+    
+    attr_fields %w{ citation-id citation-items properites sorted-items }
+
+    
+    def initialize(attributes={})
+
+      self.key_filter = Hash.new do |hash, key|
+        hash[key] = key.to_s.gsub(/([[:lower:]])([[:upper:]])/, '\1-\2').downcase
+      end
+
+      merge!(attributes)
+      
+      yield self if block_given?
+    end
+    
+    # @returns a list of citation data
+    def self.parse(argument)
+      return [] if argument.nil?
+      argument = [argument] unless argument.kind_of?(Array)
+      argument.map { |d| CitationData.new(d) }
+    end
+    
+    #
+    # Merges the argument into the citation data. The argument can be a list
+    # of citation items (hashes), a single citation item (hash), another
+    # citation data instance or hash, or a single id of a citation item.
+    #
+    def merge!(argument)
+      case
+      when argument.is_a?(Array) && argument.map(&:class).uniq == [Hash]
+        super('citation-items' => argument.map { |argument| Item.new(argument) })
+        
+      when argument.is_a?(Array) && (argument.empty? || argument.map(&:class).uniq == [Item])
+        super('citation-items' => argument)
+
+      when argument.is_a?(Hash)
+        argument.has_key?('id') ? super('citation-items' => [Item.new(argument)]) : super(argument)
+        
+      when argument.is_a?(String) || argument.is_a?(Symbol)
+        super('citation-items' => [{ 'id' => argument.to_s }])
+
+      when argument.is_a?(CitationData)
+        super(argument.attributes)
+
+      else
+        raise(ArgumentError, "unable to merge #{argument.inspect} into citation data")
+      end
+    end
+    
+    def citation_items
+      attributes['citation-items'] ||= []
+    end
+    
+    def populate!(items)
+      citation_items.each { |item| item.reverse_merge!(items[item.id.to_s]) }
+      self
+    end
+    
+    def properties
+      self.attributes['properties'] ||= {}
+    end
+    
+    [[:items, :citation_items], [:id, :citation_id]].each do |a, m|
+      alias_method a, m
+      alias_method "#{a}=", "#{m}="
+      alias_method "#{a}?", "#{m}?"
+    end
+    
+    [:each, :map, :empty?, :first, :last, :sort].each do |method_id|
+      define_method method_id do |*args, &block|
+        self.items.send(method_id, *args, &block)
+      end
+    end
+    
+  end
+  
+end

data/lib/citeproc/date.rb

@@ -0,0 +1,133 @@
+require 'date'
+
+module CiteProc
+
+
+  # == Date Variables
+  #
+  # Date objects wrap an underlying JavaScript object, within which the
+  # "date-parts" element is a nested JavaScript array containing a start date
+  # and optional end date, each of which consists of a year, an optional month
+  # and an optional day, in that order if present. Additionally, the string
+  # fields "season", "literal", as well as the boolean field "circa" are
+  # supported. 
+  #
+  class Date < Variable
+
+    attr_fields %w{ date-parts season circa literal }
+
+    Variable.date_fields.each { |field| Variable.types[field] = Date }
+
+    [:year, :month, :day].each_with_index do |method_id, index|
+      define_method method_id do
+        date_parts[0].nil? ? nil : date_parts[0][index]
+      end
+      
+      define_method [method_id, '='].join do |value|
+        date_parts[0] = [] if date_parts[0].nil?
+        date_parts[0][index] = value.to_i
+      end
+    end
+        
+    def defaults
+      Hash['delimiter', '-']
+    end
+    
+    def parse!(argument)
+      return super unless argument.is_a?(::Date) || argument.is_a?(String)
+      parse_date!(date)
+    end
+    
+    def merge!(argument)
+      case
+      when argument.has_key?('raw')
+        parse_date!(argument.delete('raw'))
+        argument.delete('date-parts')
+      when argument.has_key?('date-parts')
+        argument['date-parts'].map! { |parts| parts.map(&:to_i)  }
+      end
+      super
+    end
+    
+    def parse_date!(date)
+      # TODO find out what the Ruby parser can do
+      date = ::Date.parse(date) unless date.is_a?(::Date)
+      date_parts[0] = [date.year, date.month, date.day]
+      self
+    end
+    
+    def date_parts
+      attributes['date-parts'] ||= []
+    end
+    
+    alias :parts :date_parts
+    alias :parts= :date_parts=
+    
+    def range?
+      parts[1] && !parts[1].empty?
+    end
+    
+    def open_range?
+      self.range? && parts[1].uniq == [0]
+    end
+        
+    def uncertain!; self['circa'] = true; end
+    
+    def bc?; year && year < 0; end
+    def ad?; !bc? && year < 1000; end
+    
+    alias :uncertain? :circa?
+    
+    def from
+      parts[0] || []
+    end
+    
+    def to
+      Date.new('date-parts' => [parts[1] || []])
+    end
+    
+    # @returns a value in 0..3 depending on how many of the date parts in the
+    # range match.
+    def range_match
+      parts[0].zip(parts[1] || []).take_while { |p| p[0] == p[1] }.length
+    end
+    
+    def display_parts
+      rm = range_match
+
+      case
+      when !range? || open_range?
+         [%w{day month year}, []]
+      when rm == 1
+        [%w{day month}, %w{day month year} ]
+      when rm == 2
+        [%w{day}, %w{day month year} ]
+      else
+        [%w{day month year}, %w{day month year} ]
+      end
+    end
+    
+    def display(options={})
+      options = defaults.merge(options)
+      from.compact.join(options['delimiter'])
+    end
+    
+    def to_s
+      literal || attributes.inspect
+    end
+
+    def value; self; end
+    
+    def numeric?; false; end
+    
+    def sort_order
+      "%04d%02d%02d-%04d%02d%02d" % ((parts[0] + [0,0,0])[0,3] + ((parts[1] || []) + [0,0,0])[0,3])
+    end
+        
+    def <=>(other)
+      return nil unless other.is_a?(Date)
+      [year, sort_order] <=> [other.year, other.sort_order]
+    end
+  end
+  
+end