citeproc-ruby 0.0.6 → 1.0.0

data/lib/citeproc/selector.rb

@@ -1,61 +0,0 @@
-module CiteProc
-
-  class Selector
-    include Support::Attributes
-    
-    attr_fields :select, :include, :exclude, :quash
-    
-    
-    def initialize(argument = {})
-      key_filter['all'] = 'select'
-      key_filter['any'] = 'include'
-      key_filter['none'] = 'exclude'
-      key_filter['skip'] = 'quash'
-      
-      merge(normalize(argument))
-    end
-    
-    def type
-      attributes.keys.detect { |k| [:select, :include, :exclude].include?(k.to_sym) }
-    end
-    
-    # @returns one of :all?, :any?, :none?
-    def matcher
-      type == 'include' ? :any? : type == 'exclude' ? :none? : :all?
-    end
-    
-    def conditions
-      attributes[type] || []
-    end
-
-    def matches?(item)
-      conditions.send(matcher) { |condition| match(item, condition) }
-    end
-    
-    def skip?(item)
-      has_quash? && quash.all? { |condition| match(item, condition) }
-    end
-        
-    def to_proc
-      Proc.new { |item| matches?(item) && !skip?(item) }
-    end
-        
-    protected
-    
-    def match(item, condition)
-      values, expected = [item[condition['field']]].flatten.map(&:to_s), [condition['value']].flatten
-      expected & values != []
-    end
-    
-    def normalize(argument)
-      case
-      when [String, Symbol].include?(argument.class) && !(argument.to_s =~ /^\s*\{/)
-        { argument.to_s => [] }
-      else
-        argument
-      end
-    end
-    
-  end
-
-end

data/lib/citeproc/variable.rb

@@ -1,82 +0,0 @@
-require 'forwardable'
-
-module CiteProc
-    
-  class Variable
-    extend Forwardable
-    
-    include Support::Attributes
-    include Comparable
-
-    @date_fields = %w{ accessed container event-date issued original-date }
-
-    @name_fields = %w{
-      author editor translator recipient interviewer publisher composer
-      original-publisher original-author container-author collection-editor }
-
-    @text_fields = %w{
-      id abstract annote archive archive-location archive-place authority
-      call-number chapter-number citation-label citation-number collection-title
-      container-title DOI edition event event-place first-reference-note-number
-      genre ISBN issue jurisdiction keyword locator medium note number
-      number-of-pages number-of-volumes original-publisher original-publisher-place
-      original-title page page-first publisher publisher-place references
-      section status title URL version volume year-suffix }
-
-    @filters = Hash.new
-    
-    @types = Hash.new(Variable)
-
-    attr_fields :value
-    
-    def_delegators :value, :empty?, :to_s, :match
-    
-    class << self
-      attr_reader :date_fields, :name_fields, :text_fields, :filters, :types
-
-      def fields
-        date_fields + name_fields + text_fields
-      end
-      
-      def filter(id, key)
-        Variable.filters[id][key]
-      end
-
-      def parse(values, name=nil)
-        values.is_a?(Array) ? values.map { |value| Variable.types[name].new(value) } :
-          Variable.types[name].new(values)
-      end
-    end
-
-    def initialize(attributes={}, &block)
-      parse!(attributes)
-      yield self if block_given?
-    end
-    
-    def parse!(argument)
-      argument = argument.to_hash if argument.is_a?(Variable)
-      argument.is_a?(Hash) ?  self.merge!(argument) : self.value = argument.to_s
-    end
-        
-    def numeric?
-      to_s =~ /\d/
-    end
-    
-    # @returns (first) numeric data contained in the variable's value
-    def to_i
-      to_s =~ /(-?\d[\d,\.]*)/ && $1.to_i || 0
-    end
-    
-    
-    def <=>(other)
-      strip_markup(to_s) <=> strip_markup(other.to_s)
-    end
-    
-    protected
-    
-    def strip_markup(string)
-      string.gsub(/<[^>]*>/, '')
-    end
-  end
-
-end

data/lib/citeproc/version.rb

@@ -1,3 +0,0 @@
-module CiteProc
-  VERSION = '0.0.6'.freeze
-end

data/lib/csl/locale.rb

@@ -1,223 +0,0 @@
-module CSL
-  
-  class Locale
-    include Support::Tree
-    include Comparable
-
-    # Class Instance Variables
-    @path = File.expand_path('../../../resource/locale/', __FILE__)
-    @default = 'en-US'
-    
-    # Language and region defaults
-    @regions = Hash.new { |hash, key| hash[key] = Locale.match_region(key) }
-    @regions['en'] = 'US'
-    @regions['de'] = 'DE'
-    @regions['pt'] = 'PT'
-
-    @languages = Hash.new { |hash, key| hash[key] = Locale.match_language(key) }
-
-    class << self
-      attr_accessor :path, :default, :regions, :languages
-  
-      # @returns first available region for current language.
-      def match_region(language)
-        Dir.entries(Locale.path).detect { |l| l.match(%r/^[\w]+-#{language}-([A-Z]{2})\.xml$/) }
-        $1
-      end
-
-      # @returns first available language for current region.
-      def match_language(region)
-        Dir.entries(Locale.path).detect { |l| l.match(%r/^[\w]+-([a-z]{2})-#{region}\.xml$/) }
-        $1
-      end
-    end
-    
-    
-    attr_reader :language, :region
-
-    alias :style :parent
-
-    # @param argument a language tag; or an XML node
-    def initialize(argument=nil, style=nil, &block)
-      case
-      when argument.is_a?(Nokogiri::XML::Node)
-        @language, @region = argument['lang'].split(/-/) if argument['lang']
-        parse!(argument)
-      
-      when argument.is_a?(String) && argument.match(/^\s*<locale/)
-        argument = Nokogiri::XML.parse(argument) { |config| config.strict.noblanks }.root
-        @language, @region = argument['lang'].split(/-/) if argument['lang']
-        parse!(argument)
-      
-      when argument.is_a?(String) || argument.is_a?(Symbol)
-        set(argument)
-      end
-      
-      @parent = style
-      
-      yield self if block_given?
-    end
-    
-    def language=(language)
-      @language = language
-      @region = Locale.regions[language]
-    end
-    
-    def region=(region)
-      @region = region
-      @language = Locale.languages[region]
-    end
-    
-    def parse!(node)
-      raise(ArgumentError, "expected XML node, was: #{ node.inspect }") unless node.is_a?(Nokogiri::XML::Node)
-      
-      @terms = Term.build(node)
-      
-      @options = Hash[*node.css('style-options').map(&:attributes).map { |a| a.map { |name, a| [name, a.value] } }.flatten]    
-      
-      @date = Hash.new([])
-      ['text', 'numeric'].each do |form|
-        @date[form] = node.css("date[form='#{form}'] > date-part").map do |part|
-          Nodes::DatePart.new(Hash[*part.attributes.values.map { |a| [a.name, a.value] }.flatten])
-        end
-      end
-      
-      self
-    end
-    
-    def set(tag)
-      @language, @region = tag.to_s.split(/-/)
-    end
-    
-    def tag
-      [@language, @region].compact.join('-')
-    end
-  
-    def terms
-      @terms ||= Term.build
-    end
-    
-    alias :term :terms
-    
-    def has_term?(term)
-      terms.has_key?(term.to_s)
-    end
-    
-    def [](term)
-      terms[term.to_s]
-    end
-
-    # @example
-    # #options['punctuation-in-quotes'] => 'true'
-    def options
-      @options ||= {}
-    end
-    
-    alias :style_options :options
-
-    # @example
-    # #date['numeric']['month']['suffix'] => '/'
-    def date
-      @date ||= Hash.new([])
-    end
-    
-    # Around Alias Chains to call reload whenver locale changes
-    [:language=, :region=, :set].each do |method|
-      original = [:original, method].join('_')
-      alias_method original, method
-      define_method method do |*args|
-        self.send(original, *args)
-        reload!()
-      end
-    end
-
-    # Reloads the XML file. Called automatically whenever language or region changes.
-    def reload!
-      @region = Locale.regions[@language] if @region.nil?
-      @language = Locale.languages[@region] if @language.nil?
-
-      parse!(Nokogiri::XML(File.open(document_path)) { |config| config.strict.noblanks }.root)
-    rescue Exception => e
-      CiteProc.log.error "Failed to open locale file, falling back to default: #{e.message}"
-      CiteProc.log.debug e.backtrace[0..10].join("\n")
-      
-      unless tag == Locale.default
-        @language, @region = Locale.default.split(/-/)
-        retry
-      end
-    end
-
-    # Locales are sorted first by language, then by region; sort order is
-    # alphabetical with the following exceptions: en_US (the default locale)
-    # is prioritised; in case of a language-match the default region of that
-    # language will be prioritised (thus, de_DE will comes before de_AT even
-    # though the alphabetical order would be different).
-    def <=>(other)
-      Locale.sort.call(self, other)
-    end
-    
-    def self.sort(language = nil, region = nil)
-      Proc.new do |a,b|
-        if a.language != b.language
-          case
-          when a.language == language.to_s || b.language.nil? then -1
-          when b.language == language.to_s || a.language.nil? then 1
-          when a.language == 'en' then -1
-          when b.language == 'en' then 1
-          else
-            a.language <=> b.language
-          end
-        else
-          case
-          when a.region == b.region then 0
-          when a.region == region.to_s || b.region.nil? then -1
-          when b.region == region.to_s || a.region.nil? then 1
-          when a.region == Locale.regions[a.language] then -1
-          when b.region == Locale.regions[a.language] then 1
-          else
-            a.region <=> b.region
-          end
-        end
-      end
-    end
-    
-    # Returns an ordinalized number according to the rules specified in the
-    # given locale. Does not conform to CSL 1.0 in order to work around some
-    # shortcomings in the schema: this version tries a useful fallback if
-    # there is no direct hit in the locale (e.g., if 21 is not specified, we
-    # will try with 21 and then with 1). The fallback of the long-ordinal form
-    # is ordinal.
-    #
-    # TODO: long-ordinals may be influenced by gender in some locales
-    #
-    # @param number a Fixnum
-    # @param options the options hash; should contain a 'form' attribute
-    # @returns a string, e.g., '1st'
-    #
-    def ordinalize(number, options={})
-      number = number.to_i
-      
-      options['form'] ||= 'ordinal'
-      key = [options['form'], '%02d'].join('-')
-
-      ordinal = self[key % number].to_s(options)
-      mod = 100
-      
-      while ordinal.empty? && mod >= 1
-        key = 'ordinal-%02d'
-        ordinal = self[key % (number % mod)].to_s(options)
-        mod = mod / 10
-      end
-      
-      key.match(/^ordinal/) ? [number, ordinal].join : ordinal
-    end
-
-    
-    private
-    
-    def document_path
-      File.expand_path("./locales-#{@language}-#{@region}.xml", Locale.path)
-    end
-     
-  end
-end

data/lib/csl/node.rb

@@ -1,72 +0,0 @@
-module CSL
-  
-  def Node(*args, &block)
-    Node.parse(*args, &block)
-  end
-  
-  module_function :Node
-  
-  class Node
-    include Support::Attributes
-    include Support::Tree
-
-    def self.parse(*args, &block)
-      return if args.compact.empty?
-      
-      node = args.detect { |argument| argument.is_a?(Nokogiri::XML::Node) } ||
-        raise(ArgumentError, "arguments must contain an XML node; was #{ args.map(&:class).inspect }")
-    
-      name = node.name.split(/[\s-]+/).map(&:capitalize).join
-      klass = CSL.const_defined?(name) ? CSL.const_get(name) : self
-
-      klass.new({ :node => node }, &block)
-    end
-    
-    def initialize(arguments = {})
-      parse(normalize(arguments[:node])) if arguments.has_key?(:node)
-      
-      merge!(arguments[:attributes])
-      
-      @node_name = arguments[:name].to_s if arguments.has_key?(:name)
-      
-      yield self if block_given?
-    end
-
-    def name
-      node_name || self.class.name.split(/::/).last.gsub(/([[:lower:]])([[:upper:]])/) { [$1, $2].join('-') }.downcase
-    end
-    
-    alias :name= :node_name=
-
-    def style!
-      @style = root!.is_a?(Style) ? nil : root
-    end
-    
-    def style; @style || style!; end
-
-    def parse(node)      
-      @node_name = node.name
-
-      node.attributes.values.each { |a| attributes[a.name] = a.value }
-      add_children(node.children.map { |child| Node.parse(child) })
-    end
-
-    def to_xml
-    end
-
-    protected
-
-    def normalize(node)
-      case node
-      when Nokogiri::XML::Node
-        node
-      when String
-        # TODO file path (e.g. locale or style)
-        Nokogiri::XML.parse(node) { |config| config.strict.noblanks }.root
-      else
-        raise(ArgumentError, "failed to parse #{ node.inspect }")
-      end
-    end
-
-  end
-end

data/lib/csl/nodes.rb

@@ -1,1418 +0,0 @@
-module CSL
-
-  class Nodes
-
-    @formatting_attributes = %w{ text-case font-style font-variant font-weight
-      text-decoration vertical-align prefix suffix display strip-periods  }
-
-    @inheritable_name_attributes = %w{ and delimiter-precedes-last et-al-min
-      et-al-use-first et-al-subsequent-min et-al-subsequent-use-first
-      initialize-with name-as-sort-order sort-separator }
-  
-    class << self
-      attr_reader :formatting_attributes, :inheritable_name_attributes
-    
-      # Parses the given node an returns a new instance of Node or a suitable
-      # subclass corresponding to the node's name.
-      def parse(*args, &block)
-        node = args.detect { |argument| argument.is_a?(Nokogiri::XML::Node) }
-        raise(ArgumentError, "arguments must contain an XML node; was #{ args.map(&:class).inspect }") if node.nil?
-        
-        name = node.name.split(/[\s-]+/).map(&:capitalize).join
-        klass = Nodes.const_defined?(name) ? Nodes.const_get(name) : Node
-        
-        klass.new(*args, &block)
-      end
-    end
-    
-    
-    # == Node
-    #
-    # A Node represents a CSL rendering element.
-    # Rendering elements are used to specify which, and in what order,
-    # bibliographic data should be included in citations and bibliographies.
-    # Rendering elements also partly control the formatting of this data.
-    #
-    # Each Node is bound to a node in a CSL Style document. Furthermore,
-    # before any processiong can be done, the Node must be linked with a
-    # processor, in order to be able to access items, format, or locale
-    # information.
-    #
-    class Node
-      include Support::Attributes
-      include Support::Tree
-
-      attr_reader :style
-
-      class << self
-        # Chains the format method to the given methods
-        def format_on(*arguments)
-          arguments.flatten.each do |method_id|
-
-            # Set up Around Alias Chain
-            original_method = [method_id, 'without_formatting'].join('_')
-            alias_method original_method, method_id
-
-            define_method method_id do |*args, &block|
-              begin
-                string = send(original_method, *args, &block)
-                processor = args.detect { |argument| argument.is_a?(CiteProc::Processor) }
-                
-                processor.nil? ? string : processor.format(string, attributes)
-              rescue Exception => e
-                CiteProc.log :error, "failed to format string #{ string.inspect }", e
-                args[0]
-              end
-            end
-          end
-        end
-      end
-
-      def initialize(*args)
-        @style = args.detect { |argument| argument.is_a?(Style) }
-        args.delete(@style) unless @style.nil?
-        
-        args.each do |argument|
-          case          
-          when argument.is_a?(Node)
-            @parent = argument
-            @style = @parent.style || @style
-            
-          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 "cannot initialize Node from argument #{ argument.inspect }" unless argument.nil?
-          end
-        end
-
-        set_defaults
-        
-        yield self if block_given?
-      end
-
-      # Parses the given XML node.
-      def parse(node)
-        return if node.nil?
-        
-        node.attributes.values.each { |a| attributes[a.name] = a.value }
-        
-        @children = node.children.map do |child|
-          Nodes.parse(self, child)
-        end
-        
-        inherit_attributes(node)
-        self
-      end
-      
-      # @returns a new Node with the attributes and style of self and other
-      # merged.
-      def merge(other)
-        return self.copy if other.nil?
-        self.class.new(attributes.merge(other.attributes), other.style || style)
-      end
-
-      # @returns a new Node that contains the same attributes and style as self.
-      def copy; self.class.new(attributes, style); end
-      
-      # @returns a new Node with the attributes of self and other merged;
-      # attributes in other take precedence.      
-      def reverse_merge(other)
-        other.merge(self)
-      end
-      
-      # @returns the localized term with the given key.
-      def localized_terms(key, processor=nil)
-        localize(:term, key, processor) do |hash|
-          return hash[key] if hash.has_key?(key) && !hash[key].empty?
-        end        
-      end
-
-      # @returns the localized date parts.
-      def localized_date_parts(key, processor=nil)
-        localize(:date, key, processor) do |hash|
-          return hash[key] if hash.has_key?(key) && !hash[key].empty?
-        end
-      end
-      
-      def localized_options(key, processor=nil)
-        localize(:options, key, processor) do |hash|
-          return hash[key] if hash.has_key?(key)
-        end
-      end
-      
-      # Processes the supplied data. @returns a formatted string.
-      def process(data, processor)
-        ''
-      end
-
-      def evaluate(data, processor)
-        false
-      end
-      
-      def to_s
-        attributes.merge('node' => self.class.name).inspect
-      end
-
-      protected
-
-      # Empty method; nodes may override this method.
-      def set_defaults
-      end
-      
-      # TODO Refactor: move all processor-dependencies to citeproc
-      
-      # Prioritized locale look-up.
-      def localize(type, key, processor, &block)
-        unless @style.nil?
-          style.locales(processor && processor.language || nil).each do |locale|
-            yield locale.send(type)
-          end
-        end 
-        
-        unless processor.nil?
-          yield processor.locale.send(type) 
-          yield CSL::Locale.new(processor.language).send(type)
-        end
-        
-        CSL.default_locale.send(type)[key]
-      end
-
-      # @returns the locale with the highest priority
-      def locale(processor = nil)
-        locales(processor).first
-      end
-      
-      def locales(processor = nil)
-        if processor.nil?
-          style && style.locales || []
-        else
-          (style && style.locales(processor.language, processor.region) || []) + [Locale.new(processor.language)]
-        end  + [Locale.default]
-      end
-
-      
-      # Empty method; nodes may override this method.
-      def inherit_attributes(node)
-      end
-      
-      # Attributes for the cs:names and cs:name elements may also be set on
-      # cs:style, cs:citation and cs:bibliography. This eliminates the need to
-      # repeat the same attributes and attribute values for every occurrence
-      # of the cs:names and cs:name elements.
-      #
-      # The available inheritable attributes for cs:name are and,
-      # delimiter-precedes-last, et-al-min, et-al-use-first,
-      # et-al-subsequent-min, et-al-subsequent-use-first, initialize-with,
-      # name-as-sort-order and sort-separator. The attributes name-form and
-      # name-delimiter accompany the form and delimiter attributes on cs:name.
-      # Similarly, names-delimiter, the only inheritable attribute available
-      # for cs:names, accompanies the delimiter attribute on cs:names.
-      #
-      # When an inheritable name attribute is set on cs:style, cs:citation or
-      # cs:bibliography, its value is used for all cs:names elements within
-      # the element carrying the attribute. When an element lower in the
-      # hierarchy includes the same attribute with a different value, this
-      # latter value will override the value(s) specified higher in the
-      # hierarchy.
-      #
-      # This mehtod traverses a nodes ancestor chain and inherits all
-      # specified attributes from each parent that matches a name in names.
-      #
-      def inherit_attributes_from(node, nodes=[], attributes=[], prefix='')
-        return unless node
-        
-        # TODO refactor so that node is not required anymore
-        parent = node.parent        
-        until parent.name == 'document' do
-          attributes.each { |attribute| self[attribute] ||= parent[[prefix, attribute].join] } if nodes.include?(parent.name)
-          parent = parent.parent
-        end
-      end
-      
-      def handle_processing_error(e, data, processor)
-        CiteProc.log :error, "failed to process item #{ data.inspect }", e
-        ''
-      end
-    end
-
-    
-    # All the rendering elements that should appear in the citations and
-    # bibliography should be nested inside the cs:layout element. Itself a
-    # rendering element, cs:layout accepts both affixes and formatting
-    # attributes. When used in the cs:citation element, a delimiter can be set
-    # to separate multiple bibliographic items in a single citation.
-    class Layout < Node
-      attr_fields Nodes.formatting_attributes
-      attr_fields %w{ delimiter }
-    
-      def process(data, processor)
-        children.map { |child| child.process(data, processor) }.join
-      rescue Exception => e
-        handle_processing_error(e, data, processor)
-      end
-      
-      format_on :process
-    end
-  
-    class Macro < Layout
-      attr_fields :name
-    end
-
-    # The cs:text element is used to output text, which can originate from
-    # different sources. The source-type is indicated with an attribute, and
-    # the attribute value acts as an identifier within the source-type. For
-    # example,
-    #
-    # <text variable="title" form="short" font-style="italic"/>
-    #
-    # indicates that the source-type is a variable, and that the variable that
-    # should be displayed is the italicized short form of "title". The
-    # different source-types are:
-    #
-    # * variable - the text contents of a variable (see Standard Variables). The
-    #   optional form attribute can be set to either "long" (the default) or
-    #   "short" to select the long or short forms of variables, e.g. the full
-    #   and short title.
-    # * macro - the text generated by a macro. The value of macro should
-    #   correspond to the value of the name attribute of the desired cs:macro
-    #   element.
-    # * term - the text of a localized term (see Appendix III - Terms and
-    #   Locale). 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".
-    # * value - used to output verbatim text, which is set via the value of
-    #   value (e.g. value="some text")
-    #
-    # In all cases the attributes for affixes, display, formatting, quotes,
-    # strip-periods and text-case may be applied to cs:text.    
-    class Text < Node
-      attr_fields Nodes.formatting_attributes
-      attr_fields %w{ variable form macro term plural value quotes }
-    
-      def process(data, processor)
-        case
-        when has_value?
-          text = value
-          
-        when has_macro?
-          text = @style.macros[macro].process(data, processor) 
-          
-        when has_term?
-          text = localized_terms(term).to_s(attributes)
-          
-        when has_variable?
-          text = (data["short#{variable.capitalize}"] || data[['short', variable].join('-')] || data[variable]).to_s
-
-          if form == 'short'
-            text = processor.abbreviate(variable, text)
-          end
-          
-          if variable == 'page' && @style.options.has_key?('page-range-format')
-            text = format_page_range(text, @style.options['page-range-format'])
-          end
-          
-          if variable == 'page-first' && text.empty?
-            text = data['page'].to_s.scan(/\d+/).first.to_s
-          end
-          
-        else
-          text = ''
-        end
-        
-        # Add localized quotes
-        if has_quotes? && !text.empty?
-          prefix = [self['prefix'], localized_terms('open-quote')].compact.join
-          
-          if localized_options('punctuation-in-quote', processor) == 'true'
-            suffix = self['suffix'].to_s.sub(/^([\.,!?;:]+)/, '')
-            suffix = [$1, localized_terms('close-quote'), suffix].compact.join
-          else
-            text = text.sub(/([\.,!?;:]+)$/, '')
-            suffix = [localized_terms('close-quote'), $1, self['suffix']].compact.join
-          end
-          
-          self['prefix'] = prefix
-          self['suffix'] = suffix
-        end
-      
-        text
-      rescue Exception => e
-        handle_processing_error(e, data, processor)      
-      end
-  
-      format_on :process
-      
-      protected
-      
-      # The page abbreviation rules for the different values of the
-      # page-range-format attribute on cs:style are:
-      # 
-      # * "minimum": All digits repeated in the second number are left out:
-      #   42-5, 321-8, 2787-816
-      # * "expanded": Abbreviated page ranges are expanded to their
-      #   non-abbreviated form: 42-45, 321-328, 2787-2816
-      # * "chicago": Page ranges are abbreviated according to the link Chicago
-      #   Manual of Style-rules
-      #     
-      def format_page_range(value, format)
-        return value unless value.match(/([a-z]*)(\d+)\s*\D\s*([a-z]*)(\d+)/i)
-
-        tokens = [$1, $2, "\xe2\x80\x93", $3, $4]
-        tokens[2].force_encoding("UTF-8") if RUBY_VERSION >= '1.9.0'
-
-        # normalize page range to expanded form
-        f, t = tokens[1].chars.to_a, tokens[4].chars.to_a
-        d = t.length - f.length
-        d > 0 ? d.times { f.unshift('0') } : t = f.take(d.abs) + t
-        
-        # TODO handle prefixes correctly
-        # TODO handle multiple ranges
-        
-        case format
-        when /mini/
-          tokens[4] = f.zip(t).map { |f, t| f == t ? nil : t }.reject(&:nil?)
-          tokens[3] = nil if tokens[3] == tokens[0]
-        when 'expanded'
-          tokens[4] = t
-          tokens[3] = tokens[0] if tokens[3].nil? || tokens[3].empty?
-        when 'chicago'
-          case
-          when f.length < 3 || f.join.to_i % 100 == 0
-            # use all digits
-            tokens[4] = t
-            tokens[3] = tokens[0] if tokens[3].nil? || tokens[3].empty?            
-          when f.join.to_i % 100 < 10
-            # use changed part only
-            tokens[4] = f.zip(t).map { |f, t| f == t ? nil : t }.reject(&:nil?)
-            tokens[3] = nil if tokens[3] == tokens[0]
-          when f.length == 4
-            # use at least two digits, and all if three or more change
-            match = f[0..-3].zip(t[0..-3]).map { |f, t| f == t ? nil : t }.reject(&:nil?) + t[-2..-1]
-            tokens[4] = match.length > 2 ? t : match
-            tokens[3] = tokens[0] if tokens[3].nil? || tokens[3].empty?
-          else
-            # use at least two digits in second number
-            tokens[4] = f[0..-3].zip(t[0..-3]).map { |f, t| f == t ? nil : t }.reject(&:nil?) + t[-2..-1]
-            tokens[3] = nil if tokens[3] == tokens[0]
-          end
-        else
-          value
-        end
-        tokens.join
-      end
-      
-    end
-
-
-    #
-    # The Date element is used to output dates, in either a localized or a
-    # non-localized format. The desired date variable (@see CiteProc::Date) is
-    # selected with the variable attribute.
-    #
-    # Localized date formats are selected with the form attribute. This
-    # attribute can be set to "numeric" (for numeric date formats, e.g.
-    # "12-15-2005"), or to "text" (for date formats with a non-numeric month,
-    # e.g. "December 15, 2005"). Localized dates can be customized in two
-    # ways. First, the date-parts attribute may be used to specify which
-    # cs:date-part elements are shown. The possible values are:
-    #
-    # * "year-month-day" - default, displays year, month and day
-    # * "year-month" - displays year and month
-    # * "year" - displays year only
-    #
-    # Secondly, cs:date may include one or more cs:date-part elements (see
-    # Date-part). The attributes set on these elements override those
-    # originally specified for the localized date formats (e.g. the form
-    # attribute of the month-cs:date-part element can be set to "short" to get
-    # abbreviated month names in all locales.). Note that the use of
-    # cs:date-part elements for localized dates does not affect which, and in
-    # what order, the cs:date-part elements are included in the rendered date.
-    # Also, the cs:date-part elements may not carry the attributes for
-    # affixes, as these are considered to be locale-specific.
-    #
-    # Non-localized date formats are self-contained: the date format is
-    # entirely controlled by cs:date and its cs:date-part children. In
-    # contrast to localized dates, cs:date is used without the form and
-    # date-parts attributes. Only the included cs:date-part elements will be
-    # rendered, in the order in which they are specified. The cs:date-part
-    # elements may carry attributes for both affixes and formatting, while
-    # cs:date may carry a delimiter (delimiting the various cs:date-part
-    # elements).
-    #
-    # For both localized and non-localized dates, affixes, display and
-    # formatting attributes may be specified for the cs:date element.
-    #
-    class Date < Node
-      attr_fields Nodes.formatting_attributes
-      attr_fields %w{ variable form date-parts delimiter }
-      
-      def process(data, processor)
-        date = data[variable]
-
-        case
-        when date.nil?
-          ''
-        when date.literal?
-          date.literal
-        when date.range?
-          process_range(date, processor)
-        else
-          parts(processor).map { |part| part.process(date, processor) }.join(delimiter)
-        end
-      rescue Exception => e
-        handle_processing_error(e, data, processor)
-      end
-
-      format_on :process
-      
-      # By default, date ranges are delimited by an en-dash (e.g. "May-July
-      # 2008"). The range-delimiter attribute can be used to specify custom
-      # date range delimiters. The attribute value set on the largest
-      # date-part ("day", "month" or "year") that differs between the two
-      # dates of the date range will then be used instead of the en-dash. For
-      # example,
-      #
-      # <style>
-      #   <citation>
-      #     <layout>
-      #       <date variable="issued">
-      #         <date-part name="month" suffix=" "/>
-      #         <date-part name="year" range-delimiter="/"/>
-      #       </date>
-      #     </layout>
-      #   </citation>
-      # </style>
-      # 
-      # would result in "May-July 2008" and "May 2008/June 2009".
-      #
-      def process_range(date, processor)
-        order = parts(processor)
-
-        parts = [order, order].zip(date.display_parts).map do |order, parts|
-          order.map { |part| parts.include?(part['name']) ? part : nil }.compact
-        end
-
-        result = parts.zip([date, date.to]).map { |parts, date| parts.map { |part| part.process(date, processor) }.join(delimiter) }.compact
-        result[0].gsub!(/\s+$/, '')
-        result.join(parts[0].last.range_delimiter)
-
-        # case
-        # when date.open_range?
-        #   result << parts.map { |part| part.process(date, processor) }.join(delimiter)
-        #   result << parts.last.range_delimiter
-        #   
-        # when discriminator == 'month'
-        #   month_parts = parts.reject { |part| part['name'] == 'year' }
-        # 
-        #   result << month_parts.map { |part| part.process(date, processor) }.join(delimiter)
-        #   result << month_parts.last.range_delimiter
-        #   result << parts.map { |part| part.process(date.to, processor) }.join(delimiter)
-        # 
-        # when discriminator == 'day'
-        #   day_parts = parts.select { |part| part['name'] == 'day' }
-        # 
-        #   result << day_parts.map { |part| part.process(date, processor) }.join(delimiter)
-        #   result << day_parts.last.range_delimiter
-        #   result << parts.map { |part| part.process(date.to, processor) }.join(delimiter)
-        #   
-        # else # year
-        #   year_parts = parts.select { |part| part['name'] == 'year' }
-        # 
-        #   result << parts.map { |part| part.process(date, processor) }.join(delimiter)
-        #   result << year_parts.last.range_delimiter
-        #   result << year_parts.map { |part| part.process(date.to, processor) }.join(delimiter)
-        #   
-        # end
-        # 
-        # result.join
-      end
-      
-      def parts(processor)
-        has_form? ? merge_parts(localized_date_parts(form, processor), children) : children
-      end
-      
-      
-      # Combines two lists of date-part elements; includes only the parts set
-      # in the 'date-parts' attribute and retains the order of elements in the
-      # first list.
-      def merge_parts(p1, p2)
-        merged = p1.map do |part|
-          DatePart.new(part.attributes, style).merge(p2.detect { |p| p['name'] == part['name'] })
-        end
-        merged.reject { |part| !date_parts.match(Regexp.new(part['name'])) }
-      end
-
-      def date_parts
-        self['date-parts'] || 'year-month-day'
-      end
-    end
-
-    class DatePart < Node
-      attr_fields Nodes.formatting_attributes
-      attr_fields %w{ name form range-delimiter strip-periods }
-    
-      def process(date, processor)  
-        send(['process', self['name']].join('_'), date, processor)
-      rescue Exception => e
-        handle_processing_error(e, data, processor)      
-      end
-    
-      format_on :process
-
-      def process_year(date, processor)
-        return '' if date.year.nil?
-        
-        year = date.year.abs.to_s
-        year = year[-2..-1] if form == 'short'
-        year = [year, localized_terms('ad', processor)].join if date.ad?
-        year = [year, localized_terms('bc', processor)].join if date.bc?
-        year
-      end
-      
-      def process_month(date, processor)
-        return process_season(date, processor) if date.has_season?
-        return '' if date.month.nil?      
-
-        case
-        when form == 'numeric'
-          date.month.to_s
-        when form == 'numeric-leading-zeros'
-          "%02d" % date.month
-        else
-          localized_terms("month-%02d" % date.month, processor).to_s(attributes)
-        end      
-      end
-      
-      def process_season(date, processor)
-        season = date.season.to_s
-        season = date.month.to_s if season.match(/true|always|yes/i)
-        season = localized_terms('season-%02d' % season.to_i, processor).to_s if season.match(/0?[1-4]/)
-        season
-      end
-
-      def process_day(date, processor)
-        return '' if date.day.nil?
-        
-        case
-        when form == 'ordinal'
-          locale(processor).ordinalize(date.day, 'gender-form' => gender(date, processor))
-        when form == 'numeric-leading-zeros'
-          "%02d" % date.day
-        else # 'numeric'
-          date.day.to_s
-        end
-      end
-      
-      def gender(date, processor)
-        localized_terms("month-%02d" % date.month, processor).gender
-      end
-    
-      protected
-      
-      def set_defaults
-        unless self['range-delimiter']
-          self['range-delimiter'] = "\xe2\x80\x93"
-          self['range-delimiter'].force_encoding("UTF-8") if RUBY_VERSION >= '1.9.0'
-        end
-      end
-    end
-
-
-    # The cs:number element can be used to output any of the following
-    # variables (selected with the variable attribute):
-    # 
-    #         "edition"
-    #         "volume"
-    #         "issue"
-    #         "number"
-    #         "number-of-volumes"
-    #
-    # Although these variables can also be rendered with cs:text, cs:number
-    # has the benefit of offering number-specific formatting via the form
-    # attribute, with values:
-    # 
-    # * "numeric" (default) - e.g. "1", "2", "3"
-    # * "ordinal" - e.g. "1st", "2nd", "3rd"
-    # * "long-ordinal" - e.g. "first", "second", "third"
-    # * "roman" - e.g. "i", "ii", "iii"
-    #
-    # If a variable displayed with cs:number contains a mixture of numeric and
-    # non-numeric text, only the first number encountered is used for
-    # rendering (e.g. "12" when the entire string is "12th edition"). If a
-    # variable only contains non-numeric text (e.g. "special edition"), the
-    # entire string is rendered, as if cs:text were used instead. Fields can
-    # be tested for containing numeric content with the is-numeric
-    # conditional, e.g. "12th edition" would test "true" while "third edition"
-    # would test "false" (@see Choose).
-    #
-    # The cs:number element may carry any of the affixes, display, formatting
-    # and text-case attributes.
-    #     
-    class Number < Node
-      attr_fields Nodes.formatting_attributes      
-      attr_fields %w{ variable form }
-    
-      def process(data, processor)
-        number = data[variable]
-   
-        term = localized_terms(variable, processor)
-        attributes['gender-form'] = term.gender if term.has_gender?
-        
-        case
-        when number.nil? || number.empty? || !number.numeric?
-          number.to_s
-        when form == 'roman'
-          number.to_i.romanize
-        when form == 'ordinal'
-          locale(processor).ordinalize(number.to_i, attributes)
-        when form == 'long-ordinal'
-          locale(processor).ordinalize(number.to_i, attributes)
-        else
-          number.to_i.to_s
-        end
-      rescue Exception => e
-        handle_processing_error(e, data, processor)      
-      end
-
-      format_on :process
-    end
-
-    # The cs:name element is a required child element of cs:names, and describes
-    # both how individual names are formatted, and how names within a name
-    # variable are separated from each other. The attributes that may be used on
-    # cs:name are:
-    #
-    # 'and'
-    # This attribute specifies the delimiter between the second to last
-    # and the last name of the names in a name variable. The value of the
-    # attribute may be either "text", which selects the "and" term, or "symbol",
-    # which selects the ampersand (&).
-    #
-    # 'delimiter'  
-    # Specifies the text string to separate names of a name variable. The
-    # default value is ", " ("J. Doe, S. Smith").
-    #
-    # 'delimiter-precedes-last'
-    # Determines in which cases the delimiter used to delimit names is also used
-    # to separate the second to last and the last name in name lists. The
-    # possible values are:
-    #
-    #   "contextual" (default): the delimiter is only included for name lists with three or more names
-    #       2 names: "J. Doe and T. Williams,"
-    #       3 names: "J. Doe, S. Smith, and T. Williams"
-    #   "always": the delimiter is always included
-    #       2 names: "J. Doe, and T. Williams"
-    #       3 names: "J. Doe, S. Smith, and T. Williams"
-    #   "never": the delimiter is never included
-    #       2 names: "J. Doe and T. Williams,"
-    #       3 names: "J. Doe, S. Smith and T. Williams"
-    # 
-    # 'et-al-min / et-al-use-first'  
-    # Together, these attributes control et-al abbreviation. When the number of
-    # names in a name variable matches or exceeds the number set on et-al-min,
-    # the rendered name list is truncated at the number of names set on
-    # et-al-use-first. If truncation occurs, the "et-al" term is appended to the
-    # names rendered (see also Et-al). With a single name (et-al-use-first="1"),
-    # the "et-al" term is preceded by a space (e.g. "Doe et al."). With multiple
-    # names, the "et-al" term is preceded by the name delimiter (e.g. "Doe,
-    # Smith, et al.").
-    #
-    # 'et-al-subsequent-min / et-al-subsequent-use-first'  
-    # The (optional) et-al-min and et-al-use-first attributes take effect for
-    # all cites and bibliographic entries. With the et-al-subsequent-min and
-    # et-al-subsequent-use-first attributes divergent et-al abbreviation rules
-    # can be specified for subsequent cites (cites referencing earlier cited
-    # items).
-    #
-    # The remaining attributes, discussed below, only affect personal names.
-    # Personal names require a "family" name-part, and may also contain "given",
-    # "suffix", "non-dropping-particle" and "dropping-particle" name-parts. The
-    # roles of these name-parts, which are delimited by single spaces in
-    # rendered names, are:
-    #
-    # * "family": the surname minus any particles and suffixes
-    # * "given": the given names, which may be either full ("John Edward") or
-    #   initialized ("J. E.")
-    # * "suffix": name suffix, e.g. "Jr." in "John Smith Jr." and "III" in "Bill
-    #   Gates III"
-    # * "non-dropping-particle": name particles that are not dropped when only the
-    #   last name is shown ("de" in the Dutch surname "de Koning") but which may
-    #   be treated as a separate object from the family name (e.g. for sorting)
-    # * "dropping-particle": name particles that are dropped when only the
-    #   surname is shown ("van" in "Ludwig van Beethoven", which becomes
-    #   "Beethoven")
-    #
-    # 'form'  
-    # Specifies whether all the name-parts of personal names should be displayed
-    # (value "long"), or only the family name and the non-dropping-particle
-    # (value "short"). A third value, "count", returns the total number of names
-    # that would be otherwise displayed by the use of the cs:names element
-    # (taking into account the effects of et-al abbreviation and
-    # editor/translator collapsing), and may be used for advanced sorting.
-    #
-    # 'initialize-with'  
-    # If this attribute is set, given names are converted to initials. The
-    # attribute value specifies the suffix that is included after each initial
-    # ("." results in "J.J. Doe"). Note that the global initialize-with-hyphen
-    # option controls how compound given names (e.g. "Jean-Luc") are hyphenated
-    # when initialized (see Hyphenation of Initialized Names).
-    #
-    # 'name-as-sort-order'
-    # Specifies that names should be displayed with the given name following the
-    # family name (e.g. "John Doe" becomes "Doe, John"). The attribute may have
-    # one of the two values:
-    #
-    # "first": name-as-sort-order applies to the first name in each name variable
-    # "all": name-as-sort-order applies to all names
-    #
-    # Note that the sort order of names may differ from the display order for
-    # names containing particles and suffixes (see Name-part order). Also, this
-    # attribute only affects names written in the latin or Cyrillic alphabet.
-    # Names written in other alphabets (e.g. Asian scripts) are always shown
-    # with the family name preceding the given name.
-    #
-    # 'sort-separator'  
-    # Sets the delimiter for name-parts that have switched positions as a result
-    # of name-as-sort-order. The default value is ", " ("Doe, John"). As is the
-    # case for name-as-sort-order, this attribute only affects names written in
-    # the latin or Cyrillic alphabet.
-    #
-    # The cs:name element may also carry any of the attributes for affixes and formatting.
-    #
-    class Name < Node
-      attr_fields Nodes.formatting_attributes
-      attr_fields Nodes.inheritable_name_attributes
-      attr_fields %w{ form delimiter delimiter-precedes-et-al }
-
-      def parts
-        @parts ||= Hash.new { |h, k| k.match(/(non-)?dropping-particle/) ? h['family'] : {} }
-      end
-  
-      def process_names(role, names, processor)
-
-        # set display options
-        names = names.each { |name| name.merge_options(attributes) }
-        names.first.options['name-as-sort-order'] = 'true' if name_as_sort_order == 'first'
-
-        # name-part formatting
-        names.map! do |name|
-          name.normalize(name.display_order.map do |token|
-            processor.format(name.send(token.tr('-', '_')), parts[token])
-          end.compact.join(name.delimiter))
-        end        
-
-        # join names
-        if names.length > 2
-          names = [names[0..-2].join(delimiter), names.last]
-        end
-
-        names.join(ampersand(processor))
-      rescue Exception => e
-        CiteProc.log :error, "failed to process names #{ names.inspect }", e
-      end
-
-      format_on :process_names
-
-      def truncate(names)
-        # TODO subsequent
-        et_al_min? && et_al_min.to_i <= names.length ? names[0, et_al_use_first.to_i] : names
-      end
-      
-      protected
-      
-      def set_defaults
-        attributes['delimiter'] ||= ', '
-        attributes['delimiter-precedes-last'] ||= 'false'
-        attributes['et-al-use-first']  ||= '1'
-        
-        children.each { |child| parts[child['name']] = child.attributes }        
-      end      
-
-      # @returns the delimiter to be used between the penultimate and last
-      # name in the list.
-      def ampersand(processor)
-        if self.and?
-          ampersand = self.and == 'symbol' ? '&' : localized_terms(self.and == 'text' ? 'and' : self.and, processor).to_s(attributes)
-          delimiter_precedes_last? ? [delimiter, ampersand, ' '].join : ampersand.center(ampersand.length + 2)
-        else
-          delimiter
-        end
-      end
-
-      def inherit_attributes(node)
-        inherit_attributes_from(node, ['citation', 'bibliography', 'style'], Nodes.inheritable_name_attributes)
-        inherit_attributes_from(node, ['citation', 'bibliography', 'style'], ['et-al-use-first', 'delimiter-precedes-et-al'])
-        inherit_attributes_from(node, ['citation', 'bibliography', 'style'], ['form', 'delimiter'], 'name-')
-        inherit_attributes_from(node, ['style'], ['demote-non-dropping-particle', 'initialize-with-hyphen'])
-      end
-      
-    end
-
-    # The cs:name element may include one or two cs:name-part child elements.
-    # These child elements accept the formatting and text-case attributes, which
-    # allows for separate formatting of the different name parts (e.g. "Jane
-    # DOE", see example below). The required name attribute on cs:name-part
-    # specifies which name-parts are affected: when set to "given", the
-    # formatting only acts on the "given" name-part. When set to "family", the
-    # formatting acts on the "family", "dropping-particle" and
-    # "non-dropping-particle" name-parts (the "suffix" name-part is not subject
-    # to any name-part formatting). The order of the cs:name-part elements does
-    # not affect which, and in what order, the name-parts are rendered.
-    #
-    #     <names variable="author">
-    #       <name>
-    #         <name-part name="family" text-case="uppercase">
-    #       </name>
-    #     </names>
-    #
-    class NamePart < Node
-      attr_fields Nodes.formatting_attributes
-      attr_fields %w{ name }
-            
-    end
-  
-    # Et-al abbreviation, controlled via the et-al attributes on cs:name (see
-    # Name), can be further customized with the optional cs:et-al element, which
-    # should be included directly after the cs:name element. The term attribute
-    # of this element can be set to either "et-al" (default) or to "and others"
-    # to use either term (with this different et-al terms can be used for
-    # citations and the bibliography). In addition, attributes for affixes and
-    # formatting can be used, for example to italicize the et-al term:
-    #
-    #     <names variable="author">
-    #       <name/>
-    #       <et-al term="and others" font-style="italic"/>
-    #     </names>
-    #
-    class EtAl < Node
-      attr_fields Nodes.formatting_attributes
-      attr_fields %w{ term }
-    
-      attr_accessor :parent
-
-      def process(data, processor)
-        localized_terms(term ||  'et-al', processor).to_s(attributes)
-      rescue Exception => e
-        handle_processing_error(e, data, processor)        
-      end
-    
-      format_on :process
-    
-    end
-  
-  
-    # The cs:label element, used to output text terms whose pluralization
-    # depends on the contents of another variable (e.g. "(editors)" in "Doe and
-    # Smith (editors)"), is discussed in detail in the label section. It should
-    # be included after the cs:name and cs:et-al elements, but before the
-    # cs:substitute element. When used within cs:names, the variable attribute
-    # should be omitted, as the value set on the parent cs:names element is
-    # used.
-    #
-    # The Citation Style Language includes several variables that have
-    # matching terms. The cs:label element can be used to render one of these
-    # terms, while matching the term plurality with that of the corresponding
-    # variable. The variable/term combination is selected with the variable
-    # attribute, which can be set to either "page" or "locator". When cs:label
-    # is used as a child element of cs:names, the value of the variable
-    # attribute is automatically inherited from the parent cs:names element.
-    # The example below displays the "page" variable, using the singular form
-    # of the "page" term for a single page ("page 5"), or the plural form for
-    # a page range ("pages 5-7").  
-    #  
-    class Label < Node
-      attr_fields Nodes.formatting_attributes      
-      attr_fields %w{ variable plural form }
-    
-      def process(data, processor)
-        localized_terms(data['label'].to_s, processor).to_s(attributes.merge({ 'plural' =>  plural?(data, 0).to_s }))
-      rescue Exception => e
-        handle_processing_error(e, data, processor)        
-      end
-    
-      def process_names(role, number, processor)
-        localized_terms(role, processor).to_s(attributes.merge({ 'plural' => plural?(nil, number).to_s }))        
-      rescue Exception => e
-        handle_processing_error(e, data, processor)        
-      end
-        
-      format_on :process
-      format_on :process_names
-      
-      def plural?(data, number)
-        case
-        when plural == 'always'
-          true
-        when plural == 'never'
-          false
-        when number > 1
-          true
-        when ['locator'].include?(variable)
-          data[variable].to_s.match(/\d+f|\d+\-\d+/)
-        else
-          false
-        end
-      end
-    end
-
-
-    # The optional cs:substitute element, which should be included as the last
-    # child element of cs:names, controls substitution in case the name
-    # variables specified in the parent cs:names element are empty. The
-    # substitutions are specified as child elements of cs:substitute, and can
-    # consist of any of the standard rendering elements (with the exception of
-    # cs:layout). It is also possible to use a shorthand version of cs:names,
-    # which doesn't allow for any child elements, and uses the attributes values
-    # set on the cs:name and cs:et-al child elements of the original cs:names
-    # element. If cs:substitute contains multiple child elements, the first
-    # element to return a non-empty result is used for substitution. Substituted
-    # variables are repressed in the rest of the output to prevent duplication.
-    # An example, where an empty "author" name variable is substituted by the
-    # "editor" name variable, or, when no editors exist, by the "title" macro:
-    #
-    #     <macro name="author">
-    #       <names variable="author">
-    #         <name/>
-    #         <substitute>
-    #           <names variable="editor"/>
-    #           <text macro="title"/>
-    #         </substitute>
-    #       </names>
-    #     </macro>
-    #
-    class Substitute < Node
-        
-      def process(data, processor)
-        super
-				start_observing(data)
-				
-        children.each do |child|
-          processed = child.process(data, processor)
-          return processed unless processed.empty?
-        end
-        ''
-      rescue Exception => e
-        handle_processing_error(e, data, processor)        
-			ensure
-				stop_observing(data)
-      end
-    
-			def start_observing(item)
-				@item = item
-        item.add_observer(self)
-      end
-      
-      def stop_observing(item)
-        item.delete_observer(self)
-			ensure
-				@item = nil
-      end
-      
-      def update(key, value)
-				if key.to_s =~ /author|editor|translator/ && !value.nil?
-					@item[key] = nil
-				end
-      end
-    end
-
-    # The cs:names element can be used to display the contents of one or more
-    # name variables, each of which can contain multiple names (e.g. the
-    # "author" variable will contain all the cited item's author names). The
-    # variables to be displayed are set with the variable attribute. If multiple
-    # variables are selected (separated by single spaces, see example below),
-    # each variable is independently rendered in the order specified, with one
-    # exception: if the value of variable consists of "editor" and "translator"
-    # (in either order), and if the contents of the two name variables is
-    # identical, then the contents of only one name variable is rendered. In
-    # addition, the "editor-translator" term is used if the cs:names element
-    # contains a cs:label element, replacing the default "editor" and
-    # "translator" terms (e.g., this might result in "Doe (editor &
-    # translator)". The delimiter attribute may be set on cs:names to delimit
-    # the names of the different name variables (e.g. the semicolon in "Doe
-    # (editor); Johnson (translator)").
-    #
-    #     <names variable="editor translator" delimiter="; ">
-    #       <name/>
-    #       <label prefix=" (" suffix=")"/>
-    #     </names>
-    #
-    # There are four child elements associated with the cs:names element:
-    # cs:name, cs:et-al, cs:substitute and cs:label (all discussed below). In
-    # addition, the cs:names element may carry the attributes for affixes,
-    # display and formatting.
-    #
-    class Names < Node
-      attr_fields Nodes.formatting_attributes
-      attr_fields %w{ variable delimiter }
-    
-      [:name, :et_al, :label, :substitute].each do |method_id|
-        klass = CSL::Nodes.const_get(method_id.to_s.split(/_/).map(&:capitalize).join)
-        define_method method_id do
-          elements = children.empty? && parent.is_a?(Substitute) && klass != Substitute ? parent.parent.children : children
-          elements.detect { |child| child.class == klass }
-        end
-      end
-         
-      def prefix_label?
-        children.map {|c| [Label, Name].include?(c.class) ? c.class : nil }.compact == [Label, Name]
-      end
-         
-      def process(data, processor)
-        names = collect_names(data)
-        
-        count_only = self.name.form == 'count'
-        
-        unless names.empty? || names.map(&:last).flatten.empty?
-  
-          # handle the editor-translator special case
-          if names.map(&:first).sort.join.match(/editortranslator/)
-            editors = names.detect { |name| name.first == 'editor' }
-            translators = names.detect { |name| name.first == 'translator' }
-        
-            if editors.last.sort == translators.last.sort
-              editors[0] = 'editortranslator'
-              names.delete(translators)
-            end
-          end
-      
-          names = names.map do |role, names|
-            processed = []
-            
-            truncated = name.truncate(names)
-
-            unless count_only
-              processed << name.process_names(role, truncated, processor)
-            
-              if names.length > truncated.length
-                # use delimiter before et al. if there is more than a single name; squeeze whitespace
-                others = (et_al.nil? ? localized_terms('et-al', processor).to_s : et_al.process(data, processor))
-                link = (name.et_al_use_first.to_i > 1 || name.delimiter_precedes_et_al? ? name.delimiter : ' ')
-
-                processed << [link, others].join.squeeze(' ')
-              end
-            
-              processed.send(prefix_label? ? :unshift : :push, label.process_names(role, names.length, processor)) unless label.nil?
-            else
-              processed << truncated.length
-            end
-
-            processed.join
-          end
-          
-          count_only ? names.inject(0) { |a, b| a.to_i + b.to_i }.to_s : names.join(delimiter)
-        else
-          count_only ? '0' : substitute.nil? ? '' : substitute.process(data, processor)
-        end
-      rescue Exception => e
-        handle_processing_error(e, data, processor)        
-      end
-    
-      format_on :process
-
-      protected
-      
-      # @returns a list of all name variables covered by this node; each list
-      # is wrapped in a list containing the lists role (e.g., 'editor')
-      # followed by the list proper.
-      def collect_names(item)
-        return [] unless self.variable?
-        self.variable.split(/\s+/).map { |variable| [variable, (item[variable] || []).map(&:clone)] }.reject { |(_, n)| n.empty? }
-      end
-    
-      def inherit_attributes(node)
-        inherit_attributes_from(node, ['citation', 'bibliography', 'style'], ['delimiter'], 'names-')
-      end
-      
-    end
-  
-
-    # The cs:group element may contain one or more rendering elements (not
-    # cs:layout). cs:group itself may carry the delimiter attribute (to
-    # delimit the enclosed elements) and the attributes for affixes (applied
-    # to the group output as a whole), display and formatting (formatting
-    # settings are transmitted to the enclosed elements). Note that cs:group
-    # implicitly acts as a conditional: cs:group and its child elements are
-    # suppressed if a) at least one rendering element in cs:group calls a
-    # variable (either directly or via a macro), and b) all variables that are
-    # called are empty. This behavior exists to accommodate descriptive
-    # cs:text elements. For example
-    #
-    #     <layout>
-    #       <group prefix="(" suffix=")">
-    #         <text value="Published by: "/>
-    #         <text variable="publisher"/>
-    #       </group>
-    #     </layout>
-    #
-    # results in "(Published by: Company A)" when the "publisher" variable is
-    # set to "Company A", but doesn't generate output when the "publisher"
-    # variable is empty.
-    #
-    class Group < Node
-      attr_fields Nodes.formatting_attributes
-      attr_fields %w{ delimiter }    
-
-      def process(data, processor)
-        start_observing(data)
-
-				if delimiter.nil? || children.length < 2
-					processed = children.map { |c| c.process(data, processor) }.reject(&:empty?).join('')
-				else
-	        processed = children.reduce('') do |ps, child|
-		 				p = child.process(data, processor)
-
-						unless p.empty?
-							if delimiter && !ps.empty?
-								ps.chop! if ps[-1] =~ /[\s\.,:!\?]/ && ps[-1] == delimiter[0]
-								
-								ps << delimiter
-								
-								ps.chop! if ps[-1] =~ /[\s\.,:!\?]/ && ps[-1] == p[0]
-							end
-						
-							ps << p
-						end
-						
-						ps
-					end
-				end
-
-        stop_observing(data)
-
-        # if any variable returned nil, skip the entire group
-        skip? ? '' : processor.format(processed, attributes)
-      rescue Exception => e
-        handle_processing_error(e, data, processor)        
-      end
-
-      def start_observing(item)
-        @variables = []
-        item.add_observer(self)
-      end
-      
-      def stop_observing(item)
-        item.delete_observer(self)
-      end
-      
-      def update(key, value)
-        @variables << [key, value]
-      end
-
-      def skip?
-        @variables && @variables.map(&:last).all?(&:nil?)
-      end
-      
-      
-      protected
-
-      def set_defaults
-        formatting_attributes = collect_formatting_attributes(%w{ delimiter suffix prefix })        
-
-        children.each do |child|
-          formatting_attributes.each_pair do |key, value|
-            child[key] ||= value
-          end
-        end
-      end
-      
-      def collect_formatting_attributes(exceptions=[])
-        formatting_attributes = {}
-        (Nodes.formatting_attributes - exceptions).each do |key|
-          formatting_attributes[key] = self[key]
-          self.attributes.delete(key)
-        end
-        formatting_attributes
-      end
-      
-    end
-
-    # Similarly to the conditional statements encountered in programming
-    # languages, the cs:choose element allows for the conditional rendering of
-    # rendering elements. An example is shown below:
-    #
-    #     <choose>
-    #       <if type="book thesis" match="any">
-    #         <text variable="title" font-style="italic">
-    #       </if>
-    #       <else-if type="chapter">
-    #         <text variable="title" quotes="true">
-    #       </else-if>
-    #       <else>
-    #         <text variable="title">
-    #       </else>
-    #     </choose>
-    #
-    # cs:choose requires a cs:if child element, which may be followed by one or
-    # more cs:else-if child elements, and an optional closing cs:else child
-    # element. The cs:if and cs:else-if elements may contain any number of
-    # rendering elements (except for cs:layout). As an empty cs:else element
-    # would be superfluous, cs:else must contain at least one rendering element.
-    # cs:if and cs:else-if elements must each hold at least one condition, which
-    # are expressed as attributes. The different types of conditions available
-    # are:
-    #
-    # disambiguate  
-    # The contents of an <if disambiguate="true"> block is only rendered if it
-    # disambiguates two otherwise identical citations. This attempt at
-    # disambiguation will only be made when all other disambiguation methods
-    # have failed to uniquely identify the target source.
-    #
-    # is-numeric
-    # Tests whether the given variables (Appendix I - Variables) contain numeric
-    # data.
-    #
-    # is-uncertain-date  
-    # Tests whether the given date variables contain uncertain dates.
-    #
-    # locator  
-    # Tests whether the locator matches the given locator variable subtype (see
-    # Locators).
-    #
-    # position
-    # Tests whether the position of the item cite matches the given positions
-    # (when called within cs:bibliography, this condition will always test
-    # "false"). The different positions are (note on terminology: a citation
-    # refers to a citation group, which contains one or more cites to individual
-    # items):
-    #
-    # * "first": the position of a cite that is the first to reference an item
-    # * "ibid"/"ibid-with-locator"/"subsequent": a cite that references an
-    #   earlier cited item always has the "subsequent" position. In special
-    #   cases cites may have the "ibid" or "ibid-with-locator" position. These
-    #   positions are only assigned when:
-    #
-    #   1. the current cite immediately follows on another cite, within the same
-    #      citation, that references the same item
-    #
-    #      or
-    #
-    #   2. the current cite is the first cite in the citation, and the previous
-    #      citation includes a single cite that references the same item
-    #
-    #
-    #   If either requirement is met, the presence of locators determines which
-    #   position is assigned:
-    #
-    #   1. Preceding cite does not have a locator: if the current cite has a
-    #      locator, the position of the current cite is "ibid-with-locator".
-    #      Otherwise the position is "ibid".
-    #
-    #   2. Preceding cite does have a locator: if the current cite has the same
-    #      locator, the position of the current cite is "ibid". If the locator
-    #      differs the position is "ibid-with-locator". If the current cite
-    #      lacks a locator the position is "subsequent".
-    #
-    # * "near-note": the position of a cite following another cite that
-    #   references the same item. Both cites have to be located in foot or
-    #   endnotes, and the distance between both cites may not exceed the maximum
-    #   distance (measured in number of foot or endnotes) set with the
-    #   near-note-distance option (see Note Distance).
-    #
-    # Note that each cite can have multiple position values. Whenever
-    # position="ibid-with-locator" is true, position="ibid" is also true.
-    # And whenever position="ibid" or position="near-note" is true,
-    # position="subsequent" is also true.
-    #
-    # type
-    # Tests whether the item matches the given types (Appendix II - Types).
-    #
-    # variable
-    # Tests whether the given variables (Appendix I - Variables) contain
-    # non-empty values.
-    #
-    # With the exception of disambiguate, all conditions allow for multiple test
-    # values (separated with spaces, e.g. "book thesis").
-    #
-    # The cs:if and cs:else-if elements may include the match attribute to
-    # control the testing logic, with possible values:
-    #
-    # * "all" (default): the element only tests "true" when all conditions test "true" for all given test values
-    # * "any": the element tests "true" when any condition tests "true" for any given test value
-    # * "none": the element only tests "true" when none of the conditions test "true" for any given test value
-    #
-    class Choose < Node
-
-      def process(data, processor)
-        children.each do |child|
-          return child.process(data, processor) if child.evaluate(data, processor)
-        end
-        ''
-      rescue Exception => e
-        handle_processing_error(e, data, processor)        
-      end
-      
-    end
-  
-    class ConditionalBlock < Node
-      attr_fields %w{ disambiguate is-numeric is-uncertain-date locator
-        position type variable match }
-      
-      def process(data, processor)
-        children.map { |child| child.process(data, processor) }.join
-      rescue Exception => e
-        handle_processing_error(e, data, processor)        
-      end
-      
-      def evaluate(data, processor)
-        case
-        when disambiguate?
-          # CiteProc.log.warn "Choose disambiguate not implemented yet"
-          false
-
-        when is_numeric?
-          data[is_numeric] && data[is_numeric].numeric?
-          
-        when is_uncertain_date?
-          data[is_uncertain_date] && data[is_uncertain_date].uncertain?
-          
-        when has_locator?
-          locator == data['locator'].to_s
-          
-        when has_position?
-          # CiteProc.log.warn "Choose position not implemented yet"
-          false
-
-        when has_type?
-          matches?(type.split(/\s+/)) { |type| type == data['type'].to_s }
-          
-        when has_variable?
-          matches?(variable.split(/\s+/)) { |variable| !data[variable].nil? }
-          
-        when self.is_a?(Else)
-          true
-          
-        else
-          CiteProc.log :warn, "conditional block #{ inspect } could not be evaluated"
-          false
-          
-        end
-      rescue Exception => e
-        CiteProc.log.error "failed to evaluate item #{data.inspect}: #{ e.message }; returning false."
-        false
-      end
-      
-      # @returns true if &condition is true for any/all/none elements in the list
-      def matches?(list, &condition)
-        list.send([self['match'] || 'all', '?'].join, &condition)
-      end
-      
-    end
-
-  end
-  
-  %w{ If ElseIf Else }.each do |node_name|
-    CSL::Nodes.const_set(node_name.to_sym, Class.new(CSL::Nodes::ConditionalBlock))
-  end
-  
-end