citeproc 0.0.2 → 0.0.3

data/.rspec

@@ -1,2 +1,3 @@
 --color
+--require spec_helper
 

data/README.md

@@ -1,2 +1,4 @@
 CiteProc
 ========
+
+The CiteProc gem is a Ruby abstraction layer for the JSON API used by citeproc-js. To process citations you also require a dedicate processor engine available as a separate gem: these will include citeproc-js, citeproc-ruby and eventually citeproc-hs. As work on these packages is still in progress, please be aware of the following caveats: the 0.0.2 release of citeproc-ruby is still a standalone package and will conflict with this release of citeproc; support will be added in future versions. The citeproc-js gem currently works only in JRuby (using an embedded version of the Rhino JavaScript interpreter) but is going to support other versions of Ruby using different JavaScript runtimes.

data/auto.watchr

@@ -18,3 +18,5 @@ def run (cmd)
   puts cmd
   system cmd
 end
+
+rspec 'spec'

data/lib/citeproc.rb

@@ -12,8 +12,24 @@ require 'citeproc/errors'
 
 require 'citeproc/abbreviate'
 require 'citeproc/attributes'
+
 require 'citeproc/variable'
 require 'citeproc/date'
+require 'citeproc/names'
+
+CiteProc::Variable.class_eval do
+	@factories = Hash.new { |h,k| h.fetch(k.to_sym, CiteProc::Variable) }.merge(
+		Hash[*@types.map { |n,k|
+			[n, CiteProc.const_get(k.to_s.capitalize)]
+		}.flatten]
+	).freeze
+end
+
+require 'citeproc/item'
+require 'citeproc/citation_data'
+require 'citeproc/selector'
+require 'citeproc/bibliography'
+require 'citeproc/assets'
 
 require 'citeproc/engine'
 require 'citeproc/processor'

data/lib/citeproc/assets.rb

@@ -0,0 +1,66 @@
+require 'uri'
+
+module CiteProc
+  module Asset
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+    
+    attr_accessor :asset
+    
+    alias to_s asset
+
+    def inspect
+      to_s.inspect
+    end
+    
+    module ClassMethods
+      
+      attr_accessor :root, :extension, :prefix
+      
+      def load(asset)
+        instance = new
+        case
+        when File.exists?(asset)
+          instance.asset = read(asset)
+        when File.exists?(File.join(root.to_s, extend_name(asset)))
+          instance.asset = read(File.join(root.to_s, extend_name(asset)))
+        else
+          instance.asset = asset
+        end
+        instance
+      end
+      
+      private
+
+      def read(name)
+        io = open(name, 'r:UTF-8')
+        io.read
+      ensure
+        io.close
+      end
+
+      def extend_name(file)
+        file = File.extname(file).empty? ? [file, extension].compact.join : file
+        file = file.start_with?(prefix.to_s) ? file : [prefix,file].join
+        file
+      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-'
+  end
+    
+end

data/lib/citeproc/attributes.rb

@@ -1,9 +1,16 @@
 
 module CiteProc
   
+	# TODO refactor using a Struct instead of a hash. This will have to convert
+	# the CiteProc/CSL names which are no proper method names.
+	
+	
   module Attributes
     extend Forwardable
     
+
+		FALSE_PATTERN = (/^(false|no|never)$/i).freeze
+		
     def self.included(base)
       base.extend(ClassMethods)
     end
@@ -12,37 +19,105 @@ module CiteProc
       @attributes ||= {}
     end
     
