citeproc 1.0.0.pre12 → 1.0.0

data/lib/citeproc/names.rb

@@ -44,12 +44,8 @@ module CiteProc
 
     # Class instance variables
 
-    @romanesque = CiteProc.oniguruma {
-      '^[\p{Latin}\p{Greek}\p{Cyrillic}\p{Hebrew}\p{Armenian}\p{Georgian}\p{Common}]*$'
-    } || CiteProc.ruby_18 {
-      # @todo improve fallback range
-      /^[a-zA-Zäöüéè\s[:punct:]]*$/u
-    }
+    @romanesque =
+      /^[\p{Latin}\p{Greek}\p{Cyrillic}\p{Hebrew}\p{Armenian}\p{Georgian}\p{Common}]*$/
 
     # Default formatting options
     @defaults = {
@@ -57,6 +53,8 @@ module CiteProc
       :'name-as-sort-order' => false,
       :'demote-non-dropping-particle' => :never,
       :'sort-separator' => ', ',
+      :initialize => true,
+      :'initialize-with-hyphen' => true,
       :'initialize-with' => nil
     }.freeze
 
@@ -75,6 +73,8 @@ module CiteProc
     # @return the name's formatting options
     attr_reader :options
 
+    attr_reader :sort_prefix
+
     attr_predicates :'comma-suffix', :'static-ordering', :multi, *@parts
 
     # Aliases
@@ -92,8 +92,9 @@ module CiteProc
     end
 
     # Names quack sorta like a String
-    def_delegators :to_s, :=~, :===,
-      *String.instance_methods(false).reject { |m| m =~ /^\W|!$|to_s|replace|first|last/ }
+    def_delegators :to_s, :=~, :===, *String.instance_methods(false).reject { |m|
+      m.to_s =~ /^[\W_]|[!=_]$|^(to_s|inspect|replace|first|last|dup|clone)$/
+    }
 
     # Delegate bang! methods to each field's value
     String.instance_methods(false).each do |m|
@@ -126,12 +127,24 @@ module CiteProc
     end
 
 
+    # Resets the object's options to the default settings.
+    # @return [self]
+    def reset!
+      @options = Name.defaults.dup
+    end
+
+    # Returns a copy of the name object with all options
+    # reset to their default settings.
+    # @return [Name] a copy of the name with default options
+    def reset
+      dup.reset!
+    end
+
     # @return [Boolean] whether or not the Name looks like it belongs to a person
     def personal?
       !empty? && !literal?
     end
 
-
     # A name is `romanesque' if it contains only romanesque characters. This
     # should be the case for the majority of names written in latin- or
     # greek-based script. It will be false, for example, for names written
@@ -173,15 +186,15 @@ module CiteProc
 
     # Sets the name to use sort-order. The reverse of {#display_order!}.
     # @return [self]
-    def sort_order!
-      options[:'name-as-sort-order'] = true
+    def sort_order!(toggle = true)
+      options[:'name-as-sort-order'] = !!toggle
       self
     end
 
     # Sets the name to use display-order. The reverse of {#sort_order!}.
     # @return [self]
-    def display_order!
-      options[:'name-as-sort-order'] = false
+    def display_order!(toggle = true)
+      options[:'name-as-sort-order'] = !toggle
       self
     end
 
@@ -200,7 +213,7 @@ module CiteProc
     # Use short form for printing the name
     # @return [self]
     def short_form!
-      options[:form] = :short
+      options[:form] = 'short'
       self
     end
 
@@ -212,7 +225,7 @@ module CiteProc
     # Use long form for printing the name
     # @return [self]
     def long_form!
-      options[:form] = :long
+      options[:form] = 'long'
       self
     end
 
@@ -221,6 +234,33 @@ module CiteProc
       !!options[:'initialize-with'] && personal? && romanesque?
     end
 
