csl 1.0.0.pre1

data/features/parser/info.feature

@@ -0,0 +1,27 @@
+Feature: Parse CSL info elements
+	As a hacker of CSL styles
+	I want to be able to parse CSL info strings
+	
+	Scenario: A typical style info element
+		When I parse the CSL string
+			"""
+			<info>
+		    <title>American Medical Association</title>
+		    <id>http://www.zotero.org/styles/ama</id>
+		    <link href="http://www.zotero.org/styles/ama" rel="self"/>
+		    <author>
+		      <name>Julian Onions</name>
+		      <email>julian.onions@gmail.com</email>
+		    </author>
+		    <category citation-format="numeric"/>
+		    <category field="medicine"/>
+		    <updated/>
+		    <summary>The American Medical Association style as used in JAMA.</summary>
+		    <link href="http://www.samford.edu/schools/pharmacy/dic/amaquickref07.pdf" rel="documentation"/>
+		    <rights>This work is licensed under a Creative Commons Attribution-Share Alike 3.0 License: http://creativecommons.org/licenses/by-sa/3.0/</rights>
+		  </info>
+			"""
+		Then the nodename should be "info"
+		And the title should be "American Medical Association"
+		And the author name should be "Julian Onions"
+		And the author email should be "julian.onions@gmail.com"

data/features/parser/localized_dates.feature

@@ -0,0 +1,35 @@
+Feature: Parse CSL localized date elements
+	As a hacker of CSL styles
+	I want to be able to parse CSL localized date strings
+	
+	Scenario: A text date
+		When I parse the CSL string in the Locale scope
+			"""
+			<date form="text">
+		    <date-part name="month" suffix=" "/>
+		    <date-part name="day" form="numeric-leading-zeros" suffix=", "/>
+		    <date-part name="year"/>
+		  </date>
+			"""
+		Then the nodename should be "date"
+		And the attribute "form" should be "text"
+		And the node should have 3 parts
+		And text? should be "true"
+		And the part number 1 should have the attribute "name" set to "month"
+
+	Scenario: A numeric date
+		When I parse the CSL string in the Locale scope
+			"""
+		  <date form="numeric">
+		    <date-part name="month" form="numeric-leading-zeros" suffix="/"/>
+		    <date-part name="day" form="numeric-leading-zeros" suffix="/"/>
+		    <date-part name="year"/>
+		  </date>
+			"""
+		Then the nodename should be "date"
+		And the attribute "form" should be "numeric"
+		And the node should have 3 parts
+		And text? should be "false"
+		And numeric? should be "true"
+		And the part number 3 should have the attribute "name" set to "year"
+	

data/features/parser/terms.feature

@@ -0,0 +1,28 @@
+Feature: Parse CSL localized terms
+  As a hacker of CSL styles
+  I want to be able to parse CSL localized terms
+  
+  Scenario: A few standard terms
+    When I parse the CSL string
+      """
+      <terms>
+        <term name="accessed">accessed</term>
+        <term name="and">and</term>
+        <term name="and others">and others</term>
+        <term name="anonymous">anonymous</term>
+        <term name="anonymous" form="short">anon.</term>
+        <term name="circa">circa</term>
+        <term name="circa" form="short">c.</term>
+        <term name="cited">cited</term>
+        <term name="edition">
+          <single>edition</single>
+          <multiple>editions</multiple>
+        </term>
+      </terms>
+      """
+    Then the nodename should be "terms"
+    And the node should have 9 terms
+    And the term number 1 should have the attribute "name" set to "accessed"
+    And the term number 2 should be a textnode
+    And the term number 9 should have the attribute "name" set to "edition"
+    And the term number 9 should not be a textnode

data/features/step_definitions/locale_steps.rb

