citeproc 1.0.0.pre12 → 1.0.0

data/lib/citeproc/citation_data.rb

@@ -1,219 +1,244 @@
 module CiteProc
 
-	# A {CitationItem} consititues the main input elements to CiteProc's
-	# processing methods. In order to be processed correctly, an item must
-	# have a valid {#id} attribute used to retrieve the correpsonding {Item}
-	# containing the actual bibliographic data.
-	class CitationItem
-
-		include Attributes
+  # A {CitationItem} consititues the main input elements to CiteProc's
+  # processing methods. In order to be processed correctly, an item must
+  # have a valid {#id} attribute used to retrieve the correpsonding {Item}
+  # containing the actual bibliographic data.
+  class CitationItem
+
+    extend Forwardable
+    include Attributes
+    include Comparable
+
+    @labels = [
+      :book, :chapter, :column, :figure, :folio, :issue, :line, :note, :opus,
+      :page, :paragraph, :part, :section, :'sub-verbo', :verse, :volume
+    ].freeze
+
+    class << self
+      attr_reader :labels
+    end
 
-		@labels = [
-			:book, :chapter, :column, :figure, :folio, :issue, :line, :note, :opus,
-			:page, :paragraph, :part, :section, :'sub-verbo', :verse, :volume
-		].freeze
+    # @!attribute id
+    # @return [Symbol,String] the id of the corresponding resource
 
-		class << self
-			attr_reader :labels
-		end
+    # @!attribute locator
+    # @return [String] a string identifying a page number or similar to mark
+    #   a location or range within the resource
 
-		# @!attribute id
-		# @return [Symbol,String] the id of the corresponding resource
+    # @!attribute label
+    # Labels indicate whether the current locator is to a page, a chapter,
+    # or other subdivision of the target resource. Valid labels are defined
+    # by {.labels}.
+    # @return [Symbol,String] the label type
 
-		# @!attribute locator
-		# @return [String] a string identifying a page number or similar to mark
-		#   a location or range within the resource
+    # @!attribute suppress_author
+    # @return [Boolean] whether or not author names will not be included
+    #   in the citation output for this cite
 
-		# @!attribute label
-		# Labels indicate whether the current locator is to a page, a chapter,
-		# or other subdivision of the target resource. Valid labels are defined
-		# by {.labels}.
-		# @return [Symbol,String] the label type
+    # @!attribute author_only
+    # This optional parameter provides a means for certain demanding styles
+    # that require the processor output to be divided between the main text
+    # and a footnote.
+    # @return [Boolean] whether or not only the author name will be included
+    #   in the citation output for this cite
 
-		# @!attribute suppress_author
-		# @return [Boolean] whether or not author names will not be included
-		#   in the citation output for this cite
+    # @!attribute prefix
+    # @return [String] a string to print before cites produced for this item
 
-  	# @!attribute author_only
-  	# This optional parameter provides a means for certain demanding styles
-  	# that require the processor output to be divided between the main text
-  	# and a footnote.
-  	# @return [Boolean] whether or not only the author name will be included
-  	#   in the citation output for this cite
+    # @!attribute suffix
+    # @return [String] a string to print after cites produced for this item
 
-  	# @!attribute prefix
-  	# @return [String] a string to print before cites produced for this item
+    attr_predicates :id, :locator, :page, :label, :'suppress-author',
+      :'author-only', :prefix, :suffix
 
-  	# @!attribute suffix
-  	# @return [String] a string to print after cites produced for this item
+    # Attributes added by processor
+    attr_predicates :sortkeys, :postion, :'first-reference-note-number',
+      :'near-note', :unsorted
 
-		attr_predicates :id, :locator, :page, :label, :'suppress-author',
-			:'author-only', :prefix, :suffix
+    attr_accessor :data
 
-		# Attributes added by processor
-		attr_predicates :sortkeys, :postion, :'first-reference-note-number',
-			:'near-note', :unsorted
+    def_delegators :@data, :suppressed?, :suppress!,
+      :language, :english?, :en?
 
-		attr_accessor :data
+    def initialize(attributes = nil)
+      merge(attributes)
+      yield self if block_given?
+    end
 
-		def initialize(attributes = nil)
-			merge(attributes)
-		end
+    def initialize_copy(other)
+      @attributes = other.attributes.deep_copy
+    end
 
-		def initialize_copy(other)
-			@attributes = other.attributes.deep_copy
-		end
+    def <=>(other)
+      return unless other.respond_to?(:data)
+      data <=> other.data
+    end
 
-		# @return [String] a human-readable representation of the citation item
-		def inspect
-			"#<CiteProc::CitationItem #{id.to_s.inspect}, #{locator.to_s.inspect}>"
-		end
+    # @return [String] a human-readable representation of the citation item
+    def inspect
+      "#<CiteProc::CitationItem #{[id, locator].compact.map(&:inspect).join(', ')}>"
+    end
 
-	end
+  end
 
 
 
 
-	class CitationData
+  class CitationData
 
