html-table 1.7.0 → 1.7.1

data/spec/head_spec.rb

@@ -8,94 +8,109 @@
 require 'rspec'
 require 'html/table'
 
-#####################################################################
-# Ensure that a fresh instance of described_class is used between tests
-# by calling 'refresh' in the 'teardown' method.
-#####################################################################
-class HTML::Table::Head
-  private
-  def refresh
-    @@head = nil
-  end
-end
-
 RSpec.describe HTML::Table::Head do
   before do
-    @table = HTML::Table.new
     @thead = described_class.create
   end
 
-  example "constructor" do
+  after do
+    described_class.instance_variable_set(:@instance, nil)
+  end
+
+  example 'constructor' do
     expect{ described_class.create }.not_to raise_error
-    expect{ described_class.create("foo") }.not_to raise_error
+  end
+
+  example 'constructor with string' do
+    expect{ described_class.create('foo') }.not_to raise_error
+  end
+
+  example 'constructor with numeric' do
     expect{ described_class.create(1) }.not_to raise_error
-    expect{ described_class.create(%w/foo bar baz/) }.not_to raise_error
-    expect{ described_class.create([1,2,3]) }.not_to raise_error
-    expect{ described_class.create([[1,2,3],["foo","bar"]]) }.not_to raise_error
   end
 
-  example "basic" do
-    html = "<thead></thead>"
+  example 'constructor with arrays' do
+    expect{ described_class.create(%w[foo bar baz]) }.not_to raise_error
+    expect{ described_class.create([1, 2, 3]) }.not_to raise_error
+    expect{ described_class.create([[1, 2, 3], %w[foo bar]]) }.not_to raise_error
+  end
+
+  example 'basic' do
+    html = '<thead></thead>'
     expect(@thead.html.gsub(/\s{2,}|\n/, '')).to eq(html)
   end
 
-  example "end_tags" do
+  example 'end_tags? basic functionality' do
     expect(described_class).to respond_to(:end_tags?)
-    expect(described_class).to respond_to(:end_tags=)
+    expect(described_class.end_tags?).to be(true)
     expect{ described_class.end_tags? }.not_to raise_error
+  end
+
+  example 'end_tags= basic functionality' do
+    expect(described_class).to respond_to(:end_tags=)
     expect{ described_class.end_tags = true }.not_to raise_error
-    expect{ described_class.end_tags = "foo" }.to raise_error(HTML::Mixin::StrongTyping::ArgumentTypeError)
   end
 
-  example "with_attributes" do
+  example 'end_tags= does not allow invalid types' do
+    expect{ described_class.end_tags = 'foo' }.to raise_error(ArgumentTypeError)
+  end
+
+  example 'with attributes' do
     html = "<thead align='left' char='x'></thead>"
-    @thead.align = "left"
+    @thead.align = 'left'
     @thead.char = 'x'
     expect(@thead.html.gsub(/\s{2,}|\n/, '')).to eq(html)
   end
 
-  example "push_single_row" do
-    html = "<thead><tr><td>test</td></tr></thead>"
-    @thead.push HTML::Table::Row.new{|r| r.content = "test"}
+  example 'push single row' do
+    html = '<thead><tr><td>test</td></tr></thead>'
+    @thead.push(HTML::Table::Row.new{ |r| r.content = 'test' })
     expect(@thead.html.gsub(/\s{2,}|\n/, '')).to eq(html)
   end
 
-  example "push_multiple_rows" do
-    html = "<thead><tr><td>test</td></tr><tr><td>foo</td></tr></thead>"
-    r1 = HTML::Table::Row.new("test")
-    r2 = HTML::Table::Row.new("foo")
+  example 'push multiple rows' do
+    html = '<thead><tr><td>test</td></tr><tr><td>foo</td></tr></thead>'
+    r1 = HTML::Table::Row.new('test')
+    r2 = HTML::Table::Row.new('foo')
     @thead.push(r1, r2)
     expect(@thead.html.gsub(/\s{2,}|\n/, '')).to eq(html)
   end
 
-  example "add_content_directly" do
-    html = "<thead><tr><td>hello</td><td>world</td></tr></thead>"
-    @thead.content = "hello","world"
+  example 'add content directly' do
+    html = '<thead><tr><td>hello</td><td>world</td></tr></thead>'
+    @thead.content = 'hello', 'world'
     expect(@thead.html.gsub(/\s{2,}|\n+/, '')).to eq(html)
   end
 