+    def initialize_with
+      options[:'initialize-with'].to_s
+    end
+
+    def initialize_existing_only?
+      options[:initialize].to_s == 'false'
+    end
+
+    def initialize_without_hyphen?
+      !options[:'initialize-with-hyphen']
+    end
+
+    def initialize_without_hyphen!
+      options[:'initialize-with-hyphen'] = false
+    end
+
+    def initials
+      case
+      when !initials?
+        given
+      when initialize_existing_only?
+        existing_initials_of given
+      else
+        initials_of given
+      end
+    end
+
     def demote_non_dropping_particle?
       always_demote_non_dropping_particle? ||
         !!(sort_order? && options[:'demote-non-dropping-particle'] =~ /^sort(-only)?$/i)
@@ -266,31 +306,36 @@ module CiteProc
       sort_order_downcase <=> other.sort_order_downcase
     end
 
-    # @return [String] the name formatted according to the current options
     def to_s
+      [given, family].compact_join(' ')
+    end
+
+    # @return [String] the name formatted according to the current options
+    def format
       case
       when literal?
         literal.to_s
       when static_order?
-        [family, given].compact.join(' ')
+        [family, initials].compact.join(' ')
       when !short_form?
         case
         when !sort_order?
-          [[given, dropping_particle, particle, family].compact_join(' '),
+          [[initials, dropping_particle, particle, family].compact_join(' '),
             suffix].compact_join(comma_suffix? ? comma : ' ')
 
         when !demote_particle?
-          [[particle, family].compact_join(' '), [given,
+          [[particle, family].compact_join(' '), [initials,
             dropping_particle].compact_join(' '), suffix].compact_join(comma)
 
         else
-          [family, [given, dropping_particle, particle].compact_join(' '),
+          [family, [initials, dropping_particle, particle].compact_join(' '),
             suffix].compact_join(comma)
         end
       else
         [particle, family].compact_join(' ')
       end
     end
+    alias print format
 
     # @return [Array<String>] an ordered array of formatted name parts to be used for sorting
     def sort_order
@@ -326,8 +371,42 @@ module CiteProc
 
     private
 
-    attr_reader :sort_prefix
+    def filter_key(key)
+      key = key.to_s.tr('_', '-')
+      key = 'non-dropping-particle' if key == 'particle'
+      super key
+    end
+
+    def initials_of(string)
+      string = string.dup
+
+      string.gsub!(/([[:upper:]])[^[:upper:]\s-]*\s*/, "\\1#{initialize_with}")
+
+      initialize_hyphen!(string)
 
+      string.strip!
+      string
+    end
+
+    def initialize_hyphen!(string)
+      if initialize_without_hyphen?
+        string.tr!('-', '')
+      else
+        string.gsub!(/\s*-/, '-')
+      end
+    end
+
+    def existing_initials_of(string)
+      string = string.dup
+
+      string.gsub!(/([[:upper:]])([[:upper:]])/, '\1 \2')
+      string.gsub!(/\b([[:upper:]])\b[^[:alpha:]-]*/, "\\1#{initialize_with}")
+
+      initialize_hyphen!(string)
+
+      string.strip!
+      string
+    end
   end
 
 
@@ -483,7 +562,7 @@ module CiteProc
           @value << Name.new(value)
         when value.respond_to?(:to_s)
           begin
-            @value.concat Namae.parse!(value.to_s)
+            @value.concat Namae.parse!(value.to_s).map { |n| Name.new n }
           rescue
             raise TypeError, $!.message
           end
@@ -635,7 +714,7 @@ module CiteProc
       case
       when truncate?
         [names[0...max_names].join(delimiter), options[:'et-al']].join(truncated_delimiter)
-      when length < 2
+      when length < 3
         names.join(last_delimiter)
       else
         [names[0...-1].join(delimiter), names[-1]].join(last_delimiter)
@@ -644,7 +723,7 @@ module CiteProc
 
     # @return [String] the names in a BibTeX-compatible format
     def to_bibtex
-      map { |n| n.dup.sort_order! }.join(' and ')
+      map { |n| n.dup.sort_order!.format }.join(' and ')
     end
 
     # @return [Array<Hash>] the list of names converted to hash objects

data/lib/citeproc/number.rb

@@ -1,8 +1,10 @@
+# -*- encoding: utf-8 -*-
+
 module CiteProc
   # A CiteProc Variable used for numeric values.
   class Number < Variable
 
-	  MAX_ROMAN = 5000
+    MAX_ROMAN = 5000
 
     FACTORS = [
       ['m', 1000], ['cm', 900], ['d', 500], ['cd', 400],
@@ -11,12 +13,12 @@ module CiteProc
       ['i',    1]
     ].freeze
 
-		class << self
-			def pluralize?(string)
-				/\S\s*[,&-]\s*\S|\df/ === string
-			end
-			
-			# @param number [#to_i] the number to convert
+    class << self
+      def pluralize?(string)
+        /\S[\s,&–-]\S|\df/ === string
+      end
+
+      # @param number [#to_i] the number to convert
       # @return [String] roman equivalent of the passed-in number
       def romanize(number)
         number, roman = number.to_i, ''
@@ -30,7 +32,24 @@ module CiteProc
 
         roman
       end
-		end
+    end
+
+    def <=>(other)
+      case
+      when other.nil?
+        1
+      when numeric?
+        if other.respond_to?(:to_i)
+          to_i <=> other.to_i
+        else
+          nil
+        end
+      when other.is_a?(Variable) || other.is_a?(String)
+        to_s <=> other.to_s
+      else
+        nil
+      end
+    end
   end
 
 end

data/lib/citeproc/processor.rb

@@ -1,33 +1,32 @@
-
 module CiteProc
-  
+
   class Processor
     extend Forwardable
 
     include Abbreviate
     include Converters
-    
+
     @defaults = {
       :locale => 'en-US',
       :style  => 'chicago-author-date',
-      :engine => 'citeproc-js',
-      :format => 'html'
+      :engine => 'citeproc-ruby',
+      :format => 'html',
+      :sort_case_sensitivity => false,
+      :allow_locale_overrides => false
     }.freeze
 
     class << self
       attr_reader :defaults
     end
 
-    attr_reader :options, :items
+    attr_reader :options, :items, :data
     attr_writer :engine
 
-    def_delegators :@locale, :language, :region
-    
     def_delegators :@items, :key?, :value?, :has_key?, :has_value?,
       :include?, :member?, :length, :empty?
-    
+
     def initialize(options = {})
-      @options, @items = Processor.defaults.merge(options), {}
+      @options, @items, @data = Processor.defaults.merge(options), {}, []
       yield self if block_given?
     end
 
@@ -35,46 +34,34 @@ module CiteProc
       @engine ||= Engine.autodetect(options).new(self)
     end
 
-    def style
-      @style || load_style
-    end
-    
-    def locale
-      @locale || load_locale
-    end
-    
-    def load_style(new_style = nil)
-      options[:style] = new_style unless new_style.nil? 
-      @style = Style.open(options[:style])
-    end
-
-    def load_locale(new_locale = nil)
-      options[:locale] = new_locale unless new_locale.nil?
-      @locale = Locale.open(options[:locale])
-    end
-
     def [](id)
-      items[id.to_sym]
+      items[id.to_s]
     end
 
     def []=(id, item)
-      items[id.to_sym] = Item(item)
+      item = Item(item)
+      item.id = id.to_s
+
+      register(items)
     end
-    
+
     def register(item)
       item = Item(item)
-      items[item.to_sym] = item
+
+      data << item
+      items[item.id.to_s] = item
+
     rescue => e
       raise "failed to register item #{item.inspect}: #{e.message}"
     end
-    
+
     def <<(item)
       register(item)
       self
     end
-    
+
     def update(*arguments)
-      arguments.flatten(1).each do |argument|
+      arguments.each do |argument|
         case argument
         when Item
           register(argument)
@@ -82,8 +69,8 @@ module CiteProc
           argument.each { |item| register(item) }
         when Hash
           argument.each do |id, item|
-            id, item = id.to_sym, Item(item)
-        
+            id, item = id.to_s, Item(item)
+
             if items.key?(id) && block_given?
               items[id] = yield items[id], item
             else
@@ -94,12 +81,12 @@ module CiteProc
           raise "failed to register items #{argument.inspect}"
         end
       end
-      
+
       self
     ensure
       # notify engine
     end
-    
+    alias import update
 
 
     def process(*arguments)
@@ -114,9 +101,12 @@ module CiteProc
       engine.bibliography(Selector.new(*arguments, &block))
     end
 
+    def render(mode, *arguments)
+      engine.render(mode, CitationData.new(arguments.flatten(1)))
+    end
+
     def inspect
-      "#<CiteProc::Processor style=#{style.name.inspect} locale=#{locale.name.inspect} items=[#{items.length}]>"
+      "#<CiteProc::Processor style=#{options[:style].inspect} locale=#{options[:locale].inspect} items=[#{items.length}]>"
     end
-    
   end
 end

data/lib/citeproc/selector.rb

@@ -1,128 +1,134 @@
 
 module CiteProc
-	
-	class Selector
-
-		@types = [:all, :any, :none].freeze
-		@matcher = Hash[*@types.zip([:all?, :any?, :none?]).flatten].freeze
-		
-		@rb2cp = Hash[*(@types + [:skip]).zip(%w{
-			select include exclude quash
-		}).flatten]
-		
-		@cp2rb = @rb2cp.invert.freeze
-		@rb2cp.freeze
-		
-		class << self
-			attr_reader :types, :matcher, :rb2cp, :cp2rb
-		end
-		
-		attr_reader :type, :conditions, :skip_conditions, :custom_matcher
-		
-		def initialize(attributes = nil)
-			@conditions, @skip_conditions = {}, {}
-			
-			if block_given?
-				@type = :ruby
-				
-			else
-				unless attributes.nil? || attributes.empty?
-					attributes.symbolize_keys.each_pair do |key, conditions|
-						case key
-						when :all, :any, :none
-							@type = key
-							@conditions.merge!(conditions)
-						
-						when :select, :include, :exclude
-							@type = Selector.cp2rb[key.to_s]
-							@conditions.merge!(conditions)
-						
-						when :skip, :quash
-							@skip_conditions.merge!(conditions)
-						
-						else
-							raise TypeError, "failed to create selector from #{key.inspect}"
-						end
-					end				
-				end
-			end
-			
-		end
-		
-		def initialize_copy(other)
-			@type = other.type
-			@conditions = other.conditions.deep_copy
-			@skip_conditions = other.skip_conditions.deep_copy
-			@custom_matcher = other
-		end
-
-		def type=(type)
-			raise TypeError, "failed to set selector type to #{type.inspect}" unless
-				type.respond_to(:to_sym) && Selector.types.include?(type.to_sym)
-			
-			@type = type.to_sym
-		end
-		
-		def empty?
-			type.nil? && skip_conditions.empty? 
-		end
-
-		def custom_matcher?
-			defined?(@custom_matcher)
-		end
-		
-		alias ruby? custom_matcher?
-		
-		def matches?(item)
-			if custom_matcher?
-				custom_matcher.call(item)
-			else
-				conditions.each_pair.send(matcher) do |field, value|
-					item[field].to_s == value.to_s
-				end
-			end
-		end
-		
-		def skip?(item)
-			if custom_matcher?
-				false # skips are ignored for custom matchers
-			else
-				skip_conditions.each_pair.all? do |field, value|
-					item[field].to_s == value.to_s
-				end
-			end
-		end
-		
-		def to_proc
-			Proc.new { |item| matches?(item) && !skip?(item) }
-		end
-		
-		def to_citeproc
-			return nil if empty? || custom_matcher?
-			
-			cp = {}
-			cp[Selector.rb2cp[type]] = conditions.map do |field, value|
-				{ 'field' => field.to_s, 'value' => value.to_s }
-			end unless conditions.empty?
-			
-			cp['quash'] = skip_conditions.map do |field, value|
-				{ 'field' => field.to_s, 'value' => value.to_s }
-			end unless skip_conditions.empty?
-			
-			cp
-		end
-		
-		def to_json
-			MultiJson.encode(to_citeproc)
-		end
-		
-		private
-				
-		def matcher
-			Selector.matcher[type] || :all?
-		end
-		
-		
-	end
-	
-end
+
+  class Selector
+
+    @types = [:all, :any, :none].freeze
+    @matcher = Hash[*@types.zip([:all?, :any?, :none?]).flatten].freeze
+
+    @rb2cp = Hash[*(@types + [:skip]).zip(%w{
+      select include exclude quash
+    }).flatten]
+
+    @cp2rb = @rb2cp.invert.freeze
+    @rb2cp.freeze
+
+    class << self
+      attr_reader :types, :matcher, :rb2cp, :cp2rb
+    end
+
+    attr_reader :type, :conditions, :skip_conditions, :custom_matcher
+
+    def initialize(attributes = nil)
+      @conditions, @skip_conditions = {}, {}
+
+      if block_given?
+        @type = :ruby
+
+      else
+        unless attributes.nil? || attributes.empty?
+          attributes.symbolize_keys.each_pair do |key, conditions|
+            conditions = convert_conditions(conditions) if conditions.is_a?(Array)
+
+            case key
+            when :all, :any, :none
+              @type = key
+              @conditions.merge!(conditions)
+
+            when :select, :include, :exclude
+              @type = Selector.cp2rb[key.to_s]
+              @conditions.merge!(conditions)
+
+            when :skip, :quash
+              @skip_conditions.merge!(conditions)
+
+            else
+              raise TypeError, "failed to create selector from #{key.inspect}"
+            end
+          end
+        end
+      end
+    end
+
+    def initialize_copy(other)
+      @type = other.type
+      @conditions = other.conditions.deep_copy
+      @skip_conditions = other.skip_conditions.deep_copy
+      @custom_matcher = other
+    end
+
+    def type=(type)
+      raise TypeError, "failed to set selector type to #{type.inspect}" unless
+        type.respond_to(:to_sym) && Selector.types.include?(type.to_sym)
+
+      @type = type.to_sym
+    end
+
+    def empty?
+      type.nil? && skip_conditions.empty?
+    end
+
+    def custom_matcher?
+      defined?(@custom_matcher)
+    end
+
+    alias ruby? custom_matcher?
+
+    def matches?(item)
+      if custom_matcher?
+        custom_matcher.call(item)
+      else
+        conditions.each_pair.send(matcher) do |field, value|
+          item[field].to_s == value.to_s
+        end
+      end
+    end
+
+    def skip?(item)
+      if custom_matcher? || skip_conditions.empty?
+        false # skips are ignored for custom matchers
+      else
+        skip_conditions.each_pair.all? do |field, value|
+          item[field].to_s == value.to_s
+        end
+      end
+    end
+
+    def to_proc
+      Proc.new { |item| matches?(item) && !skip?(item) }
+    end
+
+    def to_citeproc
+      return nil if empty? || custom_matcher?
+
+      cp = {}
+      cp[Selector.rb2cp[type]] = conditions.map do |field, value|
+        { 'field' => field.to_s, 'value' => value.to_s }
+      end unless conditions.empty?
+
+      cp['quash'] = skip_conditions.map do |field, value|
+        { 'field' => field.to_s, 'value' => value.to_s }
+      end unless skip_conditions.empty?
+
+      cp
+    end
+
+    def to_json
+      ::JSON.dump(to_citeproc)
+    end
+
+    private
+
+    def matcher
+      Selector.matcher[type] || :all?
+    end
+
+    # Converts a CiteProc-JS style conditions list into
+    # a conditions Hash.
+    def convert_conditions(conditions)
+      Hash[conditions.map { |c| [c['field'], c['value']] }]
+    end
+
+  end
+
+end