citeproc 1.0.0.pre12 → 1.0.0

data/lib/citeproc/abbreviate.rb

@@ -10,9 +10,9 @@ module CiteProc
 		def abbreviations=(abbreviations)
 			@abbreviations = case abbreviations
 				when ::String
-					MultiJson.decode(abbreviations, :symbolize_keys => true)
+					::JSON.parse(abbreviations, :symbolize_names => true)
 				when ::Hash
-					abbreviations.deep_copy
+					abbreviations.deep_copy.symbolize_keys
 				else
 					raise ArgumentError, "failed to set abbreviations from #{abbreviations.inspect}"
 				end
@@ -20,11 +20,12 @@ module CiteProc
 
 		# @overload abbreviate(namespace = :default, context, word)
 		def abbreviate(*arguments)
-			raise ArgumentError, "wrong number of arguments (#{arguments.length} for 2..3)" unless (2..3).include?(arguments.length)
+			raise ArgumentError, "wrong number of arguments (#{arguments.length} for 2..3)" unless
+        (2..3).include?(arguments.length)
+
 			arguments.unshift(namespace || :default) if arguments.length < 3
 			@abbreviations.deep_fetch(*arguments)
 		end
-
 		alias abbrev abbreviate
 
 	end

data/lib/citeproc/assets.rb

@@ -1,113 +1,113 @@
 module CiteProc
 
-	module Asset
-
-		def self.included(base)
-			base.extend(ClassMethods)
-		end
-
-		attr_reader :asset, :location
-		
-		def open?
-			!asset.nil?
-		end
-		
-		def open(input)
-			case
-			when input.respond_to?(:read)
-				@location = nil
-				@asset = input.read
-			when input.to_s =~ /^\s*</
-				@location = nil
-				@asset = input.to_s.dup
-			else
-				case
-				when File.exists?(input)
-					@location = input
-				when File.exists?(self.class.extend_name(input))
-					@location = self.class.extend_name(input)
-				when File.exists?(self.class.extend_path(input))
-					@location = self.class.extend_path(input)
-				else
-					@location = input
-				end
-
-				Kernel.open(@location, 'r:UTF-8') do |io|
-					@asset = io.read
-				end
-			end
-			
-			self
-		rescue => e
-			raise ArgumentError, "failed to open asset #@location (#{input.inspect}): #{e.message}"
-		end
-
-		def name
-			File.basename(location, self.class.extension).sub(Regexp.new("^#{self.class.prefix}"), '')
-		end
-		
-		alias to_s asset
-
-		def inspect
-			"#<CiteProc::#{self.class.name} #{name}>"
-		end
-		
-		module ClassMethods
-
-			attr_accessor :root, :extension, :prefix
-
-			def open(path_or_name)
-				new.open(path_or_name)
-			end
-
-			def extend_path(input)
-				File.join(root.to_s, extend_name(input))
-			end
-			
-			def extend_name(input)
-				if File.extname(input) != extension
-				  name = [input, extension].compact.join
-				else
-				  name = input.to_s.dup
-				end
-				
-				unless name.start_with?(prefix.to_s)
-				  name = [prefix, name].join
-				end
-				
-				name
-			end
-
-		end
-
-	end
-
-	class Style
-		
-		include Asset
-		
-		@root = '/usr/local/share/citation-style-language/styles'.freeze
-		@extension = '.csl'.freeze
-		
-	end
-
-	class Locale
-		
-		include Asset
-		
-		@root = '/usr/local/share/citation-style-language/locales'.freeze
-		@extension = '.xml'.freeze
-		@prefix = 'locales-'.freeze
-		
-		
-		def language
-			name.split('-')[0]
-		end
-		
-		def region
-			name.split('-')[1]
-		end
-		
-	end
+  module Asset
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    attr_reader :asset, :location
+
+    def open?
+      !asset.nil?
+    end
+
+    def open(input)
+      case
+      when input.respond_to?(:read)
+        @location = nil
+        @asset = input.read
+      when input.to_s =~ /^\s*</
+        @location = nil
+        @asset = input.to_s.dup
+      else
+        case
+        when File.exists?(input)
+          @location = input
+        when File.exists?(self.class.extend_name(input))
+          @location = self.class.extend_name(input)
+        when File.exists?(self.class.extend_path(input))
+          @location = self.class.extend_path(input)
+        else
+          @location = input
+        end
+
+        Kernel.open(@location, 'r:UTF-8') do |io|
+          @asset = io.read
+        end
+      end
+
+      self
+    rescue => e
+      raise ArgumentError, "failed to open asset #@location (#{input.inspect}): #{e.message}"
+    end
+
+    def name
+      File.basename(location, self.class.extension).sub(Regexp.new("^#{self.class.prefix}"), '')
+    end
+
+    alias to_s asset
+
+    def inspect
+      "#<CiteProc::#{self.class.name} #{name}>"
+    end
+
+    module ClassMethods
+
+      attr_accessor :root, :extension, :prefix
+
+      def open(path_or_name)
+        new.open(path_or_name)
+      end
+
+      def extend_path(input)
+        File.join(root.to_s, extend_name(input))
+      end
+
+      def extend_name(input)
+        if File.extname(input) != extension
+          name = [input, extension].compact.join
+        else
+          name = input.to_s.dup
+        end
+
+        unless name.start_with?(prefix.to_s)
+          name = [prefix, name].join
+        end
+
+        name
+      end
+
+    end
+
+  end
+
+  class Style
+
+    include Asset
+
+    @root = '/usr/local/share/citation-style-language/styles'.freeze
+    @extension = '.csl'.freeze
+
+  end
+
+  class Locale
+
+    include Asset
+
+    @root = '/usr/local/share/citation-style-language/locales'.freeze
+    @extension = '.xml'.freeze
+    @prefix = 'locales-'.freeze
+
+
+    def language
+      name.split('-')[0]
+    end
+
+    def region
+      name.split('-')[1]
+    end
+
+  end
 
 end

