citeproc-ruby 0.0.6 → 1.0.0

data/lib/citeproc.rb

@@ -1,100 +0,0 @@
-$:.unshift(File.dirname(__FILE__)) unless
-  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
-
-$KCODE = 'UTF-8' if RUBY_VERSION < '1.9.0' && $KCODE.nil?
-
-require 'open-uri'
-
-require 'logging'
-require 'nokogiri'
-require 'json'
-
-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 'support/compatibility'
-
-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'
-
-
-require 'plugins/formats/default'
-
-# Load filter and format plugins
-Dir.glob("#{File.expand_path('..', __FILE__)}/plugins/formats/*.rb").each do |format|
-  require format
-end
-
-
-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

@@ -1,57 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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

@@ -1,133 +0,0 @@
-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!(argument)
-    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

data/lib/citeproc/formatter.rb

@@ -1,38 +0,0 @@
-module CiteProc
-  
-  module Format
-    def self.default; CiteProc::Format::Default.new; end
-  end
-  
-  class Formatter
-  
-    def format(*args)
-      @format ||= CiteProc.default_format
-      args.empty? ? @format : apply(args[0], args[1])
-    end
-
-    def format=(format)
-      @format = Format.const_get(format.to_s.split(/[\s_-]+/).map(&:capitalize).join).new
-    rescue Exception => e
-      CiteProc.log :warn, "failed to set format to #{ format.inspect }", e
-    end
-    
-    def apply(input='', attributes={})
-      return input if attributes.nil? || input.nil? || input.empty?
-
-      format.input = input
-      
-      CSL::Nodes.formatting_attributes.each do |attribute|
-        method_id = ['set', attribute.gsub(/-/, '_')].join('_')
-        
-        if !attributes[attribute].nil? && format.respond_to?(method_id)
-          format.send(method_id, attributes[attribute])
-        end
-      end
-      
-      format.finalize
-    end
-  
-  end
-  
-end