-		extend Forwardable
-		include Enumerable
+    extend Forwardable
+    include Enumerable
 
-		@defaults = {
-			:footnote => 0
-		}.freeze
+    @defaults = {
+      :footnote => 0
+    }.freeze
 
-		@rb2cp = {
-			:id => 'citationID',
-			:items => 'citationItems',
-			:sorted_items => 'sortedItems',
-			:footnote => 'noteIndex',
-			:options => 'properties'
-		}
+    @rb2cp = {
+      :id => 'citationID',
+      :items => 'citationItems',
+      :sorted_items => 'sortedItems',
+      :footnote => 'noteIndex',
+      :options => 'properties'
+    }
 
-		@cp2rb = @rb2cp.invert.freeze
-		@rb2cp.freeze
+    @cp2rb = @rb2cp.invert.freeze
+    @rb2cp.freeze
 
-		class << self
-			attr_reader :defaults, :cp2rb, :rb2cp
-		end
+    class << self
+      attr_reader :defaults, :cp2rb, :rb2cp
+    end
 
-		attr_accessor :id
+    attr_accessor :id
 
-		attr_reader :items, :options, :sorted_items
+    attr_reader :items, :options, :sorted_items
 
-		alias properties options
+    alias properties options
 
-		def_delegators :@items, :length, :empty?, :[]
+    def_delegators :@items, :length, :empty?, :[]
 
-		# Some delegators should return self
-		[:push, :<<, :unshift, :concat].each do |m|
-			define_method(m) do |*arguments|
-				names.send(m, *arguments)
-				self
-			end
-		end
+    # Some delegators should return self
+    [:push, :<<, :unshift, :concat].each do |m|
+      define_method(m) do |*arguments|
+        names.send(m, *arguments)
+        self
+      end
+    end
 
-		def initialize(attributes = nil, options = {})
-			@options = CitationData.defaults.merge(options)
-			@items, @sorted_items = [], []
-			merge(attributes)
-		end
+    def initialize(attributes = nil, options = {})
+      @options = CitationData.defaults.merge(options)
+      @items, @sorted_items = [], []
+      merge(attributes)
+    end
 
