citeproc 0.0.2 → 0.0.3

data/lib/citeproc/citation_data.rb

@@ -0,0 +1,208 @@
+module CiteProc
+
+	# CitationItems consititue the main input elements to CiteProc's processing
+	# methods. In order to be processed correctly, an item must contain a valid
+	# id attribute used to retrieve the item's bibliographic data. Additionally,
+	# an item may include the following, optional, attributes:
+	#
+	# * locator: a string identifying a page number or other pinpoint location
+	#   or range within the resource;
+  #
+	# * label: a label type, indicating whether the locator is to a page, a
+	#   chapter, or other subdivision of the target resource. Valid labels are
+	#   defined in CitationItem.labels
+	#
+	# * suppress-author: if true, author names will not be included in the
+	#   citation output for this cite;
+	#
+	# * author-only: if true, only the author name will be included in the
+	#   citation output for this cite -- 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.
+	#
+	# * prefix: a string to print before this cite item;
+	#
+	# * suffix: a string to print after this cite item.
+  #
+	class CitationItem
+		
+		include Attributes
+		
+		@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
+		
+		attr_predicates :id, :locator, :label, :'suppress-author',
+			:'author-only', :prefix, :suffix
+		
+		# Added by processor	
+		attr_predicates :sortkeys, :postion, :'first-reference-note-number',
+			:'near-note', :unsorted
+		
+		attr_accessor :data
+		
+		def initialize(attributes = nil)
+			merge(attributes)
+		end
+		
+		def initialize_copy(other)
+			@attributes = other.attributes.deep_copy
+		end
+		
+		def inspect
+			"#<CiteProc::CitationItem #{id.to_s}, #{locator.to_s} >"
+		end
+		
+	end
+	
+	
+	
+	
+	class CitationData
+		
+		extend Forwardable
+		include Enumerable
+		
+		@defaults = {
+			:footnote => 0
+		}.freeze
+		
+		@rb2cp = {
+			:id => 'citationID',
+			:items => 'citationItems',
+			:sorted_items => 'sortedItems',
+			:footnote => 'noteIndex',
+			:options => 'properties'
+		}
+		
+		@cp2rb = @rb2cp.invert.freeze
+		@rb2cp.freeze
+		
+		class << self
+			attr_reader :defaults, :cp2rb, :rb2cp
+		end
+		
+		attr_accessor :id
+		
+		attr_reader :items, :options, :sorted_items
+		
+		alias properties options
+		
+		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
+		
+		def each
+			if block_given?
+				items.each(&Proc.new)
+				self
+			else
+				to_enum
+			end
+		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 merge(other)
+      return self if other.nil?
+      
+      case other
+      when String, /^\s*\{/
+        other = MulitJson.decode(other, :symbolize_keys => true)
+      when Hash
+				# do nothing
+			when Array
+				other = { :items => other }
+      when Attributes
+        other = other.to_hash
+			else
+				raise ParseError, "failed to merge citation data and #{other.inspect}"
+      end
+
+			other = convert_from_citeproc(other)
+			
+			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?
+
+			@id = other[:id] if other.has_key?(:id)
+			      
+      self
+    end
+		
+		alias update merge
+		
+		def processed?
+			!!id
+		end
+		
+		def index
+			options[:footnote]
+		end
+		
+		def footnote?
+			options[:footnote] > 0
+		end
+		
+		def to_citeproc
+			cp = {}
+			
+			cp[CitationData.rb2cp[:items]] = items.map(&:to_citeproc)
+			cp[CitationData.rb2cp[:options]] = { CitationData.rb2cp[:footnote] => index }
+			
+			cp[CitationData.rb2cp[:id]] = id if processed?
+			
+			cp
+		end
+		
+		def to_json
+			MultiJson.encode(to_citeproc)
+		end
+		
+		alias to_s to_json
+		
+		def inspect
+			"#<CiteProc::CitationData items=[#{length}]>"
+		end
+		
+		private
+		
+		def convert_from_citeproc(hash)
+			hash = hash.symbolize_keys
+			
+			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

data/lib/citeproc/compatibility.rb

@@ -2,8 +2,12 @@ unless Symbol.is_a?(Comparable)
   class Symbol
     include Comparable
     
+		def =~(pattern)
+			to_s =~ pattern
+		end
+
     def <=>(other)
-      return nil unless other.respond_to?(:to_s)
+      return nil unless other.is_a?(Symbol)
       to_s <=> other.to_s
     end
   end

data/lib/citeproc/date.rb

@@ -1,166 +1,229 @@
 
-require 'date'
-
-begin
-  require 'chronic'
-rescue LoadError => e
-  # warn 'failed to load chronic gem'
-end
-
 module CiteProc
 
-  class Date < Variable
-
-    include Attributes
-
-    alias attributes value
-    alias to_hash value
-    
-    @parser = Object.const_defined?(:Chronic) ? ::Chronic : ::Date
-    
-    class << self
-
-      def parse(date_string)
-        new(@parser.parse(date_string))
-      rescue => e
-        raise ArgumentError.new("failed to parse date from #{date_string.inspect}", e)
-      end
-      
-      def today
-        new(::Date.today)
-      end
-      
-      alias now today
-      
-    end
-    
-
-    def initialize(attributes = ::Date.today)
-      super
-    end
-    
-    def initialize_copy(other)
-      @value = other.value.deep_copy
-    end
-    
-    def parse(attributes)
-      case
-      when attributes.is_a?(Date)
-        @value = attributes.dup
-
-      when attributes.is_a?(Numeric)
-        @value = { :'date-parts' => [[attributes.to_i]] }
-        
-      when attributes.is_a?(Hash)
-        attributes = attributes.symbolize_keys
-        if attributes.has_key?(:raw)
-          @value = Date.parse(attributes.delete(:raw)).value
-          @value.merge!(attributes)
-        else
-          @value = attributes.deep_copy
-        end
-        to_i!
-        
-      when attributes.respond_to?(:strftime)
-        @value = { :'date-parts' => [attributes.strftime('%Y-%m-%d').split(/-/).map(&:to_i)] }
-        
-      when attributes.is_a?(Array)
-        @value = { :'date-parts' => attributes[0].is_a?(Array) ? attributes : [attributes] }
-        to_i!
-        
-      when attributes.respond_to?(:to_s)
-        @value = Date.parse(attributes.to_s).value
-        
-      else
-        raise ArgumentError, "failed to parse date from #{attributes.inspect}"
-      end
-    end
-
-    attr_predicates :circa, :season, :literal, :'date-parts'
-
-    def date_parts
-      @value[:'date-parts'] ||= [[]]
-    end
-    
-    alias parts date_parts
-    alias parts= date_parts=
-
-    %w{ year month day }.each_with_index do |m,i|
-      define_method(m) { parts[0][i] }
-      define_method("#{m}=") { |v| parts[0][i] = v.to_i }
-    end
-
-    def start_date
-      ::Date.new(*parts[0])
-    end
-    
-    def start_date=(date)
-      parts[0] = date.strftime('%Y-%m-%d').split(/-/).map(&:to_i)
-    end
-
-    def end_date=(date)
-      parts[1] = date.nil? ? [0,0,0] : date.strftime('%Y-%m-%d').split(/-/).map(&:to_i)
-    end
-    
-    # Returns a Ruby date object for this instance, or Range object if this
-    # instance is closed range
-    def to_ruby
-      closed_range? ? start_date ... end_date : start_date
-    end
-    
-    def end_date
-      closed_range? ? ::Date.new(*parts[1]) : nil
-    end
-    
-    def has_end_date?
-      parts[1] && !parts[1].empty?
-    end
-    
-    # Returns true if this date is a range
-    alias range? has_end_date?
-    
-    def open_range?
-      range? && parts[1].uniq == [0]
-    end
-
-    def closed_range?
-      range? && !open_range?
-    end
-
-    alias uncertain? circa?
-        
-    # Marks the date as uncertain
-    def uncertain!; @value[:'circa'] = true; end
-    
-    # Marks the date as a certain date
-    def certain!; @value[:'circa'] = false; end    
-
-    def certain?; !uncertain?; end
-        
-    def numeric?; false; end
-    
-    def bc?; year && year < 0; end
-    def ad?; !bc? && year < 1000; end
-    
-    def to_s
-      literal? ? literal : @value.inspect
-    end
-    
-    def sort_order
-      "%04d%02d%02d-%04d%02d%02d" % ((parts[0] + [0,0,0])[0,3] + ((parts[1] || []) + [0,0,0])[0,3])
-    end
-        
-    def <=>(other)
-      return nil unless other.is_a?(Date)
-      [year, sort_order] <=> [other.year, other.sort_order]
-    end
-    
-    private
-    
-    def to_i!
-      parts.each { |p| p.map!(&:to_i) }
-    end
-    
-  end
-  
+	class Date < Variable
+
+		include Attributes
+
+		alias attributes value
+		private :attributes, :value=
+		
+
+		# Date parsers (must respond to :parse)
+		@parsers = []
+
+		require 'date'
+		@parsers << ::Date
+		
+		begin
+			require 'chronic'
+			@parsers << Chronic
+		rescue LoadError
+			# warn 'failed to load chronic gem'
+		end
+		
+		# Format string used for sorting dates
+		@sort_order = "%04d%02d%02d-%04d%02d%02d".freeze
+		
+		class << self
+
+			attr_reader :parsers, :sort_order
+			
+			# Parses the passed-in string with all available date parsers. Creates
+			# a new CiteProc Date from the first valid date returned by a parser;
+			# returns nil if no parser was able to parse the string successfully.
+			#
+			# For an equivalent method that raises an error on invalid input
+			# @see #parse!
+			def parse(date_string)
+				parse!(date_string)
+			rescue ParseError
+				nil
+			end
+			
+			# Like #parse but raises a ParseError if the input failed to be parsed.
+			def parse!(date_string)
+				@parsers.each do |p|
+					d = p.parse(date_string) rescue nil
+					return new(d) unless d.nil?
+				end
+				
+				# if we get here, all parsers failed
+				raise ParseError, "failed to parse #{date_string.inspect}"
+			end
+
+			def today
+				new(::Date.today)
+			end
+
+			alias now today
+
+		end
+
+		attr_predicates :circa, :season, :literal, :'date-parts'
+
+		# Make Date behave like a regular Ruby Date
+		def_delegators :to_ruby,
+			*::Date.instance_methods(false).reject { |m| m.to_s =~ /^to_s$|^inspect$|start$|^\W/ }
+
+
+		def initialize(value = ::Date.today)
+			super
+		end
+
+		def initialize_copy(other)
+			@value = other.value.deep_copy
+		end
+
+		def replace(value)
+			case
+			when value.is_a?(CiteProc::Date)
+				initialize_copy(value)
+
+			when value.is_a?(Numeric)
+				@value = { :'date-parts' => [[value.to_i]] }
+
+			when value.is_a?(Hash)
+				attributes = value.symbolize_keys
+
+				if attributes.has_key?(:raw)
+					@value = Date.parse(attributes.delete(:raw)).value
+					@value.merge!(attributes)
+				else
+					@value = attributes.deep_copy
+				end
+				to_i!
+
+			when value.respond_to?(:strftime)
+				@value = { :'date-parts' => [value.strftime('%Y-%m-%d').split(/-/).map(&:to_i)] }
+
+			when value.is_a?(Array)
+				@value = { :'date-parts' => value[0].is_a?(Array) ? value : [value] }
+				to_i!
+
+			when value.respond_to?(:to_s)
+				@value = Date.parse(value.to_s).value
+
+			else
+				raise TypeError, "failed to create date from #{value.inspect}"
+			end
+
+			self
+		end
+
+		# TODO replace the date parts by two proper dates or structs
+		
+		def date_parts
+			@value[:'date-parts'] ||= [[]]
+		end
+
+		alias parts date_parts
+		alias parts= date_parts=
+
+		def empty?
+			parts.flatten.compact.empty?
+		end
+		
+		%w{ year month day }.each_with_index do |m,i|
+			define_method(m) { parts[0][i] }
+			define_method("#{m}=") { |v| parts[0][i] = v.to_i }
+		end
+		
+		def -@
+			d = dup
+			d.year = -1 * year
+			d
+		end
+		
+		def start_date
+			::Date.new(*parts[0])
+		end
+
+		def start_date=(date)
+			parts[0] = date.strftime('%Y-%m-%d').split(/-/).map(&:to_i)
+		end
+
+		def end_date=(date)
+			parts[1] = date.nil? ? [0,0,0] : date.strftime('%Y-%m-%d').split(/-/).map(&:to_i)
+		end
+
+		# Returns a Ruby date object for this instance, or Range object if this
+		# instance is closed range
+		def to_ruby
+			closed_range? ? start_date ... end_date : start_date
+		end
+
+		def end_date
+			closed_range? ? ::Date.new(*parts[1]) : nil
+		end
+
+		def has_end_date?
+			parts[1] && !parts[1].empty?
+		end
+
+		# Returns true if this date is a range
+		alias range? has_end_date?
+
+		def open_range?
+			range? && parts[1].uniq == [0]
+		end
+
+		alias open? open_range?
+
+		def closed_range?
+			range? && !open_range?
+		end
+
+		alias closed? closed_range?
+
+		alias uncertain? circa?
+
+		# Marks the date as uncertain
+		def uncertain!
+			@value[:circa] = true
+		end
+
+		# Marks the date as a certain date
+		def certain!
+			@value[:circa] = false
+		end
+
+		def certain?
+			!uncertain?
+		end
+
+		def numeric?
+			false
+		end
+
+		def bc?; year and year < 0; end
+		def ad?; not bc? and year < 1000; end
+
+		def to_citeproc
+			cp = @value.stringify_keys
+			cp.delete('date-parts') if empty?
+			cp
+		end
+		
+		def to_s
+			literal? ? literal : to_ruby.to_s
+		end
+
+		def sort_order
+			Date.sort_order % ((parts[0] + [0,0,0])[0,3] + ((parts[1] || []) + [0,0,0])[0,3])
+		end
+
+		def <=>(other)
+			return nil unless other.is_a?(Date)
+			[year, sort_order] <=> [other.year, other.sort_order]
+		end
+
+		private
+
+		def to_i!
+			parts.each { |p| p.map!(&:to_i) }
+		end
+
+	end
+
 end