@@ -0,0 +1,34 @@
+Given /^the(?: following)? locale:?$/ do |string|
+  @csl = CSL::Locale.load(string)
+end
+
+When /^I load the locale from the string$/ do |string|
+  @csl = CSL::Locale.load(string)
+end
+
+When /^I ordinalize the number (\d+)(?: using the (long) form(?: and (feminine|masculine) gender))?$/ do |num, form, gender|
+  @ordinal = @locale.ordinalize(num, :form => form, :gender => gender)
+end
+
+Then /^the ordinal should (?:be|equal) "([^"]*)"$/ do |ord|
+  @ordinal.should == ord
+end
+
+When /^I ordinalize these numbers:?$/ do |table|
+  @ordinals = table.rows.map do |row|
+    num, form, gender, number = *row
+    @csl.ordinalize(num, :form => form, :gender => gender, :number => number)
+  end
+end
+
+Then /^the ordinals should (?:be|equal):?$/ do |table|
+  @ordinals.join(' ').should == table.rows.flatten.join(' ')
+end
+
+Then /^the locale should should have (\d+) terms$/ do |num|
+	@csl.terms.length.should == num.to_i
+end
+
+Then /^the (\w+[\?!]?) of the term "([^"]*)" should be "([^"]*)"$/ do |method, name, expected|
+	@csl.terms.detect { |t| t.name == name }.send(method).should == expected
+end

data/features/step_definitions/parser_steps.rb

@@ -0,0 +1,28 @@
+
+When /^I parse the CSL string(?: in the (\w+) scope)?$/ do |scope, string|
+  @csl = CSL.parse string, CSL.const_get(scope || 'Node')
+end
+
+Then /^(?:the )?(\w+[\?!]?) should be "([^"]*)"$/ do |name, expected|
+  @csl.send(name).to_s.should == expected
+end
+
+Then /^the (\w+) (\w+) should be "([^"]*)"$/ do |outer, inner, expected|
+  @csl.send(outer).send(inner).to_s.should == expected
+end
+
+Then /^the attribute "([^"]*)" should be "([^"]*)"$/ do |name, expected|
+  @csl[name.to_sym].should == expected
+end
+
+Then /^the node should have (\d+) (\w+)$/ do |length, name|
+  @csl.send(name).length.should == length.to_i
+end
+
+Then /^the (\w+) number (\d+) should have the attribute "([^"]*)" set to "([^"]*)"$/ do |name, offset, attribute, expected|
+  @csl.send("#{name}s")[offset.to_i - 1][attribute.to_sym].should == expected
+end
+
+Then /^the (\w+) number (\d+) should( not)? be a (\w+)$/ do |name, offset, negate, predicate|
+  @csl.send("#{name}s")[offset.to_i - 1].send("#{predicate}?").should == negate.nil?
+end

data/features/step_definitions/style_steps.rb

@@ -0,0 +1,16 @@
+
+When /^I load the style from the string$/ do |string|
+  @csl = CSL::Style.load string
+end
+
+Then /^the locale (\d+) should should have (\d+) terms?$/ do |locale, term|
+	@csl.locales[locale.to_i - 1].terms.length.should == term.to_i
+end
+
+Then /^the locale (\d+) (\w+\??) should be "([^"]*)"$/ do |locale, method, expected|
+  @csl.locales[locale.to_i - 1].send(method).to_s.should == expected
+end
+
+Then /^the style should have (\d+) contributors$/ do |num|
+  @csl.info.contributors.length.should == num.to_i
+end

data/features/style/loading.feature

