csl 1.4.5 → 1.5.0

data/spec/csl/node_spec.rb

@@ -1,273 +0,0 @@
-require 'spec_helper'
-
-module CSL
-
-  describe Node do
-
-    it { is_expected.not_to be nil }
-    it { is_expected.not_to have_children }
-    it { is_expected.to have_attributes(:attributes => {}) }
-
-    describe 'given a FooBarNode with attributes :foo and :bar and a TestNode without defined attributes' do
-      before(:all) do
-        class FooBarNode < Node
-          attr_struct :foo, :bar
-        end
-        class TestNode < Node
-        end
-      end
-
-      it 'creates FooBarNode::Attributes' do
-        expect(FooBarNode.const_defined?(:Attributes)).to be_truthy
-      end
-
-      it 'does not create TestNode::Attributes' do
-        expect(TestNode.const_defined?(:Attributes)).not_to be_truthy
-      end
-
-      it 'TestNode attributes are a regular Hash' do
-        expect(TestNode.new.attributes).to be_a(Hash)
-      end
-
-      it 'FooBarNode attributes are a Struct' do
-        expect(FooBarNode.new.attributes).to be_a(Struct)
-      end
-
-      describe '#match?' do
-        it 'matches an empty query' do
-          expect(FooBarNode.new.match?({})).to be_truthy
-          expect(FooBarNode.new(:foo => 'Foo').match?({})).to be_truthy
-          expect(TestNode.new.match?({})).to be_truthy
-          expect(TestNode.new(:foo => 'Foo').match?({})).to be_truthy
-        end
-
-        it 'returns true for a matching query' do
-          expect(FooBarNode.new(:foo => 'bar').match?(:foo => 'bar')).to be_truthy
-          expect(FooBarNode.new(:bar => 'b', :foo => 'f').match?(:foo => 'f', :bar => 'b')).to be_truthy
-        end
-
-        it 'returns false for non-matching query' do
-          expect(FooBarNode.new.match?(:foo => 'bar')).to be_falsey
-          expect(FooBarNode.new(:foo => 'f').match?(:foo => 'f', :bar => 'b')).to be_falsey
-        end
-
-        it 'returns false if the query contains unknown attributes' do
-          expect(FooBarNode.new(:foo => 'f').match?(:foo => 'f', :unknown => 'u')).to be_falsey
-        end
-
-        it 'matches irrespective of order' do
-          expect(FooBarNode.new(:bar => 'b', :foo => 'f').match?(:foo => 'f', :bar => 'b')).to be_truthy
-          expect(FooBarNode.new(:foo => 'f', :bar => 'b').match?(:foo => 'f', :bar => 'b')).to be_truthy
-          expect(FooBarNode.new(:foo => 'f', :bar => 'b').match?(:bar => 'b', :foo => 'f')).to be_truthy
-          expect(FooBarNode.new(:bar => 'b', :foo => 'f').match?(:bar => 'b', :foo => 'f')).to be_truthy
-        end
-
-        it 'matches an empty query with the correct node name' do
-          expect(FooBarNode.new.match?('foo-bar-node', {})).to be_truthy
-          expect(FooBarNode.new(:foo => 'Foo').match?('foo-bar-node', {})).to be_truthy
-          expect(TestNode.new.match?('test-node', {})).to be_truthy
-          expect(TestNode.new(:foo => 'Foo').match?('test-node', {})).to be_truthy
-        end
-
-        it 'does not match other node names' do
-          expect(FooBarNode.new.match?(:name, {})).not_to be_truthy
-          expect(FooBarNode.new(:foo => 'Foo').match?(:name, {})).not_to be_truthy
-          expect(TestNode.new.match?(:name, {})).not_to be_truthy
-          expect(TestNode.new(:foo => 'Foo').match?(:name, {})).not_to be_truthy
-        end
-      end
-
-      describe '#attributes_for' do
-        it 'returns an empty hash when there no attributes are set' do
-          expect(TestNode.new.attributes_for).to be_empty
-          expect(TestNode.new.attributes_for(:x, :y)).to be_empty
-
-          expect(FooBarNode.new.attributes_for).to be_empty
-          expect(FooBarNode.new.attributes_for(:x, :y)).to be_empty
-          expect(FooBarNode.new.attributes_for(:foo, :bar)).to be_empty
-        end
-
-        it 'returns an empty hash when no attributes match the filter' do
-          expect(TestNode.new(:foo => 'foo').attributes_for).to be_empty
-          expect(TestNode.new(:foo => 'foo').attributes_for(:x, :y)).to be_empty
-
-          expect(FooBarNode.new(:foo => 'foo').attributes_for).to be_empty
-          expect(FooBarNode.new(:foo => 'foo').attributes_for(:x, :y)).to be_empty
-        end
-
-        it 'returns a hash of all set attributes that match the filter' do
-          expect(TestNode.new(:foo => 'foo', :bar => 'bar').attributes_for(:x, :foo)).to eq({ :foo => 'foo' })
-          expect(FooBarNode.new(:foo => 'foo', :bar => 'bar').attributes_for(:x, :foo)).to eq({ :foo => 'foo' })
-        end
-      end
-
-      describe '#formatting_options' do
-        it 'returns an empty hash by default' do
-          expect(TestNode.new.formatting_options).to be_empty
-          expect(FooBarNode.new.formatting_options).to be_empty
-        end
-
-        it 'returns an empty hash if there are no formatting attributes' do
-          expect(TestNode.new(:foo => 'foo', :bar => 'bar').formatting_options).to be_empty
-          expect(FooBarNode.new(:foo => 'foo', :bar => 'bar').formatting_options).to be_empty
-        end
-
-        it "returns a hash of the node's formatting attributes" do
-          expect(
-            TestNode.new(:foo => 'foo', :'font-style' => 'italic').formatting_options
-          ).to eq({ :'font-style' => 'italic' })
-        end
-      end
-
-      describe '#values_at' do
-        it 'FooBarNode accepts attribute names' do
-          expect(FooBarNode.new(:foo => 'Foo', :bar => 'Bar').values_at(:bar, :foo))
-            .to eq(%w{ Bar Foo })
-
-          expect(FooBarNode.new(:foo => 'Foo').values_at(:bar, :foo))
-            .to eq([nil, 'Foo'])
-
-          expect(FooBarNode.new(:foo => 'Foo').values_at(:unknown, :foo))
-            .to eq([nil, 'Foo'])
-        end
-
-        it 'TestNode accepts attribute names' do
-          expect(TestNode.new(:foo => 'Foo', :bar => 'Bar').values_at(:bar, :foo))
-            .to eq(%w{ Bar Foo })
-
-          expect(TestNode.new(:foo => 'Foo').values_at(:bar, :foo))
-            .to eq([nil, 'Foo'])
-          expect(TestNode.new(:foo => 'Foo').values_at(:unknown, :foo))
-            .to eq([nil, 'Foo'])
-        end
-      end
-
-      describe '#to_a' do
-        it 'returns an empty list by default' do
-          expect(Node.new.attributes.to_a).to eq([])
-        end
-
-        it 'TestNode returns an empty list by default' do
-          expect(TestNode.new.attributes.to_a).to eq([])
-        end
-
-        # it 'TestNode returns a list of all key/value pairs' do
-        #   TestNode.new(:foo => 'Foo', :bar => 'Bar').attributes.to_a.map(&:last).sort.should == %w{ Bar Foo }
-        # end
-
-        # it 'FooBarNode returns an empty list by default' do
-        #   FooBarNode.new.attributes.to_a.should == []
-        # end
-
-        # it 'FooBarNode returns a list of all key/value pairs' do
-        #   FooBarNode.new(:foo => 'Foo', :bar => 'Bar').attributes.to_a.map(&:last).sort.should == %w{ Bar Foo }
-        # end
-      end
-
-      describe 'attributes.keys' do
-        it 'returns all attribute names as symbols' do
-          expect(TestNode.new.attributes.keys).to be_empty
-          expect(FooBarNode.new.attributes.keys).to eq([:foo, :bar])
-        end
-      end
-    end
-
-    describe 'comparing nodes' do
-      it 'empty nodes are equal' do
-        expect(Node.new).to eq(Node.new)
-      end
-
-      it 'considers node names' do
-        expect(Node.new).not_to eq(Node.new { |n| n.nodename = 'foo' })
-      end
-
-      it 'considers attributes' do
-        expect(Node.new(:foo => 'bar')).to eq(Node.new(:foo => 'bar'))
-        expect(Node.new(:foo => 'bar')).not_to eq(Node.new(:foo => 'baz'))
-
-        expect(Node.new(:foo => 'bar', :baz => 'qux'))
-          .not_to eq(Node.new(:foo => 'bar'))
-
-        expect(Node.new(:foo => 'bar', :baz => 'qux'))
-          .to eq(Node.new(:baz => 'qux', :foo => 'bar'))
-      end
-
-      it 'considers children' do
-        n1, n2 = Node.new, Node.new
-
-        n1 << Node.new
-        expect(n1).not_to eq(n2)
-
-        n2 << Node.new
-        expect(n1).to eq(n2)
-
-        n2.children[0][:foo] = 'bar'
-        expect(n1).not_to eq(n2)
-
-        n1.children[0][:foo] = 'bar'
-        expect(n1).to eq(n2)
-      end
-
-    end
-  end
-
-  describe TextNode do
-    it { is_expected.not_to be nil }
-    it { is_expected.not_to have_children }
-    it { is_expected.to have_attributes(:attributes => {}) }
-
-    describe '.new' do
-      it 'accepts a hash of attributes' do
-        expect(TextNode.new(:foo => 'bar').attributes).to have_key(:foo)
-      end
-
-      it 'yields itself to the optional block' do
-        expect(TextNode.new { |n| n.text = 'foo' }.text).to eq('foo')
-      end
-
-      it 'accepts hash and yields itself to the optional block' do
-        expect(TextNode.new(:foo => 'bar') { |n| n.text = 'foo' }.to_xml)
-          .to eq('<text-node foo="bar">foo</text-node>')
-      end
-    end
-
-    describe '#pretty_print' do
-      it 'prints the text node as XML' do
-        expect(TextNode.new(:foo => 'bar') { |n| n.text = 'foo' }.pretty_print)
-          .to eq('<text-node foo="bar">foo</text-node>')
-      end
-    end
-
-    describe 'comparing nodes' do
-      it 'empty nodes are equal' do
-        expect(TextNode.new).to eq(TextNode.new)
-      end
-
-      it 'considers node names' do
-        expect(TextNode.new).not_to eq(TextNode.new { |n| n.nodename = 'foo' })
-      end
-
-      it 'considers attributes' do
-        expect(TextNode.new(:foo => 'bar')).to eq(TextNode.new(:foo => 'bar'))
-        expect(TextNode.new(:foo => 'bar')).not_to eq(TextNode.new(:foo => 'baz'))
-
-        expect(TextNode.new(:foo => 'bar', :baz => 'qux'))
-          .not_to eq(TextNode.new(:foo => 'bar'))
-
-        expect(TextNode.new(:foo => 'bar', :baz => 'qux'))
-          .to eq(TextNode.new(:baz => 'qux', :foo => 'bar'))
-      end
-
-      it 'considers text' do
-        n1, n2 = TextNode.new, TextNode.new
-
-        n1.text = 'foo'
-        expect(n1).not_to eq(n2)
-
-        n2.text = 'foo'
-        expect(n1).to eq(n2)
-      end
-    end
-  end
-
-end