-  example "add_content_in_constructor" do
-    html = "<thead><tr><td>hello</td><td>world</td></tr></thead>"
-    @thead.send(:refresh)
-    @thead = described_class.create(["hello","world"])
+  example 'add content in constructor' do
+    html = '<thead><tr><td>hello</td><td>world</td></tr></thead>'
+    described_class.instance_variable_set(:@instance, nil)
+    @thead = described_class.create(%w[hello world])
     expect(@thead.html.gsub(/\s{2,}|\n+/, '')).to eq(html)
   end
 
-  example "configure_column" do
+  example 'configure column' do
     html = "<thead><tr><td>hello</td><td abbr='test' width=3 nowrap>world"
-    html += "</td></tr></thead>"
-    @thead.content = "hello","world"
-    @thead.configure(0,1){ |d|
+    html += '</td></tr></thead>'
+    @thead.content = 'hello', 'world'
+    @thead.configure(0, 1) do |d|
       d.abbr = 'test'
       d.width = 3
       d.nowrap = true
-    }
+    end
     expect(@thead.html.gsub(/\s{2,}|\n+/, '')).to eq(html)
   end
 
-  after do
-    @table = nil
-    @thead.send(:refresh)
-    @thead = nil
+  # rubocop:disable RSpec/IdenticalEqualityAssertion
+  example 'new not allowed' do
+    expect{ described_class.new }.to raise_error(NoMethodError)
+  end
+
+  example 'additional calls to constructor do nothing since class is a singleton' do
+    expect(described_class.create).to eq(described_class.create)
+    expect(described_class.instance).to eq(described_class.instance)
+    expect(described_class.instance.object_id).to eq(described_class.instance.object_id)
+    expect(described_class.create.object_id).to eq(described_class.create.object_id)
   end
+  # rubocop:enable RSpec/IdenticalEqualityAssertion
 end

data/spec/header_spec.rb

@@ -11,21 +11,30 @@ RSpec.describe HTML::Table::Row::Header do
     @theader = described_class.new
   end
 
-  example "basic" do
-    html = "<th></th>"
+  example 'basic' do
+    html = '<th></th>'
     expect(@theader.html.gsub(/\s+/, '')).to eq(html)
   end
 
-  example "constructor" do
+  example 'constructor' do
     expect{ described_class.new }.not_to raise_error
-    expect{ described_class.new("foo") }.not_to raise_error
+  end
+
+  example 'constructor with string' do
+    expect{ described_class.new('foo') }.not_to raise_error
+  end
+
+  example 'constructor with numeric' do
     expect{ described_class.new(1) }.not_to raise_error
-    expect{ described_class.new(%w/foo bar baz/) }.not_to raise_error
-    expect{ described_class.new([1,2,3]) }.not_to raise_error
-    expect{ described_class.new([[1,2,3],["foo","bar"]]) }.not_to raise_error
   end
 
-  example "with_attributes" do
+  example 'constructor with arrays' do
+    expect{ described_class.new(%w[foo bar baz]) }.not_to raise_error
+    expect{ described_class.new([1, 2, 3]) }.not_to raise_error
+    expect{ described_class.new([[1, 2, 3], %w[foo bar]]) }.not_to raise_error
+  end
+
+  example 'with_attributes' do
     html = "<th align='left' colspan=3 nowrap></th>"
     @theader.align = 'left'
     @theader.colspan = 3
@@ -33,39 +42,43 @@ RSpec.describe HTML::Table::Row::Header do
     expect(@theader.html.gsub(/\s{2,}|\n+/, '')).to eq(html)
   end
 
-  example "configure_not_allowed" do
+  example 'configure_not_allowed' do
     expect{ @theader.configure }.to raise_error(NoMethodError)
   end
 
-  example "add_content" do
-    html = "<th>hello world</th>"
-    @theader.content = "hello world"
+  example 'add_content' do
+    html = '<th>hello world</th>'
+    @theader.content = 'hello world'
     expect(@theader.html.gsub(/\s{2,}/, '')).to eq(html)
   end
 
-  example "add_multiple_content_items" do
-    html = "<th>hello world</th>"
-    @theader.content = "hello"," world"
+  example 'add_multiple_content_items' do
+    html = '<th>hello world</th>'
+    @theader.content = 'hello', ' world'
     expect(@theader.html.gsub(/\s{2,}/, '')).to eq(html)
   end
 
-  example "add_content_in_constructor" do
-    html = "<th>hello world</th>"
-    @theader = described_class.new("hello world")
+  example 'add_content_in_constructor' do
+    html = '<th>hello world</th>'
+    @theader = described_class.new('hello world')
     expect(@theader.html.gsub(/\s{2,}/, '')).to eq(html)
   end
 
