citeproc-ruby 0.0.1

data/lib/csl/renderer.rb

@@ -0,0 +1,88 @@
+module CSL
+  
+  # Represents a cs:citation or cs:bibliography element.
+  class Renderer < Node
+    
+    attr_fields Nodes.inheritable_name_attributes
+    attr_fields %w{ delimiter-precedes-et-al }
+
+    attr_reader :layout, :style
+  
+    def initialize(*args, &block)
+      @style = args.detect { |argument| argument.is_a?(Style) }
+      args.delete(@style) unless @style.nil?
+      @parent = @style
+      
+      args.each do |argument|
+        case          
+        when argument.is_a?(String) && argument.match(/^\s*</)
+          parse(Nokogiri::XML.parse(argument) { |config| config.strict.noblanks }.root)
+        
+        when argument.is_a?(Nokogiri::XML::Node)
+          parse(argument)
+        
+        when argument.is_a?(Hash)
+          merge!(argument)
+        
+        else
+          CiteProc.log.warn "failed to initialize Renderer from argument #{ argument.inspect }" unless argument.nil?
+        end
+      end
+
+      set_defaults
+      
+      yield self if block_given?
+    end
+
+    def sort(data, processor)
+      sort = find_children_by_name('sort').first
+      sort.nil? ? data : sort.apply(data, processor)
+    end
+    
+    def parse(node)
+      @layout = Nodes.parse(node.at_css('layout'), style)
+      add_children(Node.parse(node.at_css('sort')))
+    end
+  
+    def render(data, processor=nil)
+      # TODO add support for one-off processor instance
+      processor.format(process(data, processor).join(delimiter), attributes)
+    rescue Exception => e
+      CiteProc.log :error, "failed to render data #{ data.inspect }", e
+    end  
+      
+    def process(data, processor)
+      sort(data, processor).map do |item|
+        [item['prefix'], @layout.process(item, processor), item['suffix']].compact.join(' ')
+      end
+    end
+    
+    protected
+    
+    def set_defaults
+    end
+    
+  end
+
+  class Bibliography < Renderer
+    attr_fields %w{ hanging-indent second-field-align line-spacing
+      entry-spacing subsequent-author-substitute }
+      
+  end
+
+  class Citation < Renderer
+    attr_fields %w{ collapse year-suffix-delimiter after-collapse-delimiter
+      near-note-distance disambiguate-add-names disambiguate-add-given-name
+      given-name-disambiguation-rule disambiguate-add-year-suffix }
+    
+    attr_fields %w{ delimiter suffix prefix }
+    
+    def initialize(*arguments, &block)
+      super
+      %w{ delimiter suffix prefix }.each do |attribute|
+        self[attribute] = @layout.attributes.delete(attribute)
+      end
+    end
+    
+  end
+end

data/lib/csl/sort.rb

@@ -0,0 +1,53 @@
+module CSL
+  
+  class Sort < Node
+    attr_children 'key'
+
+    alias :keys :key
+    
+    def sort(items, processor)
+      items.sort do |a,b|
+        comparison = 0
+        keys.each do |key|
+          this, that = key.convert(a, processor), key.convert(b, processor)
+
+          comparison = this <=> that
+          comparison = comparison * -1 if comparison && key.descending?
+
+          comparison = comparison ? comparison : that.nil? ? -1 : 1
+        
+          break unless comparison.zero?
+        end
+        
+        comparison
+      end
+    end
+    
+    alias :apply :sort
+    
+  end
+  
+  class Key < Node
+    attr_fields %w{ variable macro sort names-min names-use-first names-use-last }
+    
+    def convert(item, processor)
+      case
+      when has_variable?
+        item[variable]
+      when has_macro?
+        processor.style.macros[macro].process(item, processor)
+      else
+        CiteProc.log.warn "sort key #{ inspect } contains no variable or macro definition."
+        item
+      end
+    end
+    
+    def ascending?; !descending?; end
+    
+    def descending?
+      has_sort? && sort == 'descending'
+    end
+    
+  end
+  
+end

data/lib/csl/style.rb

