citeproc 0.0.2 → 0.0.3

data/lib/citeproc/processor.rb

@@ -4,26 +4,52 @@ module CiteProc
 
     extend Forwardable
     
-    @defaults ||= {
+    @defaults = {
       :locale => 'en-US',
       :style  => 'chicago-author-date',
       :engine => 'citeproc-js',
       :format => 'html'
-    }
+    }.freeze
 
     class << self
       attr_reader :defaults
     end
 
-    attr_reader :options, :engine, :items
+    attr_reader :options, :engine, :items, :style
     
-    def_delegators :@engine, :process, :append, :preview, :bibliography, :style, :style=, :abbreviate, :abbreviations, :abbreviations=
+    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
+    		
   end
 end

data/lib/citeproc/selector.rb

@@ -0,0 +1,128 @@
+
+module CiteProc
+	
+	class Selector
+
+		@types = [:all, :any, :none].freeze
+		@matcher = Hash[*@types.zip([:all?, :any?, :none?]).flatten].freeze
+		
+		@rb2cp = Hash[*(@types + [:skip]).zip(%w{
+			select include exclude quash
+		}).flatten]
+		
+		@cp2rb = @rb2cp.invert.freeze
+		@rb2cp.freeze
+		
+		class << self
+			attr_reader :types, :matcher, :rb2cp, :cp2rb
+		end
+		
+		attr_reader :type, :conditions, :skip_conditions, :custom_matcher
+		
+		def initialize(attributes = nil)
+			@conditions, @skip_conditions = {}, {}
+			
+			if block_given?
+				@type = :ruby
+				
+			else
+				unless attributes.nil? || attributes.empty?
+					attributes.symbolize_keys.each_pair do |key, conditions|
+						case key
+						when :all, :any, :none
+							@type = key
+							@conditions.merge!(conditions)
+						
+						when :select, :include, :exclude
+							@type = Selector.cp2rb[key.to_s]
+							@conditions.merge!(conditions)
+						
+						when :skip, :quash
+							@skip_conditions.merge!(conditions)
+						
+						else
+							raise TypeError, "failed to create selector from #{key.inspect}"
+						end
+					end				
+				end
+			end
+			
+		end
+		
+		def initialize_copy(other)
+			@type = other.type
+			@conditions = other.conditions.deep_copy
+			@skip_conditions = other.skip_conditions.deep_copy
+			@custom_matcher = other
+		end
+
+		def type=(type)
+			raise TypeError, "failed to set selector type to #{type.inspect}" unless
+				type.respond_to(:to_sym) && Selector.types.include?(type.to_sym)
+			
+			@type = type.to_sym
+		end
+		
+		def empty?
+			type.nil? && skip_conditions.empty? 
+		end
+
+		def custom_matcher?
+			defined?(@custom_matcher)
+		end
+		
+		alias ruby? custom_matcher?
+		
+		def matches?(item)
+			if custom_matcher?
+				custom_matcher.call(item)
+			else
+				conditions.each_pair.send(matcher) do |field, value|
+					item[field].to_s == value.to_s
+				end
+			end
+		end
+		
+		def skip?(item)
+			if custom_matcher?
+				false # skips are ignored for custom matchers
+			else
+				skip_conditions.each_pair.all? do |field, value|
+					item[field].to_s == value.to_s
+				end
+			end
+		end
+		
+		def to_proc
+			Proc.new { |item| matches?(item) && !skip?(item) }
+		end
+		
+		def to_citeproc
+			return nil if empty? || custom_matcher?
+			
+			cp = {}
+			cp[Selector.rb2cp[type]] = conditions.map do |field, value|
+				{ 'field' => field.to_s, 'value' => value.to_s }
+			end unless conditions.empty?
+			
+			cp['quash'] = skip_conditions.map do |field, value|
+				{ 'field' => field.to_s, 'value' => value.to_s }
+			end unless skip_conditions.empty?
+			
+			cp
+		end
+		
+		def to_json
+			MultiJson.encode(to_citeproc)
+		end
+		
+		private
+				
+		def matcher
+			Selector.matcher[type] || :all?
+		end
+		
+		
+	end
+	
+end