@@ -0,0 +1,53 @@
+Feature: Loading CSL Style
+  As a hacker of CSL styles
+  I want to be able to parse CSL styles
+
+  Scenario: Loading a style from a string
+    When I load the style from the string
+      """
+      <?xml version="1.0" encoding="utf-8"?>
+      <style xmlns="http://purl.org/net/xbiblio/csl" class="in-text" version="1.0" demote-non-dropping-particle="never">
+        <info>
+      	<title>American Psychological Association 6th Edition</title>
+      	<id>http://www.zotero.org/styles/apa</id>
+      	<link href="http://www.zotero.org/styles/apa" rel="self"/>
+      	<link href="http://owl.english.purdue.edu/owl/resource/560/01/" rel="documentation"/>
+      	<author>
+      	  <name>Simon Kornblith</name>
+      	  <email>simon@simonster.com</email>
+      	</author>
+      	<contributor>
+      	  <name>Bruce D'Arcus</name>
+      	</contributor>
+      	<contributor>
+      	  <name>Curtis M. Humphrey</name>
+      	</contributor>
+      	<contributor>
+      	  <name>Richard Karnesky</name>
+      	  <email>karnesky+zotero@gmail.com</email>
+      	  <uri>http://arc.nucapt.northwestern.edu/Richard_Karnesky</uri>
+      	</contributor>
+      	<contributor>
+      	  <name>Sebastian Karcher</name>
+      	</contributor>
+      	<category field="psychology"/>
+      	<category field="generic-base"/>
+      	<category citation-format="author-date"/>
+      	<updated>2010-01-27T20:08:03+00:00</updated>
+      	<rights>This work is licensed under a Creative Commons Attribution-Share Alike 3.0 License: http://creativecommons.org/licenses/by-sa/3.0/</rights>
+        </info>
+        <locale xml:lang="en">
+      	<terms>
+      	  <term name="translator" form="short">
+      		<single>trans.</single>
+      		<multiple>trans.</multiple>
+      	  </term>
+      	</terms>
+        </locale>
+      </style>
+      """
+    Then the info title should be "American Psychological Association 6th Edition"
+    And the locale 1 should should have 1 term
+    And the locale 1 language should be "en"
+    And the locale 1 region should be "US"
+    And the style should have 4 contributors

data/features/support/env.rb

@@ -0,0 +1,8 @@
+begin
+  require 'simplecov'
+  require 'debugger'
+rescue LoadError
+  # ignore
+end
+
+require 'csl'

data/lib/csl.rb

@@ -0,0 +1,54 @@
+
+require 'enumerator'
+require 'forwardable'
+require 'open-uri'
+require 'singleton'
+require 'set'
+
+require 'csl/version'
+
+require 'csl/compatibility'
+require 'csl/extensions'
+require 'csl/errors'
+
+require 'csl/schema'
+
+require 'csl/pretty_printer'
+require 'csl/loader'
+require 'csl/parser'
+require 'csl/treelike'
+require 'csl/node'
+
+require 'csl/info'
+
+require 'csl/locale'
+require 'csl/locale/date'
+require 'csl/locale/term'
+require 'csl/locale/style_options'
+
+require 'csl/style'
+require 'csl/style/bibliography'
+require 'csl/style/citation'
+require 'csl/style/conditional'
+require 'csl/style/date'
+require 'csl/style/group'
+require 'csl/style/label'
+require 'csl/style/layout'
+require 'csl/style/macro'
+require 'csl/style/names'
+require 'csl/style/number'
+require 'csl/style/text'
+
+module CSL
+  
+  module_function
+  
+  def parse(*arguments)
+    Parser.instance.parse(*arguments)
+  end
+
+  def parse!(*arguments)
+    Parser.instance.parse!(*arguments)
+  end
+  
+end

data/lib/csl/compatibility.rb

@@ -0,0 +1,19 @@
+
+class Symbol
+  include Comparable
+  
+  def <=>(other)
+    return unless other.kind_of? Symbol
+    to_s <=> other.to_s
+  end
+end unless Symbol.is_a?(Comparable)
+
+class Module
+  if RUBY_VERSION < '1.9'
+    alias const? const_defined?
+  else
+    def const?(name)
+      const_defined?(name, false)
+    end
+  end
+end

data/lib/csl/errors.rb

@@ -0,0 +1,15 @@
+module CSL
+
+  class Error < StandardError
+    attr_reader :original
+
+    def initialize(message, original = $!)
+      @original = original
+			super(message)
+    end    
+  end
+  
+	class ParseError < Error; end
+	class ValidationError < Error; end
+
+end

data/lib/csl/extensions.rb

