citeproc 0.0.3 → 0.0.6

data/lib/citeproc/engine.rb

@@ -1,22 +1,22 @@
 require 'forwardable'
 
 module CiteProc
-  
+
   class Engine
-    
     extend Forwardable
-    include Abbreviate
-    
+
+    include Converters
+
     @subclasses ||= []
 
     class << self
-            
+
       attr_reader :subclasses, :type, :version
-   
+
       attr_writer :default
-   
+
       private :new
-      
+
       def inherited(subclass)
         subclass.public_class_method :new
         @subclasses << subclass
@@ -34,33 +34,33 @@ module CiteProc
         subclasses.detect { |e| e.name == name } ||
           block_given? ? yield(subclasses) : nil
       end
-      
+
       # Loads the engine with the given name and returns the engine class.
       def detect!(name)
         load(name)
         block_given? ? detect(name, &Proc.new) : detect(name)
       end
-      
+
       # Returns the best available engine class or nil.
       def autodetect(options = {})
         subclasses.detect { |e|
           !options.has_key?(:engine) || e.name == options[:engine] and
           !options.has_key?(:name) || e.name == options[:name]
-        } || subclasses.first        
+        } || subclasses.first
       end
-      
+
       # Loads the engine by requiring the engine name.
       def load(name)
         require name.gsub(/-/,'/')
       rescue LoadError
         warn "failed to load #{name} engine: try to gem install #{name}"
       end
-      
+
       # Returns a list of all available engine names.
       def available
         subclasses.map(&:engine_name)
       end
-      
+
       def engine_name
         @name ||= name.gsub(/::/, '-').downcase # returns class name as fallback
       end
@@ -70,64 +70,45 @@ module CiteProc
       end      
     end
 
-    attr_accessor :processor, :locales, :style, :items    
-    
-    def initialize(attributes = {})
-      @processor = attributes[:processor]
-      
-      @items = attributes[:items] || {}
-      @abbreviations = attributes[:abbreviations] || { :default => {} }
-      
+    attr_accessor :processor
+
+    def_delegators :@processor, :options, :abbreviations, :style, :locale,
+      :items, :language, :region, :abbreviate
+
+    def initialize(processor = nil)
+      @processor = processor
       yield self if block_given?
     end
 
-    def start
-      @started = true
-      self
-    end
-    
-    def stop
-      @started = false
-      self
-    end
-    
-    def started?; !!@started; end
-    
-    alias running? started?
-    
     [[:name, :engine_name], :type, :version].each do |method_id, target|
       define_method(method_id) do
         self.class.send(target || method_id)
       end
     end
-    
+
     def process
       raise NotImplementedByEngine
     end
-    
-    alias process_citation_cluster process
 
     def append
       raise NotImplementedByEngine
     end
-    
-    alias append_citation_cluster append
 
-    
     def bibliography
       raise NotImplementedByEngine
     end
-    
-    alias make_bibliography bibliography
-    
+
     def update_items
       raise NotImplementedByEngine
     end
-    
+
     def update_uncited_items
       raise NotImplementedByEngine
     end
-            
+
+    def inspect
+      "#<CiteProc::Engine #{name}-#{type}-#{version}>"
+    end
   end
 
 end

data/lib/citeproc/item.rb

@@ -1,113 +1,122 @@
 module CiteProc