data/spec/csl/parser_spec.rb

@@ -1,112 +0,0 @@
-require 'spec_helper'
-
-module CSL
-
-  describe Parser do
-
-    describe '.instance' do
-      it 'returns the parser' do
-        expect(Parser.instance).to be_instance_of(Parser)
-      end
-    end
-
-    Parser.engines.each_pair do |name, parser|
-      describe "when using the #{name} parser " do
-        before(:all) { Parser.instance.parser = parser }
-
-        describe '#parse' do
-
-          describe 'for <foo/>' do
-            let(:source) { '<foo/>' }
-
-            it 'returns a CSL::Node' do
-              expect(Parser.instance.parse(source)).to be_a(Node)
-            end
-
-            it 'returns a node with nodename "foo"' do
-              expect(Parser.instance.parse(source).nodename).to eq('foo')
-            end
-
-            it 'returns a node with no attributes' do
-              expect(Parser.instance.parse(source).attributes).to be_empty
-            end
-
-            it 'returns a node with no children' do
-              expect(Parser.instance.parse(source)).not_to have_children
-            end
-          end
-
-          describe 'for an empty name node' do
-            ['<name/>', '<name></name>', '<name> </name>'].each do |source|
-              it "returns a Style::Name for #{source.inspect} by default" do
-                expect(Parser.instance.parse!(source)).to be_a(Style::Name)
-              end
-
-              it "returns a Style::Name for #{source.inspect} for Style scope" do
-                expect(Parser.instance.parse!(source, Style)).to be_a(Style::Name)
-              end
-
-              it "returns a Node for #{source.inspect} for Locale scope" do
-                expect(Parser.instance.parse!(source, Locale)).to be_a(Node)
-              end
-
-              it "returns an Info::Name for #{source.inspect} for Info scope" do
-                expect(Parser.instance.parse!(source, Info)).to be_a(Info::Name)
-              end
-            end
-          end
-
-          describe 'for <foo bar="x"/>' do
-            let(:src) { '<foo bar="x"/>' }
-
-            it 'returns a node with attributes' do
-              expect(Parser.instance.parse(src).attributes).not_to be_empty
-            end
-
-            it 'returns a node with attribute bar' do
-              expect(Parser.instance.parse(src).attribute?(:bar)).to be
-            end
-
-            it 'bar should be "x"' do
-              expect(Parser.instance.parse(src)[:bar]).to eq('x')
-            end
-          end
-
-          describe 'for <foo>Foo Bar</foo>' do
-            let(:src) { '<foo>Foo Bar</foo>' }
-
-            it 'returns text node' do
-              expect(Parser.instance.parse(src)).to be_textnode
-            end
-          end
-
-          it 'returns a regular node for <x>\n <y/></x>' do
-            expect(Parser.instance.parse("<x>\n <y/></x>")).not_to be_textnode
-          end
-
-          describe 'xml comments' do
-            it 'ignores comment-only documents' do
-              expect(Parser.instance.parse("<!--x></x-->")).to be_nil
-            end
-
-            it 'ignores comments in normal nodes' do
-              expect(Parser.instance.parse("<x><!-- comment --></x>")).not_to have_children
-            end
-
-            it 'ignores comments in text nodes' do
-              node = Parser.instance.parse("<x>foo<!-- comment --></x>")
-              expect(node).to be_textnode
-              expect(node).not_to have_children
-              expect(node.text).to eq('foo')
-            end
-
-          end
-
-        end
-
-      end
-    end
-
-  end
-
-end