data/lib/citeproc/variable.rb

@@ -8,24 +8,33 @@ module CiteProc
   class Variable
 
     extend Forwardable
-    
     include Comparable
     
     @fields = Hash.new { |h,k| h.fetch(k.to_sym, nil) }.merge({
-      :date => %w{ accessed container event-date issued original-date },
-      
+      :date => %w{
+				accessed container event-date issued original-date submitted
+			},
+
       :names => %w{
-        author editor translator recipient interviewer publisher composer
-        original-publisher original-author container-author collection-editor },
+				author collection-editor composer container-author recipient editor
+				editorial-director illustrator interviewer original-author translator
+			},
       
+			:number => %w{
+				chapter-number collection-number edition issue number number-of-pages
+				number-of-volumes volume				
+			},
+			
       :text => %w{
-        id abstract annote archive archive-location archive-place authority
-        call-number chapter-number citation-label citation-number collection-title
-        container-title DOI edition event event-place first-reference-note-number
-        genre ISBN issue jurisdiction keyword locator medium note number
-        number-of-pages number-of-volumes original-publisher original-publisher-place
-        original-title page page-first publisher publisher-place references
-        section status title URL version volume year-suffix }
+				abstract annote archive archive_location archive-place authority
+				call-number citation-label citation-number collection-title
+				container-title container-title-short dimensions DOI event event-place
+				first-reference-note-number genre ISBN ISSN jurisdiction keyword
+				locator medium note original-publisher original-publisher-place
+				original-title page page-first PMID PMCID publisher publisher-place
+				references section source status title title-short URL version
+				year-suffix
+			}
     })
     
     @fields.each_value { |v| v.map!(&:to_sym) }
@@ -36,21 +45,43 @@ module CiteProc
     
     @fields[:name] = @fields[:names]
     @fields[:dates] = @fields[:date]
+    @fields[:numbers] = @fields[:number]
     
     @fields[:all] = @fields[:any] =
-      [:date,:names,:text].reduce([]) { |s,a| s.concat(@fields[a]) }.sort
+      [:date,:names,:text,:number].reduce([]) { |s,a| s.concat(@fields[a]) }.sort
 
     @fields.freeze
 
+		@markup = /<[^>]*>/.freeze
+		
+		
     class << self
-      attr_reader :fields, :types
+	
+      attr_reader :fields, :types, :markup, :factories
       
-      def parse(*args)
+			def create(value, type = nil)
+				create!(value, type)
+			rescue
+				nil
+			end
+			
+      def create!(value, type = nil)
+				factory = factories[type]
+				value.is_a?(factory) ? value : factory.new(value)
       end
+
     end
     
-    def initialize(attributes = nil)
-      parse(attributes)
+    attr_accessor :value
+
+    def_delegators :@value, :to_s,
+			*::String.instance_methods(false).select {|m| m.to_s =~ /!$/ }
+    
+    def_delegators :to_s, :=~, :===,
+			*::String.instance_methods(false).reject {|m| m.to_s =~ /^\W|!$|to_s/ }
+
+    def initialize(value = nil)
+      replace(value)
       yield self if block_given?
     end
     
@@ -58,35 +89,29 @@ module CiteProc
       @value = other.value.dup
     end
     
-    attr_accessor :value
 
-    def_delegators :@value, :to_s, :strip!, :upcase!, :downcase!, :sub!, :gsub!, :chop!, :chomp!, :rstrip!
-    
-    def_delegators :to_s, :empty?, :=~, :===, :match, :intern, :to_sym, :end_with?, :start_with?, :include?, :upcase, :downcase, :reverse, :chop, :chomp, :rstrip, :gsub, :sub, :size, :strip, :succ, :to_c, :to_r, :to_str, :split, :each_byte, :each_char, :each_line
+		# The replace method is typically called by the Variable's constructor. It
+		# will try to set the Variable to the passed in value and should accept
+		# a wide range of argument types; subclasses (especially Date and Names)
+		# override this method.
+		def replace(value)
+			raise TypeError, "failed to set value to #{value.inspect}" unless value.respond_to?(:to_s)
+			@value = value.to_s
+			self
+		end
 
