csl 1.0.0.pre1 → 1.0.0.pre2

data/lib/csl/parser.rb

@@ -65,7 +65,8 @@ module CSL
 			return nil if node.nil?
 			
       root = parse_node node, scope
-
+      scope = specialize_scope(root, scope)
+      
       node.children.each do |child|
         root << parse_tree(child, scope) unless comment?(child)
       end unless root.textnode?
@@ -86,7 +87,19 @@ module CSL
 			node.respond_to?(:comment?) && node.comment? ||
 				node.respond_to?(:node_type) && [:comment, :xmldecl].include?(node.node_type)
 		end
-		
+
+		def specialize_scope(root, scope = Node)
+		  case root
+		  when Style
+		    Style
+		  when Locale
+		    Locale
+		  when Info
+		    Info
+		  else
+		    scope
+		  end
+		end
   end
   
 end

data/lib/csl/pretty_printer.rb

@@ -8,9 +8,9 @@ module CSL
     def to_xml
       tags.flatten.join
     end
-    
+
     def pretty_print
-      pp(tags).join("\n")
+      preamble << tags.map { |t| pp t }.join("\n")
     end
 
     private
@@ -19,13 +19,15 @@ module CSL
 			2
 		end
 		
-    def pp(tags, level = 0)
-      tags.map do |tag|
-        if tag.respond_to?(:map)
-          pp tag, level + 1
-        else
-          ' ' * (level * tabwidth) + tag.to_s
-        end
+		def preamble
+		  ''
+		end
+		
+    def pp(tag, level = 0)
+      if tag.is_a?(Array)
+        tag.map { |t| pp t, level + 1 }.join("\n")
+      else
+        (' ' * (level * tabwidth)) << tag.to_s
       end
     end
     

data/lib/csl/schema.rb

@@ -4,7 +4,7 @@ module CSL
     
     @version   = '1.0.1'.freeze
     @namespace = 'http://purl.org/net/xbiblio/csl'.freeze
