csl 1.2.1 → 1.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0dd57180de9ed4d48bb5ce00393929be63df55fe
-  data.tar.gz: c20b280f2e9ec6f596d0453fc4862e23cbf50dec
+  metadata.gz: 4ba697e8ee6beb0a5f0e7cb670c6e9e7310ef449
+  data.tar.gz: b533d511d930f657c16d33eb65514b740817559b
 SHA512:
-  metadata.gz: 4d3ddca5ec5ab21e0d9e4ec973356e76f4abae8bf6b75868d7d4ffa7a10bd3853f510f280497302f3cc36f342a58f5238ab3650dc180085d36a595d21a2de4bc
-  data.tar.gz: 2a6911020b2bedc729617cb95c88db7184c5447d897f52d8ebc6ac84dbfd5f92b12a6cba54f78fe871f361eb48b37b4abc3a44b379493c6cb99000595a6d04da
+  metadata.gz: bfe06f2128b18206ffa1cc3a201b04bc6e65f6ae6b84cad7314793914568ea25db42ec0e153ece3f2fdac7d20d00cc4b31faa2b33cd1fec6aed447bc9887b207
+  data.tar.gz: c4b0e5a5e26af8fe88d9ada3b7ac7aeb50ea4f3925fe835525e4c0fea427347dd78712d10f4da8913b08e14ad867b12e9fdc36b5862650321ffd8beab4c9fad9

data/features/step_definitions/locale_steps.rb

@@ -11,7 +11,7 @@ When /^I ordinalize the number (\d+)(?: using the (long) form(?: and (feminine|m
 end
 
 Then /^the ordinal should (?:be|equal) "([^"]*)"$/ do |ord|
-  @ordinal.should == ord
+  expect(@ordinal).to eq(ord)
 end
 
 When /^I ordinalize these numbers:?$/ do |table|
@@ -22,13 +22,15 @@ When /^I ordinalize these numbers:?$/ do |table|
 end
 
 Then /^the ordinals should (?:be|equal):?$/ do |table|
-  @ordinals.join(' ').should == table.rows.flatten.join(' ')
+  expect(@ordinals.join(' ')).to eq(table.rows.flatten.join(' '))
 end
 
 Then /^the locale should should have (\d+) terms$/ do |num|
-	@csl.terms.length.should == num.to_i
+	expect(@csl.terms.length).to eq(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
+	expect(
+    @csl.terms.detect { |t| t.name == name }.send(method)
+  ).to eq(expected)
+end

data/features/step_definitions/parser_steps.rb

@@ -6,35 +6,35 @@ end
 Then /^(?:the )?(\w+[\?!]?) should be "([^"]*)"$/ do |name, expected|
   actual = @csl.send(name)
   actual = !!actual if expected =~ /^true|false$/
-  actual.to_s.should == expected
+  expect(actual.to_s).to eq(expected)
 end
 
 Then /^the (\w+) (\w+) should be "([^"]*)"$/ do |outer, inner, expected|