-	
-	# Items are similar to a Ruby Hash but pose a number of constraints on their
-	# contents: keys are always (implicitly converted to) symbols and values
-	# are strictly instances of CiteProc::Variable. When Items are constructed
-	# from (or merged with) JSON objects or Hashes Variable instances are
-	# automatically created using by passing the variables key as type to
-	# Variable.create – this will create the expected Variable type for all
-	# fields defined in CSL (for example, the `issued' field will become a
-	# CiteProc::Date object); unknown types will be converted to simple
-	# CiteProc::Variable instances, which should be fine for numeric or string
-	# values but may cause problems for more complex types.
-	#
-	# Every Item provides accessor methods for all known field names; unknown
-	# fields can still be accessed using array accessor syntax.
-	#
-	#     i = Item.new(:edition => 3, :unknown_field => 42)
-	#     i.edition         -> #<CiteProc::Number "3">
-	#     i[:edition]       -> #<CiteProc::Number "3">
-	#     i[:unknown_field] -> #<CiteProc::Variable "42">
-	#
-	# Items can be converted to the CiteProc JSON format via #to_citeproc (or
-	# #to_json to get a JSON string).
-	class Item
-		
-		@types = [
-			:article, :'article-journal', :'article-magazine', :'article-newspaper',
-			:bill, :book, :broadcast, :chapter, :entry, :'entry-dictionary',
-			:'entry-encyclopedia', :figure, :graphic, :interview, :legal_case,
-			:legislation, :manuscript, :map, :motion_picture, :musical_score,
-			:pamphlet, :'paper-conference', :patent, :personal_communication, :post,
-			:'post-weblog', :report, :review, :'review-book', :song, :speech,
-			:thesis, :treaty, :webpage].freeze
-		
-		@bibtex_types = Hash.new { |h,k| :misc }.merge(Hash[*%w{
-			pamphlet          booklet
-			paper-conference  conference
-			chapter           inbook
-			chapter           incollection
-			paper-conference  inproceedings
-			book              manual
-			thesis            phdthesis
-			paper-conference  proceedings
-			report            techreport
-			manuscript        unpublished
-			article           article
-			article-journal   article
-			article-magazine  article
-		}.map(&:intern)]).freeze
-	  
-		class << self
-			attr_reader :types, :bibtex_types
-		end
-		
-		include Attributes
-		include Enumerable
-		
-		attr_predicates :id, :'short-title', :'journal-abbreviation',
-			*Variable.fields[:all]
-		
-		def initialize(attributes = nil)
-			merge(attributes)
-		end
-		
-		def initialize_copy(other)
-			@attributes = other.attributes.deep_copy
-		end
+  
+  
+  # Items are similar to a Ruby Hash but pose a number of constraints on their
+  # contents: keys are always (implicitly converted to) symbols and values
+  # are strictly instances of CiteProc::Variable. When Items are constructed
+  # from (or merged with) JSON objects or Hashes Variable instances are
+  # automatically created using by passing the variables key as type to
+  # Variable.create – this will create the expected Variable type for all
+  # fields defined in CSL (for example, the `issued' field will become a
+  # CiteProc::Date object); unknown types will be converted to simple
+  # CiteProc::Variable instances, which should be fine for numeric or string
+  # values but may cause problems for more complex types.
+  #
+  # Every Item provides accessor methods for all known field names; unknown
+  # fields can still be accessed using array accessor syntax.
+  #
+  #     i = Item.new(:edition => 3, :unknown_field => 42)
+  #     i.edition         -> #<CiteProc::Number "3">
+  #     i[:edition]       -> #<CiteProc::Number "3">
+  #     i[:unknown_field] -> #<CiteProc::Variable "42">
+  #
+  # Items can be converted to the CiteProc JSON format via #to_citeproc (or
+  # #to_json to get a JSON string).
+  class Item
     
-		# Don't expose attributes. Items need to mimic Hash functionality in a controlled way.
-		private :attributes
-		
-		def each
-			if block_given?
-				attributes.each(&Proc.new)
-				self
-			else
-				to_enum
-			end
-		end
-		
-		# Returns a corresponding BibTeX::Entry if the bibtex-ruby gem is installed;
-		# otherwise returns a BibTeX string.
-		def to_bibtex
-			# hash = to_hash
-			# 
-			# hash[:type] = Item.bibtex_types[hash[:type]]
-			# 
-			# if hash.has_key?(:issued)
-			# 	date = hash.delete(:issued)
-			# 	hash[:year] = date.year
-			# 	hash[:month] = date.month
-			# end
-			# 
-			# Variable.fields[:date].each do |field|
-			# 	hash[field] = hash[field].to_s if hash.has_key?(field)
-			# end
-			# 
-			# Variable.fields[:names].each do |field|
-			# 	hash[field] = hash[field].map(&:sort_order!).join(' and ')
-			# end
-			
-			raise 'not implemented yet'
-		end
-				
-		private
-
-		def filter_value(value, key)
-			Variable.create!(value, key)
-		end
+    @types = [
+      :article, :'article-journal', :'article-magazine', :'article-newspaper',
+      :bill, :book, :broadcast, :chapter, :entry, :'entry-dictionary',
+      :'entry-encyclopedia', :figure, :graphic, :interview, :legal_case,
+      :legislation, :manuscript, :map, :motion_picture, :musical_score,
+      :pamphlet, :'paper-conference', :patent, :personal_communication, :post,
+      :'post-weblog', :report, :review, :'review-book', :song, :speech,
+      :thesis, :treaty, :webpage].freeze
+    
+    @bibtex_types = Hash.new { |h,k| :misc }.merge(Hash[*%w{
+      pamphlet          booklet
+      paper-conference  conference
+      chapter           inbook
+      chapter           incollection
+      paper-conference  inproceedings
+      book              manual
+      thesis            phdthesis
+      paper-conference  proceedings
+      report            techreport
+      manuscript        unpublished
+      article           article
+      article-journal   article
+      article-magazine  article
+    }.map(&:intern)]).freeze
+    
+    class << self
+      attr_reader :types, :bibtex_types
+    end
+    
+    include Attributes
+    include Enumerable
+    
+    attr_predicates :id, :'short-title', :'journal-abbreviation',
+      *Variable.fields[:all]
+    
+    def initialize(attributes = nil)
+      merge(attributes)
+    end
+    
+    def initialize_copy(other)
+      @attributes = other.attributes.deep_copy
+    end
+    
+    # Don't expose attributes. Items need to mimic Hash functionality in a controlled way.
+    private :attributes
+    
+    def each
+      if block_given?
+        attributes.each(&Proc.new)
+        self
+      else
+        to_enum
+      end
+    end
+    
+    # Returns a corresponding BibTeX::Entry if the bibtex-ruby gem is installed;
+    # otherwise returns a BibTeX string.
+    def to_bibtex
+      # hash = to_hash
+      # 
+      # hash[:type] = Item.bibtex_types[hash[:type]]
+      # 
+      # if hash.has_key?(:issued)
+      #   date = hash.delete(:issued)
+      #   hash[:year] = date.year
+      #   hash[:month] = date.month
+      # end
+      # 
+      # Variable.fields[:date].each do |field|
+      #   hash[field] = hash[field].to_s if hash.has_key?(field)
+      # end
+      # 
+      # Variable.fields[:names].each do |field|
+      #   hash[field] = hash[field].to_bibtex
+      # end
+      
+      raise 'not implemented yet'
+    end
+    
+    def to_sym
+      id.to_s.to_sym
+    end
+    
+    def inspect
+      "#<CiteProc::Item id=#{id.inspect} attributes={#{attributes.length}}>"
+    end
+    
+    private
 