-    @preamble  = '<?xml version="1.0" encoding="utf-8"?>'.freeze
+    @preamble  = "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n".freeze
     
     @types = %w{ article article-journal article-magazine article-newspaper
       bill book broadcast chapter entry entry-dictionary entry-encyclopedia
@@ -74,13 +74,11 @@ module CSL
       :periods => %w{
         strip-periods
       },
-      :textcase => %w{
-        lowercase uppercase capitalize-first capitalize-all title sentence
-      },
       :name => %w{
         name-form name-delimiter and delimiter-precedes-et-al initialize-with
-        delimiter-precedes-last et-al-min etal-use-first et-al-subsequent-min
-        et-al-subsequent-use-first et-al-use-last 
+        delimiter-precedes-last et-al-min et-al-use-first et-al-subsequent-min
+        et-al-subsequent-use-first et-al-use-last name-as-sort-order
+        sort-separator initialize
       },
       :names => %w{
         names-delimiter
@@ -90,6 +88,25 @@ module CSL
     @attributes.each_value { |v| v.map!(&:to_sym).freeze }
     @attributes.freeze
     
+    @file = File.expand_path('../../../vendor/schema/csl.rng', __FILE__)
+    
+    @validators = {
+      :nokogiri => lambda { |schema, style|
+        schema.validate(Nokogiri::XML(style)).map { |e| [e.line, e.message] }
+      },
+      
+      :default => lambda { |schema, style|
+        raise ValidationError, "please `gem install nokogiri' for validation support"
+      }
+    }
+    
+    begin
+      require 'nokogiri'
+      @validator = @validators[:nokogiri]
+      @schema = Nokogiri::XML::RelaxNG(File.open(@file))
+    rescue LoadError
+      @validator = @validators[:default]
+    end
     
     class << self
       
@@ -102,8 +119,78 @@ module CSL
         attributes.values_at(*arguments).flatten(1)
       end
       
+      # Validates the passed-in style or list of styles. The style argument(s)
+      # can either be a {Style} object, a style's file handle, XML content
+      # or a valid location (wildcards are supported). The method returns
+      # a list of validation errors; the passed-in style is valid if the
+      # method returns an empty list.
+      #
+      # @example
+      #   CSL::Schema.validate(CSL::Style.load(:apa))
+      #
+      #   CSL::Schema.validate('my-styles/style.csl')
+      #   CSL::Schema.validate('my-styles/*.csl')
+      #   CSL::Schema.validate('http://www.example.org/style.csl')
+      #
+      # @param style [Node,String,IO,Array] the style (or a list of styles)
+      #   to validate.
+      #
+      # @raise [ArgumentError] if the passed-in argument is not a Style or
+      #   a valid style location.
+      # @raise [ValidationError] if the validation process fails
+      #
+      # @return [<<Fixnum,String>>] a list of validation errors
+      def validate(node)
+        case
+        when node.is_a?(Node)
+          validator[schema, node.to_xml]
+        when node.respond_to?(:read)
+          validator[schema, node.read]
+        when node.is_a?(Enumerable) && !node.is_a?(String)
+          node.map { |n| validate(n) }.flatten(1)
+        when node.respond_to?(:to_s)
+          node = node.to_s
+
+          case
+          when node =~ /^\s*</
+            validator[schema, node]
+          when File.exists?(node)
+            validator[schema, File.open(node, 'r:UTF-8')]
+          else
+            glob = Dir.glob(node)
+            
+            if glob.empty?
+              validator[schema, Kernel.open(node)]            
+            else
+              glob.map { |n| validator[schema, File.open(n, 'r:UTF-8')] }.flatten(1)
+            end
+          end
+        else
+          raise ArgumentError, "failed to validate #{node.inspect}: not a CSL node"
+        end
+      end
+      
+      # Whether or not the passed-in style (or list of styles) is valid.
+      #
+      # @see validate
+      #
+      # @param style [Style,String,IO,Array] the style (or a list of styles)
+      #   to validate.
+      #
+      # @raise [ArgumentError] if the passed-in argument is not a Style or
+      #   a valid style location.
+      # @raise [ValidationError] if the validation process fails
+      #
+      # @return [Boolean] whether or not the passed-in style (or styles)
+      #   is valid.
+      def valid?(style)
+        validate(style).empty?
+      end
+      
+      private
+      
+      attr_reader :validators, :validator, :schema
     end
     
-  end
-  
+  end  
 end

data/lib/csl/style.rb

@@ -15,24 +15,23 @@ module CSL
       attr_accessor :default
 
       def parse(data)
-        node = CSL.parse!(data)
+        node = CSL.parse!(data, self)
         
         raise ParseError, "root node is not a style: #{node.inspect}" unless
           node.is_a?(self)
         
         node
       end
-      
     end
     
     attr_defaults :version => Schema.version, :xmlns => Schema.namespace
     
-    attr_struct :xmlns, :version, :'style-class', :'default-locale',
+    attr_struct :xmlns, :version, :class, :'default-locale',
       :'initialize-with-hyphen', :'page-range-format',
       :'demote-non-dropping-particle', *Schema.attr(:name, :names)
     
-    attr_children :'style-options', :info, :locale, :macro, :citation,
-      :bibliography
+    attr_children :'style-options', :info, :locale, :macro,
+      :citation, :bibliography
     
     alias metadata info
     alias options  style_options
@@ -46,8 +45,20 @@ module CSL
       
       yield self if block_given?
     end
+
+    def validate
+      Schema.validate self
+    end
+    
+    def valid?
+      validate.empty?
+    end
     
+    private
     
+    def preamble
+      Schema.preamble.dup
+    end 
   end
     
 end

data/lib/csl/style/choose.rb

@@ -0,0 +1,16 @@
+module CSL
+  class Style
+    
+    class Choose < Node
+
+      class Block < Node
+        
+        def self.matches?(nodename)
+          nodename.to_s =~ /^if(-else)?|else$/
+        end
+        
+      end
+    end
+    
+  end
+end

data/lib/csl/style/date.rb

@@ -2,13 +2,13 @@ module CSL
   class Style
     
     class Date < Node
-      attr_struct :name, :form, :'range-delimiter', :'date-parts',
-        *Schema.attr(:affixes, :display, :font, :textcase)      
+      attr_struct :name, :form, :'range-delimiter', :'date-parts', :variable,
+        :'text-case', *Schema.attr(:affixes, :display, :font, :delimiter)   
     end
     
     class DatePart < Node
-      attr_struct :name, :form, :'range-delimiter',
-        *Schema.attr(:affixes, :textcase, :font, :periods)
+      attr_struct :name, :form, :'range-delimiter', :'text-case',
+        *Schema.attr(:affixes, :font, :periods)
     end
     
     

data/lib/csl/style/label.rb

@@ -5,8 +5,8 @@ module CSL
    
       has_no_children
       
-      attr_struct :variable, :form, :plural,
-        *Schema.attr(:affixes, :font, :textcase, :periods)
+      attr_struct :variable, :form, :plural, :'text-case',
+        *Schema.attr(:affixes, :font, :periods)
       
     end
     

data/lib/csl/style/names.rb

@@ -3,7 +3,7 @@ module CSL
     
     class Names < Node
       
-      attr_struct :variable, *Schema.attr(:names)      
+      attr_struct :variable, *Schema.attr(:names, :delimiter, :affixes, :display, :font)      
       
       attr_children :name, :'et-al', :label, :substitute
       
@@ -30,7 +30,7 @@ module CSL
       def initialize(attributes = {})
         super(attributes)
         children[:'name-part'] = []
-        
+
         yield self if block_given?
       end
       
@@ -38,7 +38,7 @@ module CSL
 
     class NamePart < Node
       has_no_children
-      attr_struct :name, *Schema.attr(:textcase, :affixes, :font)
+      attr_struct :name, :'text-case', *Schema.attr(:affixes, :font)
     end
     
     class EtAl < Node

data/lib/csl/style/number.rb

@@ -2,7 +2,8 @@ module CSL
   class Style
     
     class Number < Node
-      attr_struct :form, *Schema.attr(:affixes, :display, :font, :textcase)
+      attr_struct :variable, :form, :'text-case',
+        *Schema.attr(:affixes, :display, :font)
       
 
       # @return [Boolean] whether or not the number's format is set to

data/lib/csl/style/text.rb

@@ -2,8 +2,8 @@ module CSL
   class Style
     
     class Text < Node
-      attr_struct :macro, :term, :form, :plural, :value,
-        *Schema.attr(:affixes, :display, :font, :quotes, :periods, :textcase)
+      attr_struct :variable, :macro, :term, :form, :plural, :'text-case',
+        :value, *Schema.attr(:affixes, :display, :font, :quotes, :periods)
     end
     
   end

data/lib/csl/version.rb

@@ -1,3 +1,3 @@
 module CSL  
-  VERSION = '1.0.0.pre1'.freeze
+  VERSION = '1.0.0.pre2'.freeze
 end

data/spec/csl/info_spec.rb

@@ -45,9 +45,28 @@ module CSL
       it 'prints the category if present' do
         Info.new { |i| i.category = 'author' }.to_xml.should == '<info><category>author</category></info>'
       end
-      
     end
     
+    describe '#pretty_print' do
+      it 'returns an empty info element by default' do
+        subject.pretty_print.should == '<info/>'
+      end
+
+      it 'prints the id indented if present' do
+        Info.new { |i| i.set_child_id 'apa' }.pretty_print.should == "<info>\n  <id>apa</id>\n</info>"
+      end
+    end
+    
+    describe '#tags' do
+      it 'returns a list with an empty info element by default' do
+        subject.tags.should == ['<info/>']
+      end
+      
+      it 'returns a nested list if id is present' do
+        Info.new { |i| i.set_child_id 'apa' }.tags.should == ['<info>', ['<id>apa</id>'], '</info>']
+      end
+      
+    end
   end
   
   describe Info::Author do

data/spec/csl/locale/term_spec.rb

@@ -76,6 +76,51 @@ module CSL
           f.matches?(:name => 'edition', :gender => 'feminine').should be_true
         end
       end
+      
+      describe 'attributes#to_a' do
+        it 'returns an array of all attribute values of underlying struct' do
+          f.attributes.to_a.should == ['edition', nil, 'feminine', nil]
+        end
+      end
+    end
+    
+    describe '#to_s' do
+      it 'returns an empty string by default' do
+        Locale::Term.new.to_s.should == ''
+      end
+      
+      describe 'given a simple term' do
+        let(:node) { Locale::Term.new { |t| t.text = 'foo' } }
+        
+        it "returns the term's text" do
+          node.to_s.should == node.text
+        end
+      end
+
+      describe 'given a compound term' do
+        let(:node) { Locale::Term.new { |t| t.single = 'shoe'; t.multiple = 'shoes' } }
+
+        it "returns the term's singular form by default" do
+          node.to_s.should == node.singularize
+        end
+        
+        it "returns the term's plural form when passed :number => :plural" do
+          node.to_s(:number => :plural).should == node.pluralize
+        end
+
+        it "returns the term's plural form when passed :number => 2" do
+          node.to_s(:number => 2).should == node.pluralize
+        end
+
+        it "returns the term's singular form when passed :number => 1" do
+          node.to_s(:number => 1).should == node.singularize
+        end
+
+        it "returns the term's plural form when passed :plural => true" do
+          node.to_s(:plural => true).should == node.pluralize
+        end
+
+      end
     end
     
 		describe '#to_xml' do

data/spec/csl/node_spec.rb

@@ -92,9 +92,11 @@ module CSL
       it 'accepts hash and yields itself to the optional block' do
         TextNode.new(:foo => 'bar') { |n| n.text = 'foo' }.to_xml.should == '<text-node foo="bar">foo</text-node>'
       end
-      
     end
     
+    describe '#pretty_print' do
+      TextNode.new(:foo => 'bar') { |n| n.text = 'foo' }.pretty_print.should == '<text-node foo="bar">foo</text-node>'
+    end
   end
   
 end