-  @csl.send(outer).send(inner).to_s.should == expected
+  expect(@csl.send(outer).send(inner).to_s).to eq(expected)
 end
 
 Then /^the attribute "([^"]*)" should be "([^"]*)"$/ do |name, expected|
-  @csl[name.to_sym].should == expected
+  expect(@csl[name.to_sym]).to eq(expected)
 end
 
 Then /^the node should have (\d+) (\w+)$/ do |length, name|
-  @csl.send(name).length.should == length.to_i
+  expect(@csl.send(name).length).to eq(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
+  expect(@csl.send("#{name}s")[offset.to_i - 1][attribute.to_sym]).to eq(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?
+  expect(@csl.send("#{name}s")[offset.to_i - 1].send("#{predicate}?")).to eq(negate.nil?)
 end
 
 Then /^the (\w+) number (\d+)'s (\w+) should( not)? be "([^"]*)"$/ do |name, offset, method, negate, expected|
   actual = @csl.send("#{name}s")[offset.to_i - 1].send(method).to_s
   
   if negate.nil?
-    actual.should == expected
+    expect(actual).to eq(expected)
   else
-    actual.should_not == expected
+    expect(actual).not_to eq(expected)
   end
 end

data/features/step_definitions/style_steps.rb

@@ -4,13 +4,13 @@ When /^I load the style from the string$/ do |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
+	expect(@csl.locales[locale.to_i - 1].terms.length).to eq(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
+  expect(@csl.locales[locale.to_i - 1].send(method).to_s).to eq(expected)
 end
 
 Then /^the style should have (\d+) contributors$/ do |num|
-  @csl.info.contributors.length.should == num.to_i
+  expect(@csl.info.contributors.length).to eq(num.to_i)
 end

data/lib/csl/loader.rb

@@ -72,11 +72,11 @@ module CSL
         input = input.to_s
 
         case
-        when File.exists?(input)
+        when File.exist?(input)
           location = input
-        when File.exists?(extend_name(input))
+        when File.exist?(extend_name(input))
           location = extend_name(input)
-        when File.exists?(extend_path(input))
+        when File.exist?(extend_path(input))
           location = extend_path(input)
         else
           location = input

data/lib/csl/node.rb

@@ -433,6 +433,11 @@ module CSL
     end
 
 
+    # The node's formatting options. If the node's parent responds
+    # to `inheritable_formatting_options`, these will be included
+    # in the result. This makes it easy for nodes to push formatting
+    # options to their child nodes.
+    #
     # @return [Hash] the node's formatting options
     def formatting_options
       options = attributes_for Schema.attr(:formatting)

data/lib/csl/style/group.rb

@@ -5,8 +5,7 @@ module CSL
     # element (with the exception of {Layout}). Group nodes may carry the
     # delimiter attribute to separate their child elements, as well as
     # affixes and display attributes (applied to the output of the group
-    # as a whole) and formatting attributes (transmitted to the enclosed
-    # elements).
+    # as a whole).
     #
     # Groups implicitly act as a conditionals: a Group and its child
     # elements are suppressed if a) at least one rendering element in
@@ -27,10 +26,6 @@ module CSL
       def formatting_options
         attributes_for :display, *Schema.attr(:affixes) 
       end
-
-      def inheritable_formatting_options
-        attributes_for :'text-case', *Schema.attr(:font)
-      end
     end
     
   end

data/lib/csl/version.rb

@@ -1,3 +1,3 @@
 module CSL
-  VERSION = '1.2.1'.freeze
+  VERSION = '1.2.2'.freeze
 end

data/spec/csl/info_spec.rb

@@ -4,23 +4,23 @@ module CSL
 
   describe Info do
 
-    it { should_not be_nil }
-    it { should_not have_children }
+    it { is_expected.not_to be_nil }
+    it { is_expected.not_to have_children }
 
     before { @info = Info.new }
 
     describe '#nodename' do
       it 'returns "info"' do
-        subject.nodename.should == 'info'
+        expect(subject.nodename).to eq('info')
       end
     end
 
     describe 'license' do
-      it { should_not have_rights }
-      it { should_not be_default_license }
+      it { is_expected.not_to have_rights }
+      it { is_expected.not_to be_default_license }
 
       it 'has no license by default' do
-        @info.license.should be_nil
+        expect(@info.license).to be_nil
       end
 
       it 'setting a license adds a rights node' do
@@ -29,36 +29,36 @@ module CSL
 
       it 'setting the default license creates the default rights node' do
         @info.default_license!
-        @info.should have_rights
-        @info.should be_default_license
+        expect(@info).to have_rights
+        expect(@info).to be_default_license
 
         @info.rights.text = 'cc'
-        @info.should_not be_default_license
+        expect(@info).not_to be_default_license
 
         @info.default_license!
-        @info.should be_default_license
+        expect(@info).to be_default_license
       end
     end
 
     describe '#children' do
       it 'returns a Info::Children instance' do
-        @info.children.should be_a(Info::Children)
+        expect(@info.children).to be_a(Info::Children)
       end
 
       it 'allows to set the id by array accessor' do
-        lambda { Info.new.children[:id] = 'foo' }.should_not raise_error
+        expect { Info.new.children[:id] = 'foo' }.not_to raise_error
       end
     end
 
     describe '#category' do
       it 'returns an empty list by default' do
-        @info.category.should be_empty
+        expect(@info.category).to be_empty
       end
     end
 
     describe 'citation-format' do
       it 'has no citation-format by default' do
-        @info.citation_format.should be_nil
+        expect(@info.citation_format).to be_nil
       end
 
       it 'setting a citation-format creates a new category node' do
@@ -73,7 +73,7 @@ module CSL
         before { @info.add_child Info::Category.new(:'citation-format' => 'author') }
 
         it 'has a citation format' do
-          @info.citation_format.should == :author
+          expect(@info.citation_format).to eq(:author)
         end
 
         it 'setting a citation-format does not create a new category node' do
@@ -89,7 +89,7 @@ module CSL
         before { @info.add_child Info::Category.new(:field => 'literature') }
 
         it 'has no citation-format by default' do
-          @info.citation_format.should be_nil
+          expect(@info.citation_format).to be_nil
         end
 
         it 'setting a citation-format creates a new category node' do
@@ -103,20 +103,20 @@ module CSL
     end
 
     describe 'link accessors' do
-      it { should_not have_self_link }
-      it { should_not have_documentation_link }
-      it { should_not have_template_link }
+      it { is_expected.not_to have_self_link }
+      it { is_expected.not_to have_documentation_link }
+      it { is_expected.not_to have_template_link }
 
       it 'self_link is nil by default' do
-        @info.self_link.should be_nil
+        expect(@info.self_link).to be_nil
       end
 
       it 'returns nil if no suitable link is set' do
-        Info.new {|i| i.link = {:href => 'foo', :rel => 'documentation'} }.self_link.should be_nil
+        expect(Info.new {|i| i.link = {:href => 'foo', :rel => 'documentation'} }.self_link).to be_nil
       end
 
       it 'returns the href value of the link if it is set' do
-        Info.new {|i| i.link = {:href => 'foo', :rel => 'self'} }.self_link.should == 'foo'
+        expect(Info.new {|i| i.link = {:href => 'foo', :rel => 'self'} }.self_link).to eq('foo')
       end
 
       it 'setter changes the value of existing link' do
@@ -126,73 +126,73 @@ module CSL
 
       it 'setter creates new link node if link did not exist' do
         expect { @info.self_link = 'bar' }.to change { @info.has_self_link? }
-        @info.links[0].should be_a(Info::Link)
+        expect(@info.links[0]).to be_a(Info::Link)
       end
 
     end
 
     describe '#to_xml' do
       it 'returns an empty info element by default' do
-        subject.to_xml.should == '<info/>'
+        expect(subject.to_xml).to eq('<info/>')
       end
 
       it 'prints the id if present' do
-        Info.new { |i| i.set_child_id 'apa' }.to_xml.should == '<info><id>apa</id></info>'
+        expect(Info.new { |i| i.set_child_id 'apa' }.to_xml).to eq('<info><id>apa</id></info>')
       end
 
       it 'prints the category if present' do
-        Info.new { |i| i.category = {:'citation-format' => 'author'} }.to_xml.should == '<info><category citation-format="author"/></info>'
+        expect(Info.new { |i| i.category = {:'citation-format' => 'author'} }.to_xml).to eq('<info><category citation-format="author"/></info>')
       end
     end
 
     describe '#dup' do
       it 'does not copy ancestors' do
         apa = Style.load(:apa).info
-        apa.should be_a(Info)
+        expect(apa).to be_a(Info)
 
-        apa.should_not be_root
-        apa.dup.should be_root
+        expect(apa).not_to be_root
+        expect(apa.dup).to be_root
       end
     end
 
     describe '#deep_copy' do
       it 'copies the full sub-tree' do
         apa = Style.load(:apa).info
-        apa.should be_a(Info)
+        expect(apa).to be_a(Info)
 
         xml = apa.to_xml
 
         copy = apa.deep_copy
 
-        apa.to_xml.should == xml # original unchanged!
-        copy.to_xml.should == xml
+        expect(apa.to_xml).to eq(xml) # original unchanged!
+        expect(copy.to_xml).to eq(xml)
       end
     end
 
     describe '#pretty_print' do
       it 'returns an empty info element by default' do
-        subject.pretty_print.should == '<info/>'
+        expect(subject.pretty_print).to eq('<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>"
+        expect(Info.new { |i| i.set_child_id 'apa' }.pretty_print).to eq("<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/>']
+        expect(subject.tags).to eq(['<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>']
+        expect(Info.new { |i| i.set_child_id 'apa' }.tags).to eq(['<info>', ['<id>apa</id>'], '</info>'])
       end
 
     end
   end
 
   describe Info::Author do
-    it { should_not be_nil }
+    it { is_expected.not_to be_nil }
 
     let(:poe) {
       Info::Author.new { |a|
@@ -203,33 +203,33 @@ module CSL
 
     describe '#name' do
       it 'returns nil by default' do
-        subject.name.should be nil
+        expect(subject.name).to be nil
       end
 
       it 'returns the name if set' do
-        poe.name.to_s.should == 'E. A. Poe'
+        expect(poe.name.to_s).to eq('E. A. Poe')
       end
     end
 
     describe '#family' do
       it "returns the author's family name" do
-        poe.family.should == 'Poe'
+        expect(poe.family).to eq('Poe')
       end
     end
 
     describe '#email' do
       it 'returns the email' do
-        poe.email.to_s.should == 'poe@baltimore.com'
+        expect(poe.email.to_s).to eq('poe@baltimore.com')
       end
     end
 
     describe '#to_xml' do
       it 'returns an empty author by default' do
-        subject.to_xml.should == '<author/>'
+        expect(subject.to_xml).to eq('<author/>')
       end
 
       it 'prints all children' do
-        poe.to_xml.should == '<author><name>E. A. Poe</name><email>poe@baltimore.com</email></author>'
+        expect(poe.to_xml).to eq('<author><name>E. A. Poe</name><email>poe@baltimore.com</email></author>')
       end
     end
 
@@ -237,31 +237,31 @@ module CSL
 
   describe Info::Contributor do
 
-    it { should_not be_nil }
+    it { is_expected.not_to be_nil }
 
     let(:bruce) { Info::Contributor.new { |c| c.name = "Bruce D'Arcus" } }
 
     describe '#name' do
       it 'returns the name' do
-        bruce.name.to_s.should == "Bruce D'Arcus"
+        expect(bruce.name.to_s).to eq("Bruce D'Arcus")
       end
     end
 
 
     describe '#to_xml' do
       it 'returns an empty contributor by default' do
-        subject.to_xml.should == '<contributor/>'
+        expect(subject.to_xml).to eq('<contributor/>')
       end
 
       it 'prints the name tag if present' do
-        bruce.to_xml.should == "<contributor><name>Bruce D'Arcus</name></contributor>"
+        expect(bruce.to_xml).to eq("<contributor><name>Bruce D'Arcus</name></contributor>")
       end
     end
 
   end
 
   describe Info::Rights do
-    it { should_not be_nil }
+    it { is_expected.not_to be_nil }
 
     describe '#dup' do
       it 'copies attributes and text' do
@@ -269,8 +269,8 @@ module CSL
         r[:license] = 'bar'
 
         c = r.dup
-        c.text.should == 'foo'
-        c[:license].should == 'bar'
+        expect(c.text).to eq('foo')
+        expect(c[:license]).to eq('bar')
       end
     end
   end