@@ -0,0 +1,110 @@
+module CSL
+
+  # class StyleOptions < Node
+  #   attr_fields %w{ punctuation-in-quote }
+  # end
+  # 
+  # class Info < Node
+  # end
+  
+  
+  class Style < Node
+
+    @schema = File.expand_path('../../resource/schema/csl.rnc', __FILE__)
+    @path = File.expand_path('../../../resource/style', __FILE__)
+    @default = 'apa'
+    
+    class << self; attr_accessor :path, :schema, :default; end
+    
+    def initialize(style=nil)
+      open(style || Style.default)
+    end
+    
+    # @param style A CSL stream, a file, the name of Style in the local repository, or an URI
+    def open(style)
+      @attributes = {}
+      doc = Nokogiri::XML(locate(style)) { |config| config.strict.noblanks }
+
+      [:citation, :bibliography].each do |element|
+        @attributes[element] ||= CSL.const_get(element.to_s.capitalize).new(doc.at_css("style > #{element}"), self)
+      end
+
+      @attributes[:locales] = doc.css('style > locale').map { |locale| Locale.new(locale) }
+
+      @attributes[:info] = Hash[*doc.at_css('style > info').children.map { |node| [node.name.downcase, node.content] }.flatten]
+      @attributes[:options] = Hash[doc.root.attributes.values.map { |a| [a.name, a.value] }]
+      @attributes[:macros] = Hash[doc.css('style > macro').map { |m| [m[:name], Nodes::Macro.new(m, self)] } ]
+      
+      self
+    end
+    
+    # Returns the CSL Relax NG schema defintion.
+    def schema
+      @attributes[:schema] ||= Nokogiri::XML::RelaxNG(File.open(Style.schema))
+    end
+    
+    
+    # Validates the current style's source document against the CSL defintion.
+    def validate
+      [] # schema.validate(@doc)
+    end
+    
+    # Returns true if the current style's source document conforms to the CSL definition.
+    def valid?
+      validate.empty?
+    end
+
+    # Updates the current style using the URI returned by #link.
+    def update!
+      open(link)
+    end
+    
+    def options
+      @attributes[:options] ||= {}
+    end
+    
+    def [](key)
+      options[key.to_s]
+    end
+    
+    def info
+      @attributes[:info]
+    end
+
+    [:title, :id].each do |method_id|
+      define_method method_id do
+        @attributes[method_id] ||= info[method_id.to_s]
+      end
+    end
+    
+    [:info, :macros, :citation, :bibliography].each do |method_id|
+      define_method method_id do; @attributes[method_id]; end
+    end
+    
+    alias :macro macros
+    
+    # @returns the style's locales.
+    def locales(language = nil, region = nil)
+      @attributes[:locales].select { |lc| lc.language.nil? || language.nil? || lc.language == language }.sort(&Locale.sort(language, region))
+    end
+    
+    def link
+      @attributes[:link] ||= info.at_css('link')['href']
+    end
+    
+    
+    private
+    
+    def locate(resource)
+      resource = resource.to_s
+      return resource if resource.match(/^\s*<(\?xml|style)/)
+      return File.read(resource) if File.exists?(resource)
+      
+      local = File.join(Style.path, "#{resource}.csl")
+      return File.read(local) if File.exists?(local)
+
+      Kernel.open(resource)
+    end
+  end
+    
+end

data/lib/csl/term.rb