-  example "indent_level" do
+  example 'indent_level' do
     expect(described_class).to respond_to(:indent_level)
     expect(described_class).to respond_to(:indent_level=)
-    expect{ described_class.indent_level = "foo" }.to raise_error(ArgumentTypeError)
+    expect{ described_class.indent_level = 'foo' }.to raise_error(ArgumentTypeError)
     expect{ described_class.indent_level = 6 }.not_to raise_error
   end
 
-  example "end_tags" do
+  example 'end_tags? basic functionality' do
     expect(described_class).to respond_to(:end_tags?)
+    expect(described_class.end_tags?).to be(true)
+  end
+
+  example 'end_tags= only accepts valid types' do
     expect(described_class).to respond_to(:end_tags=)
-    expect{ described_class.end_tags = "foo" }.to raise_error(ArgumentTypeError)
+    expect{ described_class.end_tags = 'foo' }.to raise_error(ArgumentTypeError)
     expect{ described_class.end_tags = 1 }.to raise_error(ArgumentTypeError)
     expect{ described_class.end_tags = true }.not_to raise_error
   end

data/spec/html_handler_spec.rb

@@ -9,24 +9,27 @@ require 'html/table'
 
 RSpec.describe HTML::Mixin::HtmlHandler do
   before do
-    @table = HTML::Table.new(["foo",1,"bar"])
+    @table = HTML::Table.new(['foo', 1, 'bar'])
   end
 
-  example "html" do
+  example 'html basic functionality' do
     expect(@table).to respond_to(:html)
     expect{ @table.html }.not_to raise_error
-    expect{ @table.html = "foo" }.to raise_error(NoMethodError)
-    expect( @table.html).to be_kind_of(String)
-    expect( @table.html.length > 0).to eq(true)
+    expect(@table.html).to be_a(String)
+    expect(!@table.html.empty?).to be(true)
   end
 
-  example "modify_html" do
+  example 'there is no html= method' do
+    expect{ @table.html = 'foo' }.to raise_error(NoMethodError)
+  end
+
+  example 'modify_html' do
     expect{ @table.send(:modify_html) }.to raise_error(ArgumentError)
-    expect{ @table.send(:modify_html,"nowrap") }.not_to raise_error
-    expect{ @table.send(:modify_html,"align","top") }.not_to raise_error
-    expect{
-      @table.send(:modify_html,"align","top")
-      @table.send(:modify_html,"align","top")
-    }.not_to raise_error
+    expect{ @table.send(:modify_html, 'nowrap') }.not_to raise_error
+    expect{ @table.send(:modify_html, 'align', 'top') }.not_to raise_error
+    expect do
+      @table.send(:modify_html, 'align', 'top')
+      @table.send(:modify_html, 'align', 'top')
+    end.not_to raise_error
   end
 end

data/spec/row_spec.rb

@@ -1,136 +1,163 @@
 ############################################
 # row_spec.rb
 #
-# Specs for the Table::Row class.
+# Specs for the HTML::Table::Row class.
 ############################################
 require 'rspec'
 require 'html/table'
-include HTML
 
 RSpec.describe HTML::Table::Row do
   before do
     @trow = described_class.new
   end
 
-  example "constructor" do
-    expect{ Table::Row.new }.not_to raise_error
-    expect{ Table::Row.new("foo") }.not_to raise_error
-    expect{ Table::Row.new(1) }.not_to raise_error
-    expect{ Table::Row.new([1,2,3]) }.not_to raise_error
-    expect{ Table::Row.new([[1,2,3],["foo","bar"]]) }.not_to raise_error
+  example 'constructor' do
+    expect{ described_class.new }.not_to raise_error
   end
 
-  example "basic" do
-    html = "<tr></tr>"
+  example 'constructor with string argument' do
+    expect{ described_class.new('foo') }.not_to raise_error
+  end
+
+  example 'constructor with numeric argument' do
+    expect{ described_class.new(1) }.not_to raise_error
+  end
+
+  example 'constructor with array arguments' do
+    expect{ described_class.new([1, 2, 3]) }.not_to raise_error
+    expect{ described_class.new([[1, 2, 3], %w[foo bar]]) }.not_to raise_error
+  end
+
+  example 'basic' do
+    html = '<tr></tr>'
     expect(@trow.html.gsub(/\s+/, '')).to eq(html)
   end
 
-  example "header" do
+  example 'header' do
     expect(@trow).to respond_to(:header?)
     expect(@trow).to respond_to(:header=)
     expect{ @trow.header? }.not_to raise_error
     expect{ @trow.header = true }.not_to raise_error
   end
 