+		def_delegators :attributes, :length, :empty?
+
+		def [](key)
+			attributes[filter_key(key)]
+		end
+		
+		def []=(key, value)
+			attributes[filter_key(key)] = filter_value(value)
+		end
+		
+		def filter_key(key)
+			key.to_sym
+		end
+		
+		def filter_value(value, key = nil)
+			value.respond_to?(:deep_copy) ? value.deep_copy : value.dup
+		rescue
+			value
+		end
+		
     def merge(other)
       return self if other.nil?
       
       case other
       when String, /^\s*\{/
-        other = MulitJson.encode(other, :symbolize_keys => true)
+        other = MulitJson.decode(other, :symbolize_keys => true)
       when Hash
-        other = other.deep_copy
-      else
+				# do nothing
+      when Attributes
         other = other.to_hash
+			else
+				raise ParseError, "failed to merge attributes and #{other.inspect}"
       end
 
-      other.each_pair { |k,v| attributes[k.to_sym] = v }
+      other.each_pair do |key, value|
+				attributes[filter_key(key)] = filter_value(value, key)
+			end
       
       self
     end
 
     alias update merge
     
-    def reverse_merge(other)
-      other.merge(self)
-    end
+		def reverse_merge(other)
+			fail "not implemented yet"
+		end
+
+		def to_hash
+			attributes.deep_copy
+		end
+
+		def to_citeproc
+			Hash[*attributes.map { |k,v|
+				[k.to_s, v.respond_to?(:to_citeproc) ? v.to_citeproc : v.to_s]
+			}.flatten(1)]
+		end
+		
+		def to_json
+			MultiJson.encode(to_citeproc)
+		end
 
-    alias to_hash attributes
+		# Don't expose internals to public API
+		private :filter_key, :filter_value
+		
+		# initialize_copy should be able to access attributes
+		protected :attributes
+		
 
+	
+		# def eql?(other)
+		# 	case
+		# 	when equal?(other)
+		# 		true
+		# 	when self.class != other.class, length != other.length
+		# 		false
+		# 	else
+		# 		other.attributes.each_pair do |key, value|
+		# 			return false unless attributes[key].eql?(value)
+		# 		end
+		# 		
+		# 		true
+		# 	end
+		# end
+		# 
+		# def hash
+		# end
+		
     module ClassMethods
 
-      def create(parameters)
-        new.merge(parameters)
-      end
-      
+			def create(parameters)
+				create!(parameters)
+			rescue
+				nil
+			end
+
+			def create!(parameters)
+				new.merge(parameters)
+			end
+
       def attr_predicates(*arguments)
         arguments.flatten.each do |field|
           field, default = *(field.is_a?(Hash) ? field.to_a.flatten : [field]).map(&:to_s)
@@ -50,14 +125,14 @@ module CiteProc
         end
       end
 
-      def attr_fields
+      def attr_fields(*arguments)
         arguments.flatten.each do |field|
           attr_field(*(field.is_a?(Hash) ? field.to_a.flatten : [field]).map(&:to_s))
         end
       end
       
       def attr_field(field, default = nil, predicate = false)
-        method_id = field.downcase.gsub(/[-\s]+/, '_')
+        method_id = field.to_s.downcase.gsub(/[-\s]+/, '_')
 
         unless instance_methods.include?(method_id)
           if default
@@ -77,11 +152,12 @@ module CiteProc
             attributes[field.to_sym] = value
           end
         end
-        
+        				
         predicate_id = [method_id, '?'].join  
         if predicate && !instance_methods.include?(predicate_id)
           define_method(predicate_id) do
-            ![nil, false, '', [], 'false', 'no', 'never'].include?(attributes[field.to_sym])
+						v = attributes[field.to_sym]
+						!(v.nil? || (v.respond_to?(:empty?) && v.empty?) || v =~ FALSE_PATTERN)
           end
           
           has_predicate = ['has_', predicate_id].join

data/lib/citeproc/bibliography.rb

@@ -0,0 +1,180 @@
+
+module CiteProc
+
+	# = Bibliography
+	#
+	# Typically a Bibliography is returned by the Processor. It contains a list
+	# of references and formatting options. 
+	#
+	# A Bibliography can be created from (and exported to) CiteProc JSON
+	# bibliographies; these consist of a	two-element list, composed of a
+	# JavaScript array containing certain formatting parameters, and a list of
+	# strings representing bibliography entries.
+	#
+	# == Bibliography Formatting Options
+	#
+	# :offset => 0
+	#   Some citation styles apply a label (either a number or an alphanumeric
+	#   code) to each bibliography entry, and use this label to cite
+	#   bibliography items in the main text. In the bibliography, the labels
+	#   may either be hung in the margin, or they may be set flush to the
+	#   margin, with the citations indented by a uniform amount to the right.
+	#   In the latter case, the amount of indentation needed depends on the
+	#   maximum width of any label. The :offset option gives the maximum
+	#   number of characters that appear in any label used in the
+	#   bibliography. The client that controls the final rendering of the
+	#   bibliography string should use this value to calculate and apply a
+	#   suitable indentation length.
+	#
+	# :entry_spacing => 0
+	#   An integer representing the spacing between entries in the
+	#   bibliography.
+	#
+	# :line_spacing => 0
+	#   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.
+	#
+	# :align => false
+	#   When the second-field-align CSL option is set, this returns either
+	#   "flush" or "margin". The calling application should align text in
+	#   bibliography output as described in the CSL specification. Where
+	#   second-field-align is not set, this return value is set to false.
+	#
+	class Bibliography
+
+		@defaults = {
+			:offset => 0,
+			:entry_spacing => 0,
+			:line_spacing => 0,
+			:indent => 0,
+			: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
+		}
+		
+		@rb2cp = @cp2rb.invert.freeze
+		@cp2rb.freeze
+		
+		class << self
+			
+			attr_reader :defaults, :cp2rb, :rb2cp
+			
+			# Create a new Bibliography from the passed-in string or array.
+			def parse(input)
+				case
+				when input.is_a?(String)
+					parse(MultiJson.decode(input))
+					
+				when input.is_a?(Array) && input.length == 2
+					options, references = input
+
+					new do |b|
+						b.concat(references)
+						b.errors.concat(options.fetch('bibliography_errors', []))
+						
+						b.preamble, b.postamble = options['bibstart'], options['bibend']
+						
+						(options.keys & cp2rb.keys).each do |k|
+							b.options[cp2rb[k]] = options[k]
+						end
+					end
+				
+				else
+					raise ParseError, "failed to create Bibliography from #{input.inspect}"
+				end
+			end
+			
+		end
+		
+		include Comparable
+		include Enumerable
+				
+		extend Forwardable
+
+		attr_reader :options, :errors, :references
+
+		attr_accessor :preamble, :postamble
+
+		alias before preamble
+		alias after postamble
+		
+		def_delegators :@references, :[], :[]=, :<<, :push, :unshift, :pop,
+			:concat, :include?, :index, :length, :empty?
+		
+		def initialize(options = {})
+			@options = Bibliography.defaults.merge(options)
+			@errors, @references = [], []
+			
+			yield self if block_given?
+		end
+		
+		def initialize_copy(other)
+			@options = other.options.dup
+			@errors, @references = other.errors.dup, other.references.dup
+		end
+
+		def has_errors?
+			!errors.empty?
+		end
+		
+		alias errors? has_errors?
+		
+		def each
+			if block_given?
+				references.each(&Proc.new)
+				self
+			else
+				to_enum
+			end
+		end
+		
+		def <=>(other)
+			return nil unless other.respond_to?(:references)
+			references <=> other.references
+		end
+
+		def citeproc_options
+			Hash[*options.map { |k,v|
+					[Bibliography.rb2cp[k] || k.to_s, v]
+				}.flatten]
+		end
+		
+		def to_citeproc
+			[
+				citeproc_options.merge({		
+		      'bibstart' => preamble,
+		      'bibend' => postamble,
+		      'bibliography_errors' => errors
+				}),
+				
+				references
+				
+			]
+		end
+		
+		def to_json
+			MultiJson.encode(to_citeproc)
+		end
+		
+		def inspect
+			"#<CiteProc::Bibliography @references=[#{references.length}], @errors=[#{errors.length}]>"
+		end
+		
+	end
+	
+end