@@ -0,0 +1,124 @@
+module CSL
+  
+  # == Term
+  #
+  # Terms are localized strings. For example, if a style specifies that the
+  # term "and" should be used, the string that appears in the style output
+  # depends on the locale: "and" for English, "und" for German. Terms are
+  # defined using cs:term elements, child elements of cs:terms, itself a child
+  # element of cs:locale. Terms are identified by the value of the name
+  # attribute of cs:term. Two types of terms exist: simple terms, where the
+  # content of the cs:term is the localized string, and compound terms, where
+  # cs:term includes the two child elements cs:single and cs:multiple, which
+  # respectively contain the singular and plural variant of the term (e.g.
+  # "page" and "pages"). Some terms are defined for multiple forms. In these
+  # cases, multiple cs:term element share the same value of name, but differ
+  # in the value of the optional form attribute. The different forms are:
+  #
+  # * "long" - the default, e.g. "editor" and "editors" for the term "editor"
+  # * "short" - e.g. "ed" and "eds" for the term "editor"
+  # * "verb" - e.g. "edited by" for the term "editor"
+  # * "verb-short" - e.g. "ed" for the term "editor"
+  # * "symbol" - e.g. "§" for the term "section"
+  #  
+  # The plural attribute can be set to choose either the singular (value
+  # "false", the default) or plural variant (value "true") of a term. In
+  # addition, the form attribute can be set to select the desired term form
+  # ("long" [default], "short", "verb", "verb-short" or "symbol"). If for a
+  # given term the desired form does not exist, another form may be used:
+  # "verb-short" reverts to "verb", "symbol" reverts to "short", and "verb"
+  # and "short" both revert to "long".
+  #
+  class Term
+    include Support::Attributes
+
+    attr_fields %w{ name long short verb verb-short symbol gender feminine
+      masculine neutral }
+    
+    def initialize(argument=nil, &block)
+      case
+      when argument.nil?
+
+      when argument.is_a?(Hash)
+        merge!(argument)
+      
+      when argument.is_a?(Nokogiri::XML::Node)
+        parse!(argument)
+        
+      when argument.is_a?(String) && argument.match(/^<term/)
+        parse!(Nokogiri::XML.parse(argument).root)
+      
+      when argument.is_a?(String) || argument.is_a?(Symbol)
+        attributes['name'] = argument.to_s
+      
+      else
+        CiteProc.log.warn "failed to create new Term from #{ argument.inspect }"
+        
+      end
+      
+      yield self if block_given?
+    end
+      
+    
+    # @returns a hash containing all the terms in the given document
+    def self.build(doc=nil)
+      terms = Hash.new { |h,k| h[k] = Term.new(k) }
+      doc.css('terms term').each { |term| terms[term['name']].parse!(term) } unless doc.nil?
+
+      terms
+    end
+    
+    def parse!(node)
+      raise(ArgumentError, "failed to parse node; expected <term>, was: #{ node.inspect }") unless node.name == 'term'
+      
+      self['name'] = node['name']
+      self['gender'] = node['gender']
+      self[node['form'] || node['gender-form'] || 'long'] = Hash[%w{ singular plural }.zip(node.children.map(&:content))]
+      
+    end
+    
+    def singularize(options={})
+      options['plural'] = 'false'
+      to_s(options)
+    end
+
+    def pluralize(options={})
+      options['plural'] = 'true'
+      to_s(options)
+    end
+    
+    def to_s(options={})
+      plural = ['', 'false', '1', 'never'].include?(options['plural'].to_s) ? false : true
+
+      term = case options['form']
+        when 'verb-short' then verb_short || verb || long
+        when 'symbol'     then symbol || short || long
+        when 'verb'       then verb || long
+        when 'short'      then short || long
+        else
+          self[options['form']] || self[options['gender-form']] || long || masculine || feminine || neutral
+      end || {}
+      
+      plural && !term['plural'].nil? ? term['plural'].to_s : term['singular'].to_s
+    rescue Exception => e
+      CiteProc.log.error "failed to convert Term to String: #{ e.message }"
+      ''
+    end
+    
+    def empty?
+      long.nil? && short.nil? && verb.nil? && verb_short.nil? && symbol.nil?
+    end
+    
+    def has_gender?
+      !gender.nil?
+    end
+    
+    %w{ masculine feminine neutral }.each do |gender|
+      define_method "#{gender}?" do
+        self['gender'] == gender
+      end
+    end
+    
+  end
+  
+end

data/lib/extensions/core.rb

@@ -0,0 +1,43 @@
+
+# ---------- Open Class ----------
+
+module Kernel
+  alias :is_an? :is_a? unless defined?(is_an?)
+end
+
+
+# ---------- Extensions ----------
+
+module Extensions
+  module Core
+  
+    module Numbers
+      MAX_ROMAN = 4999
+      FACTORS = [["M", 1000], ["CM", 900], ["D", 500], ["CD", 400],
+      ["C",  100], ["XC",  90], ["L",  50], ["XL",  40],
+      ["X",   10], ["IX",   9], ["V",   5], ["IV",   4],
+      ["I",    1]]
+
+      # Returns roman equivalent of the integer
+      # This function is featured in the pickaxe book
+      def romanize
+        num = self.to_i
+        roman = ""
+        unless num < 1 || num > MAX_ROMAN
+          for code, factor in FACTORS
+            count, num = num.divmod(factor)
+            roman << (code * count)
+          end
+        end
+        roman.downcase
+      end
+
+    end
+  end
+end
+
+# ---------- Include extensions ----------
+
+class Fixnum
+  include Extensions::Core::Numbers
+end

data/lib/plugins/filters/bibtex.rb

@@ -0,0 +1,12 @@
+CiteProc::Variable.filters[:bibtex] = (Hash.new { |h, k| k }).merge(Hash[*%w{
+  date      issued
+  isbn      ISBN
+  booktitle container-title
+  journal   container-title
+  series    collection-title
+  address   publisher-place
+  pages     page
+  number    issue
+  url       URL
+  doi       DOI
+}])

data/lib/plugins/formats/default.rb