data/spec/csl/schema_spec.rb

@@ -1,112 +0,0 @@
-require 'spec_helper'
-
-module CSL
-  describe 'Schema' do
-
-    it 'cannot be instantiated' do
-      expect(Schema).not_to respond_to(:new)
-    end
-
-    describe '.version' do
-      it 'returns a version string' do
-        expect(Schema.version).to match(/^\d+\.\d+\.\d+/)
-      end
-
-      it 'is greater than 1.0' do
-        expect(Schema.version.split(/\./)[0].to_i).to be >= 1
-      end
-    end
-
-    describe '.variables' do
-      it 'contains :names fields' do
-        expect(Schema.variables[:names]).not_to be_empty
-        expect(Schema.variables[:name]).to equal Schema.variables[:names]
-      end
-
-      it 'contains :date fields' do
-        expect(Schema.variables[:date]).not_to be_empty
-        expect(Schema.variables[:dates]).to equal Schema.variables[:date]
-      end
-
-      it 'contains :text fields' do
-        expect(Schema.variables[:text]).not_to be_empty
-      end
-
-      it 'contains :number fields' do
-        expect(Schema.variables[:numbers]).not_to be_empty
-        expect(Schema.variables[:number]).not_to be_empty
-      end
-
-      it 'accepts either string or symbol input' do
-        expect(Schema.variables[:names]).to equal Schema.variables['names']
-      end
-    end
-
-    describe '.types' do
-      it 'returns an array' do
-        expect(Schema.types).to be_a(Array)
-      end
-
-      it 'is not empty' do
-        expect(Schema.types).not_to be_empty
-      end
-
-      it 'includes :article' do
-        expect(Schema.types).to include(:article)
-      end
-    end
-
-    describe '.categories' do
-      it 'given a field name returns the corresponding type' do
-        expect(Schema.categories.values_at(:author, :issued, :abstract, :issue)).to eq(
-          [:names, :date, :text, :number]
-        )
-      end
-
-      it 'accepts either string or symbol input' do
-        expect(Schema.categories).to have_key(:author)
-        expect(Schema.categories['author']).to equal Schema.categories[:author]
-      end
-    end
-
-    describe '.validate' do
-      it 'accepts and validates a locale instance' do
-        expect(Schema.validate(Locale.load('en-US'))).to eq([])
-      end
-
-      it 'accepts and validates a locale file path' do
-        expect(Schema.validate(File.join(Locale.root, 'locales-en-US.xml'))).to eq([])
-      end
-
-      it 'accepts and validates a locale file' do
-        expect(Schema.validate(File.open(File.join(Locale.root, 'locales-en-US.xml')))).to eq([])
-      end
-
-      it 'accepts and validates a locale wildcard path' do
-        expect(Schema.validate(File.join(Locale.root, 'locales-en-*.xml'))).to eq([])
-      end
-
-      it 'accepts and validates a style file path' do
-        expect(Schema.validate(File.join(Style.root, 'apa.csl'))).to eq([])
-      end
-
-      it 'accepts and validates the xml contents of a style instance' do
-        expect(Schema.validate(Style.load(:apa).pretty_print)).to eq([])
-      end
-
-      it 'accepts and validates a style instance' do
-        expect(Schema.validate(Style.load(:apa))).to eq([])
-      end
-
-      it 'does not accept invalid xml markup' do
-        expect(Schema.validate(%Q{
-         <style xmlns="http://purl.org/net/xbiblio/csl" class="note" version="1.0">
-         </stle>
-        })[0][0]).to eq(0) # error on line 0 -> parse error
-      end
-
-    # TODO fix nokogiri/jing validation
-    end unless RUBY_PLATFORM =~ /java/i
-
-  end
-end