@@ -0,0 +1,63 @@
+
+# Some methods in this file are taken from ActiveSupport
+# and are copyright (c) 2005-2010 David Heinemeier Hansson.
+# They are loaded only if ActiveSupport is not present.
+
+module CSL
+  module Extensions
+
+    # ActiveSupport Fallback
+    module SymbolizeKeys
+      def symbolize_keys
+        inject({}) do |options, (key, value)|
+          options[(key.to_sym rescue key) || key] = value
+          options
+        end
+      end
+  
+      def symbolize_keys!
+        replace(symbolize_keys)
+      end
+
+    end
+
+    # ActiveSupport Fallback
+    module StringifyKeys
+      def stringify_keys
+        inject({}) do |options, (key, value)|
+          options[(key.to_s rescue key) || key] = value
+          options
+        end
+      end
+
+      def stringify_keys!
+        replace(symbolize_keys)
+      end
+    end
+
+		module Nesting
+			def nesting
+				name.split(/::/).inject([]) { |ns, n| ns << (ns[-1] || Object).const_get(n) }
+			end
+		end
+
+    module Blank
+      def blank?
+        nil? || respond_to?(:empty?) && empty?
+      end
+    end
+  end
+end
+
+class Hash
+  include CSL::Extensions::SymbolizeKeys unless method_defined?(:symbolize_keys)
+  include CSL::Extensions::StringifyKeys unless method_defined?(:stringify_keys)
+end
+
+class Module
+	include CSL::Extensions::Nesting
+end
+
+class Object
+  include CSL::Extensions::Blank unless method_defined?(:blank?)
+end

data/lib/csl/info.rb

@@ -0,0 +1,40 @@
+module CSL
+  
+  class Info < Node
+
+    attr_children :author, :category, :contributor, :id, :issn, :eissn,
+      :issnl, :link, :published, :rights, :summary, :title, :'title-short',
+      :updated, :'link-dependent-style'
+    
+    alias contributors contributor
+    
+    
+    class Contributor < Node
+      attr_children :name, :email, :uri
+    end
+    
+    class Author < Node
+      attr_children :name, :email, :uri
+    end
+    
+    class Translator < Node
+      attr_children :name, :email, :uri
+    end
+    
+    class Link < TextNode
+      attr_struct :href, :rel
+    end
+
+    class DependentStyle < TextNode
+      attr_struct :href, :rel
+    end
+
+
+    class Category < TextNode
+      attr_struct :field, :'citation-format'
+    end    
+    
+  end
+    
+  
+end

data/lib/csl/loader.rb

@@ -0,0 +1,78 @@
+module CSL
+  #
+  # Mixin used by Locale and Style to load assets either from disk or from
+  # the network. Classes including the Loader module are expected to provide
+  # appropriate root, prefix and extension values and a parse method that
+  # will be passed the contents of the asset data.
+  #
+  module Loader
+    
+    attr_accessor :root, :prefix, :extension
+    
+    # call-seq:
+    #   Style.load(:apa)                         -> style
+    #   Style.load('chicago-author.csl')         -> style
+    #   Locale.load('en')                        -> locale
+    #   Locale.load('http://example.com/de.xml') -> locale
+    #
+    # Resolves the passed-in path/name or string and loads the asset data.
+    # The data will be passed on to the #parse method of the base class.
+    # Typically, this will return a new instance of the class.
+    def load(input)
+      case
+      when input.respond_to?(:read)
+        data = input.read
+      when input.to_s =~ /^\s*</
+        data = input
+      else
+
+				case
+				when File.exists?(input)
+					location = input
+				when File.exists?(extend_name(input))
+					location = extend_name(input)
+				when File.exists?(extend_path(input))
+					location = extend_path(input)
+				else
+					location = input
+				end
+
+				Kernel.open(location, 'r:UTF-8') do |io|
+          data = io.read
+        end
+      end
+
+			parse(data)
+			
+		rescue => e
+			raise ParseError, "failed to load #{input.inspect}: #{e.message}"
+    end
+    
+    # Extends the passed-in string to a full path.
+    def extend_path(string)
+      File.join(root.to_s, extend_name(string))
+    end
+    
+    # Extends the passed-in string to a style/locale name, by prefixing and
+    # appending the default name prefix and extension.
+    def extend_name(string)
+      if File.extname(string).empty?
+        name = [string, extension].compact.join
+      else
+        name = string.to_s.dup
+      end
+      
+      unless name.start_with?(prefix.to_s)
+        name = [prefix, name].join
+      end
+      
+      name
+    end
+
+    # The base class is exepcted to redefine the #parse method.
+    def parse(data)
+      raise 'Not Implemented'
+    end
+  end
+  
+end