-	end
+    def filter_value(value, key)
+      Variable.create!(value, key)
+    end
 
+  end
+  
 end

data/lib/citeproc/processor.rb

@@ -1,8 +1,11 @@
 
 module CiteProc
+  
   class Processor
-
     extend Forwardable
+
+    include Abbreviate
+    include Converters
     
     @defaults = {
       :locale => 'en-US',
@@ -15,41 +18,105 @@ module CiteProc
       attr_reader :defaults
     end
 
-    attr_reader :options, :engine, :items, :style
+    attr_reader :options, :items
+    attr_writer :engine
+
+    def_delegators :@locale, :language, :region
+    
+    def_delegators :@items, :key?, :value?, :has_key?, :has_value?,
+      :include?, :member?, :length, :empty?
     
-    def_delegators :@engine, :abbreviate, :abbreviations, :abbreviations=
-     
     def initialize(options = {})
-      @options = Processor.defaults.merge(options)
-      @engine = Engine.autodetect(@options).new(:processor => self)
-      @style = Style.load(@options[:style])
-      @locales = @options[:locale]
-      @items = {}
-    end
-    
-		def style=(style)
-		  @style = Style.load(style.to_s)
-		  @engine.style = @style
-		  @style
-	  end
-	  
-	  def locales=(locale)
-      @locales = { locale.to_sym => Locale.load(locale.to_s) }
-      @engine.locales = @locales
-      @locales
-    end
-
-		def process(*arguments)
-			@engine.process(CitationData(arguments.flatten(1)))
-		end
-		
-		def append(*arguments)
-			@engine.append(CitationData(arguments.flatten(1)))
-		end
-		
-		def bibliography(*arguments, &block)
-			@engine.bibliography(Selector.new(*arguments, &block))
-		end
-    		
+      @options, @items = Processor.defaults.merge(options), {}
+      yield self if block_given?
+    end
+
+    def engine
+      @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]
+    end
+
+    def []=(id, item)
+      items[id.to_sym] = Item(item)
+    end
+    
+    def register(item)
+      item = Item(item)
+      items[item.to_sym] = 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|
+        case argument
+        when Item
+          register(argument)
+        when Array
+          argument.each { |item| register(item) }
+        when Hash
+          argument.each do |id, item|
+            id, item = id.to_sym, Item(item)
+        
+            if items.key?(id) && block_given?
+              items[id] = yield items[id], item
+            else
+              items[id] = item
+            end
+          end
+        else
+          raise "failed to register items #{argument.inspect}"
+        end
+      end
+      
+      self
+    ensure
+      # notify engine
+    end
+    
+
+
+    def process(*arguments)
+      engine.process(CitationData(arguments.flatten(1)))
+    end
+
+    def append(*arguments)
+      engine.append(CitationData(arguments.flatten(1)))
+    end
+
+    def bibliography(*arguments, &block)
+      engine.bibliography(Selector.new(*arguments, &block))
+    end
+
+    def inspect
+      "#<CiteProc::Processor style=#{style.name.inspect} locale=#{locale.name.inspect} items=[#{items.length}]>"
+    end
+    
   end
 end