-  example "with_attributes" do
+  example 'with attributes' do
     html = "<tr align='center'></tr>"
-    @trow.align = "center"
+    @trow.align = 'center'
     expect(@trow.html.gsub(/\s{2,}|\n+/, '')).to eq(html)
   end
 
-  example "index_assignment_constraints" do
-    expect{ @trow[0] = "foo" }.to raise_error(ArgumentTypeError)
+  example 'index assignment allows valid types' do
+    expect{ @trow[0] = HTML::Table::Row::Data.new }.not_to raise_error
+    expect{ @trow[0] = HTML::Table::Row::Header.new }.not_to raise_error
+  end
+
+  example 'index assignment raises an error for invalid types' do
+    expect{ @trow[0] = 'foo' }.to raise_error(ArgumentTypeError)
     expect{ @trow[0] = 1 }.to raise_error(ArgumentTypeError)
-    expect{ @trow[0] = Table::Caption.new }.to raise_error(ArgumentTypeError)
-    expect{ @trow[0] = Table::Row::Data.new }.not_to raise_error
-    expect{ @trow[0] = Table::Row::Header.new }.not_to raise_error
+    expect{ @trow[0] = HTML::Table::Caption.new }.to raise_error(ArgumentTypeError)
   end
 
-  example "push_constraints" do
-    expect{ @trow.push(Table::Caption.new) }.to raise_error(ArgumentTypeError)
-    expect{ @trow.push(nil) }.to raise_error(ArgumentTypeError)
-    expect{ @trow.push("test") }.not_to raise_error
+  example 'push allows valid types' do
+    expect{ @trow.push('test') }.not_to raise_error
     expect{ @trow.push(7) }.not_to raise_error
-    expect{ @trow.push(Table::Row::Data.new) }.not_to raise_error
-    expect{ @trow.push(Table::Row::Header.new) }.not_to raise_error
+    expect{ @trow.push(HTML::Table::Row::Data.new) }.not_to raise_error
+    expect{ @trow.push(HTML::Table::Row::Header.new) }.not_to raise_error
+  end
+
+  example 'push raises an error for invalid types' do
+    expect{ @trow.push(HTML::Table::Caption.new) }.to raise_error(ArgumentTypeError)
+    expect{ @trow.push(nil) }.to raise_error(ArgumentTypeError)
   end
 
-  example "double_arrow_constraints" do
-    expect{ @trow << Table::Caption.new }.to raise_error(ArgumentTypeError)
-    expect{ @trow << "test" }.not_to raise_error
-    expect{ @trow << "test" << "foo" }.not_to raise_error
-    expect{ @trow << Table::Row::Data.new }.not_to raise_error
-    expect{ @trow << Table::Row::Header.new }.not_to raise_error
+  example 'double arrow allows valid types' do
+    expect{ @trow << 'test' }.not_to raise_error
+    expect{ @trow << 'test' << 'foo' }.not_to raise_error
+    expect{ @trow << HTML::Table::Row::Data.new }.not_to raise_error
+    expect{ @trow << HTML::Table::Row::Header.new }.not_to raise_error
   end
 
-  example "header_in_constructor" do
-    expect{ @trow = Table::Row.new('test', true) }.not_to raise_error
-    html = "<tr><th>test</th></tr>"
+  example 'double arrow raises an error for invalid types' do
+    expect{ @trow << HTML::Table::Caption.new }.to raise_error(ArgumentTypeError)
+  end
+
+  example 'header in constructor' do
+    expect{ @trow = described_class.new('test', true) }.not_to raise_error
+    html = '<tr><th>test</th></tr>'
     expect(@trow.html.gsub(/\s+/, '')).to eq(html)
   end
 
-  example "push_single_data_element" do
-    html = "<tr><td>hello</td></tr>"
-    @trow.push Table::Row::Data.new{ |d| d.content = "hello" }
+  example 'push single data element' do
+    html = '<tr><td>hello</td></tr>'
+    @trow.push(HTML::Table::Row::Data.new{ |d| d.content = 'hello' })
     expect(@trow.html.gsub(/\s{2,}|\n+/, '')).to eq(html)
   end
 
-  example "push_multiple_data_element" do
-    html = "<tr><td>hello</td><td>world</td></tr>"
-    d1 = Table::Row::Data.new{ |d| d.content = "hello" }
-    d2 = Table::Row::Data.new{ |d| d.content = "world" }
+  example 'push multiple data element' do
+    html = '<tr><td>hello</td><td>world</td></tr>'
+    d1 = HTML::Table::Row::Data.new{ |d| d.content = 'hello' }
+    d2 = HTML::Table::Row::Data.new{ |d| d.content = 'world' }
     @trow.push d1, d2
     expect(@trow.html.gsub(/\s{2,}|\n+/, '')).to eq(html)
   end
 