data/lib/citeproc/attributes.rb

@@ -23,16 +23,16 @@ module CiteProc
     def write_attribute(key, value)
       attributes[filter_key(key)] = filter_value(value, key)
     end
-		alias []= write_attribute
+    alias []= write_attribute
 
-		def attribute?(key)
-			value = read_attribute key
+    def attribute?(key)
+      value = read_attribute key
 
-			return false if value.nil?
-			return false if value.respond_to?(:empty?) && value.empty?
+      return false if value.nil?
+      return false if value.respond_to?(:empty?) && value.empty?
 
-			value.to_s !~ /^(false|no|never)$/i
-		end
+      value.to_s !~ /^(false|no|never)$/i
+    end
 
     def filter_key(key)
       key.to_sym
@@ -49,7 +49,7 @@ module CiteProc
 
       case
       when other.is_a?(String) && /^\s*\{/ =~ other
-        other = MultiJson.decode(other, :symbolize_keys => true)
+        other = ::JSON.parse(other, :symbolize_names => true)
       when other.respond_to?(:each_pair)
         # do nothing
       when other.respond_to?(:to_hash)
@@ -83,7 +83,7 @@ module CiteProc
 
     # @return [String] a JSON string representation of the attributes
     def to_json
-      MultiJson.encode(to_citeproc)
+      ::JSON.dump(to_citeproc)
     end
 
     # Don't expose internals to public API
@@ -173,7 +173,7 @@ module CiteProc
         predicate_id = [method_id, '?'].join
         if predicate && !instance_methods.include?(predicate_id)
           define_method(predicate_id) do
-						attribute?(field)
+            attribute?(field)
           end
 
           has_predicate = ['has_', predicate_id].join
@@ -184,4 +184,4 @@ module CiteProc
     end
 
   end
-end
+end

data/lib/citeproc/bibliography.rb

@@ -13,30 +13,30 @@ module CiteProc
 
     @defaults = {
       :offset => 0,
-      :entry_spacing => 0,
-      :line_spacing => 0,
-      :indent => 0,
-      :align => false
+      :'entry-spacing' => 1,
+      :'line-spacing' => 1,
+      :'hanging-indent' => false,
+      :'second-field-align' => false
     }.freeze
-    
-    
+
+
     # citeproc-js and csl attributes are often inconsistent or difficult
     # to use as symbols/method names, so we're using different names at the
     # cost of making conversion to and from the json format more difficult
-    
+
     @cp2rb = {
       'maxoffset' => :offset,
-      'entryspacing' => :entry_spacing,
-      'linespacing' => :line_spacing,
-      'hangingindent' => :indent,
-      'second-field-align' => :align
+      'entryspacing' => :'entry-spacing',
+      'linespacing' => :'line-spacing',
+      'hangingindent' => :'hanging-indent',
+      'second-field-align' => :'second-field-align'
     }
-    
+
     @rb2cp = @cp2rb.invert.freeze
     @cp2rb.freeze
-    
+
     class << self
-      
+
       # @!attribute [r] defaults
       # @example Default Formatting Options
       #   {
@@ -54,19 +54,17 @@ module CiteProc
       #     # string should use this value to calculate and apply a suitable
       #     # indentation length.
       #
-      #     :entry_spacing => 0,
+      #     :'entry-spacing' => 1,
       #     # An integer representing the spacing between entries in the
       #     # bibliography.
       #
-      #     :line_spacing => 0,
+      #     :'line-spacing' => 1,
       #     # An integer representing the spacing between the lines within
       #     # each bibliography entry.
       #
-      #     :indent => 0,
-      #     # The number of em-spaces to apply in hanging indents within the
-      #     # bibliography.
+      #     :'hanging-indent' => false,
       #
-      #     :align => false
+      #     :'second-field-align' => false
       #     # When the second-field-align CSL option is set, this returns
       #     # either "flush" or "margin". The calling application should
       #     # align text in the bibliography output as described by the CSL
@@ -77,105 +75,143 @@ module CiteProc
       attr_reader :defaults
 
       attr_reader :cp2rb, :rb2cp
-      
+
       # Create a new Bibliography from the passed-in string or array, or nil
       # if the input cannot be parsed.
-      def create(input)
-        create!(input)
+      def create(input, &block)
+        create!(input, &block)
       rescue
         nil
       end
-      
+
       # Create a new Bibliography from the passed-in string or array. Raises
       # ParseError if the input cannot be parsed.
       def create!(input)
         case
         when input.is_a?(String)
-          create!(MultiJson.decode(input))
-          
+          create!(::JSON.parse(input))
+
+        when input.is_a?(Hash)
+          create!([input])
+
         when input.is_a?(Array) && input.length == 2
           options, references = input
 
           new do |b|
-            b.concat(references)
+            b.references.concat(references)
+            b.ids.concat(options.fetch('entry_ids', []))
             b.errors.concat(options.fetch('bibliography_errors', []))
-            
-            b.prefix, b.suffix = options['bibstart'], options['bibend']
-            
+
+            b.header, b.footer = options['bibstart'], options['bibend']
+
             (options.keys & cp2rb.keys).each do |k|
               b.options[cp2rb[k]] = options[k]
             end
+
+            yield b if block_given?
           end
-        
+
         else
           raise ParseError, "failed to create Bibliography from #{input.inspect}"
         end
       end
-      
+
     end
-    
+
     include Comparable
     include Enumerable
-        
+
     extend Forwardable
 
     # @!attribute [r] refrences
     # @return [Array<String>] the list of references
     attr_reader :references
-    
+
+    attr_reader :ids
+
     # @!attribute [r] options
     # @see .defaults
     # @return [Hash] the current formatting options
     attr_reader :options
-    
+
     # @!attribute [r] errors
-    # @todo not implemented yet
     # @return [Array<String>] a list of errors
     attr_reader :errors
 
-    # @!attribute prefix
+    # @!attribute header
     # @return [String] content included before the reference list
-    attr_accessor :prefix, :suffix
+    attr_accessor :header
 
-    # @!attribute suffix
+    # @!attribute footer
     # @return [String] content included after the reference list
-    attr_accessor :suffix
+    attr_accessor :footer
 
+    # @!attribute prefix
+    # @return [String] content included before each reference
+    attr_accessor :prefix
+
+    # @!attribute suffix
+    # @return [String] content included after each reference
+    attr_accessor :suffix
 
     # Bibliographies quack sorta like an Array
-    def_delegators :@references, :length, :empty?, :[], :include?, :index
+    def_delegators :@references, :length, :empty?
+
+    attr_accessor :connector
 
-    # Some delegators should return self
-    [:push, :<<, :unshift, :concat].each do |m|
-      define_method(m) do |*arguments, &block|
-        references.send(m, *arguments, &block)
-        self
-      end
-    end
-    
-    
     def initialize(options = {})
       @options = Bibliography.defaults.merge(options)
-      @errors, @references = [], []
-      
+      @errors, @references, @ids, @connector = [], [], [], "\n"
+
       yield self if block_given?
     end
-    
+
     def initialize_copy(other)
-      @options = other.options.dup
-      @errors, @references = other.errors.dup, other.references.dup
+      @options, @connector = other.options.dup, other.connector.dup
+      @errors, @references, @ids = other.errors.dup, other.references.dup, other.ids.dup
+    end
+
+    def push(id, reference)
+      ids << id
+      references << reference
+      self
     end
+    alias << push
 
     def has_errors?
       !errors.empty?
     end
-    
+
     alias errors? has_errors?
-    
-    def join(connector = "\n")
-      [prefix, references.join(connector), suffix].compact.join
+
+    def entry_spacing
+      options[:'entry-spacing'].to_f
+    end
+
+    def line_spacing
+      options[:'line-spacing'].to_f
     end
-    
+
+    def hanging_indent?
+      options[:'hanging_indent']
+    end
+
+    def join()
+      [
+        header,
+
+        references.map { |r|
+          [prefix, r, suffix].compact.join('')
+        }.join(connector),
+
+        footer
+      ].compact.join(connector)
+    end
+
+    def to_s
+      join
+    end
+
     def each
       if block_given?
         references.each(&Proc.new)
@@ -184,7 +220,7 @@ module CiteProc
         to_enum
       end
     end
-    
+
     def <=>(other)
       return nil unless other.respond_to?(:references)
       references <=> other.references
@@ -195,29 +231,29 @@ module CiteProc
           [Bibliography.rb2cp[k] || k.to_s, v]
         }.flatten]
     end
-    
+
     def to_citeproc
       [
-        citeproc_options.merge({    
+        citeproc_options.merge({
           'bibstart' => prefix,
           'bibend' => suffix,
           'bibliography_errors' => errors
         }),
-        
+
         references
-        
+
       ]
     end
-    
+
     def to_json
-      MultiJson.encode(to_citeproc)
+      ::JSON.dump(to_citeproc)
     end
-    
+
     # @return [String] a human-readable representation of the bibliography
     def inspect
       "#<CiteProc::Bibliography @references=[#{references.length}], @errors=[#{errors.length}]>"
     end
-    
+
   end
-  
+
 end