-		def initialize_copy(other)
-			@options = other.options.dup
-			@items = other.items.map(&:dup)
-			@sorted_items = other.items.map(&:dup)
-			@id = other.id.dup if other.processed?
-		end
+    def initialize_copy(other)
+      @options = other.options.dup
+      @items = other.items.map(&:dup)
+      @sorted_items = other.items.map(&:dup)
+      @id = other.id.dup if other.processed?
+    end
 
     def merge(other)
       return self if other.nil?
 
       case other
       when String, /^\s*\{/
-        other = MulitJson.decode(other, :symbolize_keys => true)
+        other = JSON.parse(other, :symbolize_names => true)
       when Hash
-				# do nothing
-			when Array
-				other = { :items => other }
+        # do nothing
+      when Array
+        other = { :items => other }
       when Attributes
         other = other.to_hash
-			else
-				raise ParseError, "failed to merge citation data and #{other.inspect}"
+      else
+        raise ParseError, "failed to merge citation data and #{other.inspect}"
       end
 
-			other = convert_from_citeproc(other)
+      other = convert_from_citeproc(other)
 
-			items.concat(Array(other.delete(:items)).map { |i| CitationItem.create!(i) })
-			sorted_items.concat(Array(other.delete(:sorted_items)))
+      items.concat(Array(other.delete(:items)).map { |i| CitationItem.create!(i) })
+      sorted_items.concat(Array(other.delete(:sorted_items)))
 
-			properties = other.delete(:options)
-			options.merge!(convert_from_citeproc(Hash[properties])) unless properties.nil?
+      properties = other.delete(:options)
+      options.merge!(convert_from_citeproc(Hash[properties])) unless properties.nil?
 
-			@id = other[:id] if other.has_key?(:id)
+      @id = other[:id] if other.has_key?(:id)
 
       self
     end
 
-		alias update merge
+    alias update merge
 
-		def each
-			if block_given?
-				items.each(&Proc.new)
-				self
-			else
-				to_enum
-			end
-		end
+    def each
+      if block_given?
+        if sorted?
+          sorted_items.each(&Proc.new)
+        else
+          items.each(&Proc.new)
+        end
 
-		def processed?
-			!!id
-		end
+        self
+      else
+        to_enum
+      end
+    end
 
-		def index
-			options[:footnote]
-		end
+    def processed?
+      !!id
+    end
 
-		def footnote?
-			options[:footnote] > 0
-		end
+    def sorted?
+      !sorted_items.empty?
+    end
 
-		def to_citeproc
-			cp = {}
+    def sort!(&block)
+      @sorted_items = items.sort(&block)
+      self
+    end
 
-			cp[CitationData.rb2cp[:items]] = items.map(&:to_citeproc)
-			cp[CitationData.rb2cp[:options]] = { CitationData.rb2cp[:footnote] => index }
+    def index
+      options[:footnote]
+    end
 
-			cp[CitationData.rb2cp[:id]] = id if processed?
+    def footnote?
+      options[:footnote] > 0
+    end
 
-			cp
-		end
+    def to_citeproc
+      cp = {}
 
-		def to_json
-			MultiJson.encode(to_citeproc)
-		end
+      cp[CitationData.rb2cp[:items]] = items.map(&:to_citeproc)
+      cp[CitationData.rb2cp[:options]] = { CitationData.rb2cp[:footnote] => index }
 
-		alias to_s to_json
+      cp[CitationData.rb2cp[:id]] = id if processed?
 
-		# @return [String] a human-readable representation of the citation data
-		def inspect
-			"#<CiteProc::CitationData items=[#{length}]>"
-		end
+      cp
+    end
 
-		private
+    def to_json
+      ::JSON.dump(to_citeproc)
+    end
 
-		def convert_from_citeproc(hash)
-			hash = hash.symbolize_keys
+    alias to_s to_json
 
-			CitationData.cp2rb.each do |cp, rb|
-				cp = cp.to_sym
-				hash[rb] = hash.delete(cp) if hash.has_key?(cp)
-			end
+    # @return [String] a human-readable representation of the citation data
+    def inspect
+      "#<CiteProc::CitationData items=[#{length}]>"
+    end
+
+    private
+
+    def convert_from_citeproc(hash)
+      hash = hash.symbolize_keys
 
-			hash
-		end
+      CitationData.cp2rb.each do |cp, rb|
+        cp = cp.to_sym
+        hash[rb] = hash.delete(cp) if hash.has_key?(cp)
+      end
+
+      hash
+    end
 
-	end
+  end
 
-end
+end

data/lib/citeproc/compatibility.rb

@@ -1,91 +1,5 @@
 # -*- coding: utf-8 -*-
 
-unless Symbol.is_a?(Comparable)
-  class Symbol
-    include Comparable
-
-    def =~(pattern)
-      to_s =~ pattern
-    end
-
-    def <=>(other)
-      return nil unless other.is_a?(Symbol)
-      to_s <=> other.to_s
-    end
-  end
-end
-
-
-
-if RUBY_VERSION < '1.9'
-  require 'enumerator'
-
-  $KCODE = 'u'
-  require 'jcode'
-
-  module CiteProc
-
-    def to_unicode(string)
-      string.gsub(/\\?u([\da-f]{4})/i) { |m| [$1.to_i(16)].pack('U') }
-    end
-
-    def ruby_18
-      yield
-    end
-
-    def ruby_19
-      false
-    end
-    
-    begin
-      require 'oniguruma'
-      
-      def oniguruma
-        Oniguruma::ORegexp.new(yield, :syntax => Oniguruma::SYNTAX_JAVA, :encoding => Oniguruma::ENCODING_UTF8)
-      end
-      
-      def oniguruma?
-        true
-      end
-    rescue LoadError
-      def oniguruma
-        false
-      end
-      alias oniguruma? oniguruma
-    end
-  end
-
-  # Remove the 'id' and 'type' methods in Ruby 1.8
-  class Object
-    undef_method :id
-    undef_method :type
-  end
-
-else
-
-  module CiteProc
-    def to_unicode(string)
-      string
-    end
-
-    def ruby_18
-      false
-    end
-
-    def ruby_19
-      yield
-    end
-    
-    def oniguruma
-      Regexp.new(yield)
-    end
-    
-    def oniguruma?
-      true
-    end
-  end
-end
-
 #
 # Robust unicode upcase/downcase
 #
@@ -94,13 +8,9 @@ if RUBY_PLATFORM =~ /java/i
   require 'java'
 
   puts java.lang.System.getProperty('file.encoding')
-  
+
   module CiteProc
-    
-    def jruby
-      yield
-    end
-    
+
     def upcase(string)
       java.lang.String.new(string).to_upper_case(java.util.Locale::ENGLISH).to_s
     end
@@ -108,23 +18,11 @@ if RUBY_PLATFORM =~ /java/i
     def downcase(string)
       java.lang.String.new(string).to_lower_case(java.util.Locale::ENGLISH).to_s
     end
-    
-    # def oniguruma
-    #   Regexp.new(yield)
-    # end
-    # 
-    # def oniguruma?
-    #   true
-    # end
   end
 
 else
 
-  module CiteProc    
-    
-    def jruby
-      false
-    end
+  module CiteProc
 
     begin
       require 'unicode'
@@ -157,7 +55,7 @@ else
 
           def downcase(string)
             ActiveSupport::Multibyte::Chars.new(string).downcase.to_s
-          end    
+          end
         rescue LoadError
 
           def upcase(string)
@@ -174,6 +72,5 @@ else
 end
 
 module CiteProc
-  module_function :ruby_18, :ruby_19, :oniguruma, :oniguruma?,
-    :to_unicode, :upcase, :downcase
+  module_function :upcase, :downcase
 end