csl 1.0.0.pre1

data/lib/csl/parser.rb

@@ -0,0 +1,92 @@
+module CSL
+  #
+  # A relatively straightforward XML parser that parses CSL using either
+  # Nokogiri or REXML.
+  #
+  class Parser
+    include Singleton
+
+    attr_accessor :parser
+    
+    @engines = {
+      :nokogiri => lambda { |source|
+        Nokogiri::XML::Document.parse(source, nil, nil,
+          Nokogiri::XML::ParseOptions::DEFAULT_XML | Nokogiri::XML::ParseOptions::NOBLANKS)
+      },
+      :default  => lambda { |source|
+        REXML::Document.new(source, :compress_whitespace => :all, :ignore_whitespace_nodes => :all)
+      }
+    }
+    
+    class << self
+      attr_reader :engines
+    end
+    
+    def initialize
+      require 'nokogiri'
+      @parser = Parser.engines[:nokogiri]
+    rescue LoadError
+      require 'rexml/document'
+      @parser = Parser.engines[:default]
+    end
+    
+    def parse(*arguments)
+      parse!(*arguments)
+    rescue
+      nil
+    end
+    
+    def parse!(source, scope = Node)
+      root = parser[source].children.detect { |child| !comment?(child) }
+      parse_tree root, scope
+    end
+
+    private
+    
+    def parse_node(node, scope = Node)
+      attributes, text = parse_attributes(node), parse_text(node)
+      
+      if text
+        n = TextNode.create node.name, attributes
+        n.text = text
+        n
+      else
+        scope.create node.name, attributes
+      end
+    end
+    
+    def parse_attributes(node)
+      Hash[*node.attributes.map { |n, a|
+        [n.to_sym, a.respond_to?(:value) ? a.value : a.to_s]
+      }.flatten]
+    end
+    
+    def parse_tree(node, scope = Node)
+			return nil if node.nil?
+			
+      root = parse_node node, scope
+
+      node.children.each do |child|
+        root << parse_tree(child, scope) unless comment?(child)
+      end unless root.textnode?
+      
+      root
+    end
+    
+    def parse_text(node)
+      if node.respond_to?(:has_text?)
+        node.has_text? && node.text
+      else
+        child = node.children[0]
+        child && child.respond_to?(:text?) && child.text? && child.text
+      end
+    end
+    
+		def comment?(node)
+			node.respond_to?(:comment?) && node.comment? ||
+				node.respond_to?(:node_type) && [:comment, :xmldecl].include?(node.node_type)
+		end
+		
+  end
+  
+end

data/lib/csl/pretty_printer.rb

@@ -0,0 +1,33 @@
+module CSL
+  module PrettyPrinter
+    
+    def tags
+      raise 'not implemened by base class'
+    end
+    
+    def to_xml
+      tags.flatten.join
+    end
+    
+    def pretty_print
+      pp(tags).join("\n")
+    end
+
+    private
+    
+		def tabwidth
+			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
+      end
+    end
+    
+  end
+end

data/lib/csl/schema.rb

@@ -0,0 +1,109 @@
+module CSL
+  
+  class Schema
+    
+    @version   = '1.0.1'.freeze
+    @namespace = 'http://purl.org/net/xbiblio/csl'.freeze
+    @preamble  = '<?xml version="1.0" encoding="utf-8"?>'.freeze
+    
+    @types = %w{ 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 }.map(&:to_sym).freeze
+
+    @variables = Hash.new { |h,k| h.fetch(k.to_sym, nil) }.merge({
+      :date => %w{
+        accessed container event-date issued original-date submitted
+      },
+
+      :names => %w{
+        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{
+        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
+      }
+    })
+
+    @variables.each_value { |v| v.map!(&:to_sym).freeze }
+
+    @categories = Hash.new { |h,k| h.fetch(k.to_sym, nil) }.merge(
+      Hash[*@variables.keys.map { |k| @variables[k].map { |n| [n,k] } }.flatten]
+    ).freeze
+
+    @variables[:name] = @variables[:names]
+    @variables[:dates] = @variables[:date]
+    @variables[:numbers] = @variables[:number]
+
+    @variables[:all] = @variables[:any] =
+      [:date,:names,:text,:number].reduce([]) { |s,a| s.concat(@variables[a]) }.sort
+
+    @variables.freeze
+    
+    @attributes = Hash.new { |h,k| h.fetch(k.to_sym, nil) }.merge({
+      :affixes => %w{
+        prefix suffix
+      },
+      :delimiter => %w{
+        delimiter
+      },
+      :display => %w{
+        block left-margin right-inline indent
+      },
+      :font => %w{
+        font-style font-variant font-weight text-decoration vertical-align
+      },
+      :quotes => %w{
+        quotes
+      },
+      :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 
+      },
+      :names => %w{
+        names-delimiter
+      }
+    })
+    
+    @attributes.each_value { |v| v.map!(&:to_sym).freeze }
+    @attributes.freeze
+    
+    
+    class << self
+      
+      attr_accessor :version, :namespace, :types, :variables, :categories,
+        :attributes, :preamble
+      
+      private :new
+      
+      def attr(*arguments)
+        attributes.values_at(*arguments).flatten(1)
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/csl/style.rb