@@ -0,0 +1,134 @@
+module CiteProc
+
+  module Format
+
+    class Default
+
+      attr_reader :input
+      
+      Token = Struct.new :content, :annotations, :styles
+      AffixFilter = /([\.,\s!?()])/
+      
+      def initialize
+        reset
+      end
+      
+      def name; "CiteProc default style (plain text)"; end
+      
+      def reset
+        @styles = {}
+        @tokens = []
+        @affixes = [nil, nil]
+      end
+      
+      def input=(input)
+        reset
+        @tokens = input.split(/(<span[^>]*>[^<]*<\/span>)/).map do |t|
+          token = Token.new
+          
+          if t.match(/^<span(?:\s+class=['"]([\w\s]*)["'])?>([^<]*)<\/span>$/)
+            token.content = $2 || ''
+            token.annotations = $1.split(/\s+/)
+          else
+            token = Token.new
+            token.content = t
+            token.annotations = []
+          end
+          
+          token
+        end
+      end
+      
+      def finalize
+        [prefix, @tokens.map(&:content).join, suffix].compact.join
+      end
+      
+      def prefix
+        return nil if @affixes[0].nil?
+        @affixes[0].match(/([\.;:!?\s])$/) && @tokens.first.content.start_with?($1) ? @affixes[0].sub(/\.$/, '') : @affixes[0]
+      end
+
+      def suffix
+        return nil if @affixes[1].nil?
+        @affixes[1].match(/^([\.;:!?\s])/) && @tokens.last.content.end_with?($1) ? @affixes[1].sub(/^\./, '') : @affixes[1]
+      end
+            
+      def set_prefix(prefix)
+        @affixes[0] = prefix
+      end
+
+      def set_suffix(suffix)
+        @affixes[1] = suffix
+      end
+      
+      # @param display 'block', 'left-margin', 'right-inline', 'inline'
+      def set_display(display)
+        @styles['display'] = display || 'inline'
+      end
+      
+      def set_strip_periods(strip)
+        @tokens.each { |token| token.content = token.content.gsub(/\.+/, ' ').squeeze(' ').gsub(/^\s+|\s+$/, '') } if strip == 'true'
+      end
+            
+      # @param style 'normal', 'italic', 'oblique' 
+      def set_font_style(style)
+        @styles['font-style'] = style || 'normal'
+      end
+      
+      # @param variant 'normal', 'small-caps'
+      def set_font_variant(variant)
+        @styles['font-variant'] = variant || 'normal'
+      end
+   
+      # @param weight 'normal', 'bold', 'light' 
+      def set_font_weight(weight)
+        @styles['font-weight'] = weight || 'normal'
+      end
+
+      # @param decoration 'none', 'underline'
+      def set_text_decoration(decoration)
+        @styles['text-decoration'] = decoration || 'none'
+      end
+
+      # @param align 'baseline', 'sub', 'sup' 
+      def set_vertical_align(align)
+        @styles['vertical-align'] = align || 'baseline'
+      end
+
+      # @param case 'lowercase', 'uppercase', 'capitalize-first', 'capitalize-all', 'title', 'sentence'
+      def set_text_case(text_case)
+
+        # note: the nocase annotations does not override lowercase and uppercase
+        
+        case text_case
+        when 'lowercase'
+          @tokens.each { |token| token.content = UnicodeUtils ? UnicodeUtils.downcase(token.content) : token.content.downcase }
+          
+        when 'uppercase'
+          @tokens.each { |token| token.content = UnicodeUtils ? UnicodeUtils.upcase(token.content) : token.content.upcase }
+          
+        when 'capitalize-first'
+          token = @tokens.detect { |token| !token.annotations.include?('nocase') }
+          token.content.sub!(/^./) { UnicodeUtils ? UnicodeUtils.upcase($&) : $&.upcase }
+          
+        when 'capitalize-all'
+          # @tokens.each { |token| token.content.gsub!(/\b\w/) { $&.upcase } unless token.annotations.include?('nocase') }
+          @tokens.each { |token| token.content = token.content.split(/(\s+)/).map(&:capitalize).join unless token.annotations.include?('nocase') }
+          
+        # TODO exact specification?
+        when 'title'
+          @tokens.each { |token| token.content = token.content.split(/(\s+)/).map { |w| w.match(/^(and|of|a|an|the)$/i) ? w : w.gsub(/\b\w/) { UnicodeUtils ? UnicodeUtils.upcase($&) : $&.upcase } }.join.sub(/^(\w)/) {$&.upcase} unless token.annotations.include?('nocase') }
+
+        # TODO exact specification?
+        when 'sentence'
+          @tokens.each { |token| token.content.capitalize! unless token.annotations.include?('nocase') }
+
+        else
+          # nothing
+        end
+      end
+
+    end
+    
+  end
+end