-  example "add_content_directly" do
-    html = "<tr><td>hello</td><td>world</td></tr>"
-    @trow.content = "hello","world"
+  example 'add content directly' do
+    html = '<tr><td>hello</td><td>world</td></tr>'
+    @trow.content = 'hello', 'world'
     expect(@trow.html.gsub(/\s{2,}|\n+/, '')).to eq(html)
   end
 
-  example "add_content_in_constructor" do
-    html = "<tr><td>hello</td><td>world</td></tr>"
-    @trow = Table::Row.new(%w/hello world/)
+  example 'add content in constructor' do
+    html = '<tr><td>hello</td><td>world</td></tr>'
+    @trow = described_class.new(%w[hello world])
     expect(@trow.html.gsub(/\s{2,}|\n+/, '')).to eq(html)
   end
 
-  example "configure_column" do
+  example 'configure column' do
     html = "<tr><td>hello</td><td abbr='test' width=3 nowrap>world</td></tr>"
-    @trow.content = "hello","world"
-    @trow.configure(1){ |d|
+    @trow.content = 'hello', 'world'
+    @trow.configure(1) do |d|
       d.abbr = 'test'
       d.width = 3
       d.nowrap = true
-    }
+    end
     expect(@trow.html.gsub(/\s{2,}|\n+/, '')).to eq(html)
   end
 
-  example "unshift_constraints" do
-    expect{ @trow.unshift(Table::Caption.new) }.to raise_error(ArgumentTypeError)
+  example 'unshift does not allow invalid types' do
+    expect{ @trow.unshift(HTML::Table::Caption.new) }.to raise_error(ArgumentTypeError)
     expect{ @trow.unshift(nil) }.to raise_error(ArgumentTypeError)
-    expect{ @trow.unshift("test") }.not_to raise_error
+  end
+
+  example 'unshift allows proper types' do
+    expect{ @trow.unshift('test') }.not_to raise_error
     expect{ @trow.unshift(7) }.not_to raise_error
-    expect{ @trow.unshift(Table::Row::Data.new) }.not_to raise_error
-    expect{ @trow.unshift(Table::Row::Header.new) }.not_to raise_error
+    expect{ @trow.unshift(HTML::Table::Row::Data.new) }.not_to raise_error
+    expect{ @trow.unshift(HTML::Table::Row::Header.new) }.not_to raise_error
+  end
+
+  example 'configure error' do
+    expect{ @trow.configure(0, 0){} }.to raise_error(ArgumentError)
+  end
+
+  example 'indent_level' do
+    expect(described_class).to respond_to(:indent_level)
+    expect(described_class).to respond_to(:indent_level=)
+    expect{ described_class.indent_level = 'foo' }.to raise_error(ArgumentTypeError)
+    expect{ described_class.indent_level = 3 }.not_to raise_error
   end
 
-  example "configure_error" do
-    expect{ @trow.configure(0,0){ }.to raise_error(ArgumentError) }
+  example 'end_tags?' do
+    expect(described_class).to respond_to(:end_tags?)
+    expect(described_class.end_tags?).to be(true)
   end
 
-  example "indent_level" do
-    expect(Table::Row).to respond_to(:indent_level)
-    expect(Table::Row).to respond_to(:indent_level=)
-    expect{ Table::Row.indent_level = "foo" }.to raise_error(ArgumentTypeError)
-    expect{ Table::Row.indent_level = 3 }.not_to raise_error
+  example 'end_tags= basic functionality' do
+    expect(described_class).to respond_to(:end_tags=)
+    expect{ described_class.end_tags = true }.not_to raise_error
   end
 
-  example "end_tags" do
-    expect(Table::Row).to respond_to(:end_tags?)
-    expect(Table::Row).to respond_to(:end_tags=)
-    expect{ Table::Row.end_tags = "foo" }.to raise_error(ArgumentTypeError)
-    expect{ Table::Row.end_tags = 1 }.to raise_error(ArgumentTypeError)
-    expect{ Table::Row.end_tags = true }.not_to raise_error
+  example 'end_tags= rejects invalid values' do
+    expect{ described_class.end_tags = 'foo' }.to raise_error(ArgumentTypeError)
+    expect{ described_class.end_tags = 1 }.to raise_error(ArgumentTypeError)
   end
 end