@@ -0,0 +1,53 @@
+module CSL
+  
+  class Style < Node
+    
+    @default = :apa
+
+    @root = File.expand_path('../../../vendor/styles', __FILE__).freeze
+        
+    @extension = '.csl'.freeze
+    @prefix = ''
+    
+    class << self
+      include Loader
+      
+      attr_accessor :default
+
+      def parse(data)
+        node = CSL.parse!(data)
+        
+        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',
+      :'initialize-with-hyphen', :'page-range-format',
+      :'demote-non-dropping-particle', *Schema.attr(:name, :names)
+    
+    attr_children :'style-options', :info, :locale, :macro, :citation,
+      :bibliography
+    
+    alias metadata info
+    alias options  style_options
+    alias locales  locale
+    
+    def initialize(attributes = {})
+      super(attributes)
+      
+      children[:locale] = []
+      children[:macro]  = []
+      
+      yield self if block_given?
+    end
+    
+    
+  end
+    
+end

data/lib/csl/style/bibliography.rb

@@ -0,0 +1,15 @@
+module CSL
+  class Style
+    
+    class Bibliography < Node
+      
+      attr_struct :'hanging-indent', :'second-field-align', :'line-spacing',
+        :'entry-spacing', :'note-distance', :'subsequent-author-substitute',
+        :'subsequent-author-substitute-rule', *Schema.attr(:name, :names)
+      
+      attr_children :sort, :layout
+      
+    end
+    
+  end
+end

data/lib/csl/style/citation.rb

@@ -0,0 +1,17 @@
+module CSL
+  class Style
+    
+    class Citation < Node
+      
+      attr_struct :'cite-group-delimiter', :collapse, :'year-suffix-delimiter',
+        :'after-collapse-delimiter', :'disambiguate-add-names',
+        :'disambiguate-add-givenname', :'disambiguate-add-year-suffix',
+        :'givenname-disambiguation-rule', :'names-delimiter',
+        *Schema.attr(:names, :name)
+    
+      attr_children :sort, :layout
+      
+    end
+    
+  end
+end

data/lib/csl/style/conditional.rb

@@ -0,0 +1,11 @@
+module CSL
+  class Style
+    
+    class Conditional < Node
+      
+      class Block < Node
+      end    
+    end
+    
+  end
+end

data/lib/csl/style/date.rb

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

data/lib/csl/style/group.rb

@@ -0,0 +1,9 @@
+module CSL
+  class Style
+    
+    class Group < Node
+      attr_struct *Schema.attr(:affixes, :display, :delimiter)      
+    end
+    
+  end
+end

data/lib/csl/style/label.rb

@@ -0,0 +1,14 @@
+module CSL
+  class Style
+    
+    class Label < Node
+   
+      has_no_children
+      
+      attr_struct :variable, :form, :plural,
+        *Schema.attr(:affixes, :font, :textcase, :periods)
+      
+    end
+    
+  end
+end

data/lib/csl/style/layout.rb

@@ -0,0 +1,10 @@
+module CSL
+  class Style
+    
+    class Layout < Node
+      attr_struct *Schema.attr(:affixes, :font, :delimiter)
+    
+    end
+    
+  end
+end

data/lib/csl/style/macro.rb

@@ -0,0 +1,9 @@
+module CSL
+  class Style
+    
+    class Macro < Node
+      attr_struct :name
+    end
+  
+  end
+end

data/lib/csl/style/names.rb

@@ -0,0 +1,54 @@
+module CSL
+  class Style
+    
+    class Names < Node
+      
+      attr_struct :variable, *Schema.attr(:names)      
+      
+      attr_children :name, :'et-al', :label, :substitute
+      
+      alias labels label
+      
+      def initialize(attributes = {})
+        super(attributes)
+        children[:label] = []
+        
+        yield self if block_given?
+      end
+      
+    end
+    
+    
+    class Name < Node
+    
+      attr_struct :form, *Schema.attr(:name, :affixes, :font, :delimiter)
+
+      attr_children :'name-part'
+
+      alias parts name_part
+
+      def initialize(attributes = {})
+        super(attributes)
+        children[:'name-part'] = []
+        
+        yield self if block_given?
+      end
+      
+    end
+
+    class NamePart < Node
+      has_no_children
+      attr_struct :name, *Schema.attr(:textcase, :affixes, :font)
+    end
+    
+    class EtAl < Node
+      has_no_children
+      attr_struct :term, *Schema.attr(:affixes, :font)
+    end
+
+    class Substitute < Node
+    end
+    
+    
+  end
+end