-    def parse(attributes)
-      case
-      when attributes.is_a?(Hash)
-        attributes.each_key do |key|
-          writer = "#{key}="
-          send(writer, attributes[key]) if respond_to?(writer)
-        end
-      when attributes.respond_to?(:to_s)
-        @value = attributes.to_s.dup
-      end
-    end
-    
-    def type
-      @type ||= self.class.name.split(/::/)[-1].downcase.to_sym
-    end
-    
+		def type
+			@type ||= self.class.name.split(/::/)[-1].downcase.to_sym
+		end
+
+		# Returns true if the Variable can be (safely) cast to a numeric value.
     def numeric?
-      self =~ /\d/ ? to_i : false
+      match(/\d/) ? to_i : false
     end
     
-    # @returns (first) numeric data contained in the variable's value
+    # Returns (first) numeric data contained in the variable's value
     def to_i
-      to_s =~ /(-?\d+)/ && $1.to_i || 0
+     to_s =~ /(-?\d+)/ && $1.to_i || 0
     end
     
     def to_f
@@ -94,28 +119,43 @@ module CiteProc
     end
     
     def strip_markup
-      gsub(/<[^>]*>/, '')
+      gsub(Variable.markup, '')
     end
     
     def strip_markup!
-      gsub!(/<[^>]*>/, '')
+      gsub!(Variable.markup, '')
     end 
     
     def <=>(other)
       case
       when other.respond_to?(:strip_markup)
         strip_markup <=> other.strip_markup
+
       when other && other.respond_to?(:to_s)
         to_s <=> other.to_s
+
       else
         nil
       end
     end
     
+		alias to_citeproc to_s
+		
     def to_json
-      MultiJson.encode(@value)
+      MultiJson.encode(to_citeproc)
     end
+
+		def inspect
+			"#<#{self.class.name}: #{to_s.inspect}>"
+		end
+		
   end
-  
-  class Text < Variable; end
+
+
+	class Text < Variable
+	end
+
+	class Number < Variable
+	end
+
 end

data/lib/citeproc/version.rb

@@ -1,3 +1,3 @@
 module CiteProc
-  VERSION = '0.0.2'.freeze
+  VERSION = '0.0.3'.freeze
 end

data/spec/citeproc/assets_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'tempfile'
+
+module CiteProc
+  
+  describe 'Assets' do
+    let(:file) { Tempfile.new('asset') }
+    let(:root) { File.dirname(file.path) }
+    let(:name) { File.basename(file.path) }
+    let(:extension) { File.extname(name) }
+  
+    before(:all) do
+      file.write("asset content\n")
+      file.close
+    end
+  
+    after(:all) { file.unlink }
+
+    describe 'Style' do
+
+      before(:all) do
+        @default_root = Style.root
+        @default_extension = Style.extension
+        Style.root = root
+        Style.extension = extension
+      end
+      
+      after(:all) do
+        Style.root = @default_root
+        Style.extension = @default_extension
+      end
+    
+      describe '.load' do  
+      
+        it 'accepts an absolute file name' do
+          Style.load(file.path).to_s.should == "asset content\n"
+        end
+
+        it 'accepts a file name' do
+          Style.load(name).to_s.should == "asset content\n"
+        end
+
+        it 'accepts a file name without extension' do
+          Style.load(name.sub(/#{extension}$/,'')).to_s.should == "asset content\n"
+        end
+                
+                
+        it 'accepts a uri' do
+          pending
+        end
+      
+        it 'returns the given string if it is neither file nor uri' do
+          Style.load('foo bar!').to_s.should == 'foo bar!'
+        end
+      
+      end
+    
+    end
+  end
+end