RubyGems - ruport - Versions diffs - 0.4.9 → 0.4.11 - Mend

ruport 0.4.9 → 0.4.11

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (33) hide show

data/AUTHORS +7 -9
data/CHANGELOG +36 -2
data/Rakefile +14 -1
data/TODO +0 -7
data/examples/create.sql +2 -0
data/examples/sql_query.rb +19 -0
data/lib/ruport.rb +1 -1
data/lib/ruport/data_row.rb +2 -1
data/lib/ruport/data_set.rb +28 -6
data/lib/ruport/format.rb +3 -3
data/lib/ruport/format/engine.rb +42 -46
data/lib/ruport/format/plugin.rb +57 -9
data/lib/ruport/query.rb +1 -1
data/lib/ruport/rails/reportable.rb +5 -5
data/lib/ruport/report.rb +3 -16
data/lib/ruport/system_extensions.rb +125 -0
data/test/tc_data_set.rb +47 -10
data/test/tc_format_engine.rb +46 -53
data/test/tc_plugin.rb +147 -2
data/test/ts_all.rb +0 -1
data/test/ts_format.rb +0 -1
data/test/unit.log +2506 -288
metadata +14 -21
data/lib/ruport/format/builder.rb +0 -123
data/lib/ruport/parser.rb +0 -202
data/test/samples/car_ads.txt +0 -505
data/test/samples/five_lines.txt +0 -5
data/test/samples/five_paragraphs.txt +0 -9
data/test/samples/ross_report.txt +0 -58530
data/test/tc_builder.rb +0 -135
data/test/tc_data_set.rb~ +0 -326
data/test/tc_state.rb +0 -142
data/test/ts_parser.rb +0 -10

data/test/tc_builder.rb DELETED Viewed

@@ -1,135 +0,0 @@
-require "test/unit"
-require "ruport"
-class TestBuilder < Test::Unit::TestCase
-  include Ruport
-  def setup
-    data = DataSet.new
-    data.fields = %w[ col1 col2 col3 ]
-    data.default = ""; data << %w[ a b c ]; data << %w[ d e f ]
-    @builder = Format::Builder.new( data )
-  end
-  def test_register_rendering_method
-    assert_raise(NoMethodError) {
-      @builder.render_sample
-    }
-    Format::Builder.register_rendering_method :sample do
-      "sample"
-    end
-    assert_nothing_raised { @builder.render_sample }
-    assert_equal( "sample", @builder.render_sample )
-    Format::Builder.register_rendering_method :data_snatcher do
-      @data
-    end
-    assert_equal(DataSet.new( %w[ col1 col2 col3 ],
-                              :data => [ %w[ a b c ], %w[ d e f ]]),
-                              @builder.render_data_snatcher)
-  end
-  def test_render_html
-    @builder.format = :html
-    assert_equal("<table>\n  <tr>\n    <th>col1</th><th>col2</th>" +
-                 "<th>col3</th>\n  </tr>\n" +
-                 "  <tr>\n    <td>a</td><td>b</td><td>c</td>\n  </tr>\n" +
-                 "  <tr>\n    <td>d</td><td>e</td><td>f</td>\n  </tr>\n" +
-                 "</table>", @builder.render )
-  end
-  def test_render_text
-    @builder.format = :text
-    assert_equal( "fields: ( col1, col2, col3 )\n" +
-                  "row0: ( a, b, c )\n" +
-                  "row1: ( d, e, f )\n", @builder.render )
-  end
-  def test_render_csv
-    @builder.format = :csv
-    assert_equal("col1,col2,col3\na,b,c\nd,e,f\n", @builder.render)
-  end
-  def test_partial_rendering
-    my_data = DataSet.new
-    my_data.fields = %w[ col1 col2 col3 ]
-    [ %w[ a b c], %w[ d e f ], %w[ g h i ], %w[ j k l ] ].each do |row|
-      my_data << row
-    end
-    my_builder = Format::Builder.new( my_data )
-    my_builder.range = 1..2
-    my_builder.format = :csv
-    assert_equal("col1,col2,col3\nd,e,f\ng,h,i\n", my_builder.render)
-    my_builder.format = :html
-    assert_equal( "<table>\n  <tr>\n    <th>col1</th><th>col2</th>"+
-                  "<th>col3</th>\n  </tr>\n"+
-                  "  <tr>\n    <td>d</td><td>e</td><td>f</td>\n  </tr>\n" +
-                  "  <tr>\n    <td>g</td><td>h</td><td>i</td>\n  </tr>\n" +
-                  "</table>", my_builder.render )
-   my_builder.format = :text
-   assert_equal( "fields: ( col1, col2, col3 )\n" +
-                 "row1: ( d, e, f )\nrow2: ( g, h, i )\n",
-                 my_builder.render )
-  end
-  def test_complete_output
-    @builder.output_type = :complete
-    @builder.format      = :html
-    assert_equal( "<html><head><title></title></head><body>\n"+
-                  "<table>\n  <tr>\n    <th>col1</th><th>col2</th>" +
-                  "<th>col3</th>\n  </tr>\n" +
-                  "  <tr>\n    <td>a</td><td>b</td><td>c</td>\n  </tr>\n" +
-                  "  <tr>\n    <td>d</td><td>e</td><td>f</td>\n  </tr>\n" +
-                  "</table></body></html>\n", @builder.render )
-  end
-  def test_header
-    @builder.header = "This is a sample header"
-    @builder.format = :csv
-    assert_equal( "This is a sample header\n\n" +
-                  "col1,col2,col3\na,b,c\nd,e,f\n", @builder.render )
-    @builder.format = :html
-    assert_equal( "<table>\n  <tr>\n    <th colspan=3>"+
-                  "This is a sample header</th>\n  </tr>\n"+
-                  "  <tr>\n    <th>col1</th><th>col2</th>" +
-                  "<th>col3</th>\n  </tr>\n" +
-                  "  <tr>\n    <td>a</td><td>b</td><td>c</td>\n  </tr>\n" +
-                  "  <tr>\n    <td>d</td><td>e</td><td>f</td>\n  </tr>\n" +
-                  "</table>", @builder.render )
-    @builder.format = :text
-    assert_equal( "This is a sample header\n" +
-                  "fields: ( col1, col2, col3 )\n" +
-                  "row0: ( a, b, c )\n" +
-                  "row1: ( d, e, f )\n", @builder.render )
-  end
-  def test_footer
-    @builder.footer = "This is a sample footer"
-    @builder.format = :csv
-    assert_equal( "col1,col2,col3\na,b,c\nd,e,f\n\n"+
-                  "This is a sample footer\n", @builder.render )
-    @builder.format = :html
-    assert_equal( "<table>\n  <tr>\n    <th>col1</th><th>col2</th>" +
-                  "<th>col3</th>\n  </tr>\n" +
-                  "  <tr>\n    <td>a</td><td>b</td><td>c</td>\n  </tr>\n" +
-                  "  <tr>\n    <td>d</td><td>e</td><td>f</td>\n  </tr>\n" +
-                  "  <tr>\n    <th colspan=3>"+
-                  "This is a sample footer</th>\n  </tr>\n"+
-                  "</table>", @builder.render )
-    @builder.format = :text
-    assert_equal( "fields: ( col1, col2, col3 )\n" +
-                  "row0: ( a, b, c )\n" +
-                  "row1: ( d, e, f )\n" +
-                  "This is a sample footer\n", @builder.render )
-  end
-end

data/test/tc_data_set.rb~ DELETED Viewed

@@ -1,326 +0,0 @@
-#!/usr/local/bin/ruby -w
-require "test/unit"
-require "ruport"
-class TestDataSet < Test::Unit::TestCase
-  include Ruport
-  def setup
-    @data = DataSet.new
-    @data.fields = %w[ col1 col2 col3 ]
-    @data.default = ""
-    @data << %w[ a b c ] << { "col1" => "d", "col3" => "e"}
-  end
-  def test_new
-    fields = %w[ col1 col2 col3 ]
-    my_data = DataSet.new(fields)
-    assert_equal(fields,my_data.fields)
-    my_filled_data = DataSet.new( fields, :content => [[1,2,3],[4,5,6]] )
-    assert_equal( [[1,2,3],[4,5,6]], my_filled_data.map { |r| r.to_a } )
-    hash_filling = [ { "col1" => 9, "col2" => 6, "col3" => 0 },
-                     { "col1" => 54, "col3" => 1 } ]
-    my_filled_data = DataSet.new(fields, :content => hash_filling)
-    assert_equal( [[9,6,0],[54,nil,1]], my_filled_data.map { |r| r.to_a } )
-    cloned_set = @data.clone
-    assert_equal( [ %w[a b c], ["d","","e"] ], cloned_set.map { |r| r.to_a } )
-  end
-  def test_fields
-    assert_equal(%w[ col1 col2 col3 ], @data.fields )
-  end
-  def test_default
-    @data.default = "x"
-    @data << { }
-    assert_equal(  ['x','x','x'],
-                    @data[2].to_a )
-  end
-  def test_delete_if
-    @data.delete_if { |r| r.any? { |e| e.empty? } }
-    assert_equal([%w[a b c]],@data.to_a)
-  end
-  def test_brackets
-    row0 = { "col1" => "a", "col2" => "b", "col3" => "c" }
-    row1 = { "col1" => "d", "col2" => "", "col3" => "e" }
-    row0.each do |key,value|
-      assert_equal( value, @data[0][key] )
-    end
-    row1.each do |key,value|
-      assert_equal( value, @data[1][key] )
-    end
-  end
-  def test_eql?
-    data2 = DataSet.new
-    data2.fields = %w[ col1 col2 col3 ]
-    data2.default = ""
-    data2 << %w[ a b c ]
-    data2 << { "col1" => "d", "col3" => "e" }
-    #FIXME: This looks like some shady discrete math assignment
-    assert(@data.eql?(data2) && data2.eql?(@data))
-    data2 << [2, 3, 4]
-    assert(!( @data.eql?(data2) || data2.eql?(@data) ))
-    @data << [2, 3, 4]
-    assert(@data.eql?(data2) && data2.eql?(@data))
-    @data << [8, 9, 10]
-    assert(!( @data.eql?(data2) || data2.eql?(@data) ))
-    data2 << [8, 9, 10]
-    assert(@data.eql?(data2) && data2.eql?(@data))
-  end
-  def test_shaped_like?
-    a = DataSet.new
-    a.fields = %w[ col1 col2 col3 ]
-    assert(@data.shaped_like?(a))
-    assert(a.shaped_like?(@data))
-  end
-  def test_union
-    a = DataSet.new
-    a.fields = %w[ col1 col2 col3 ]
-    a << %w[ a b c ]
-    a << %w[ x y z ]
-    b = a | @data
-    assert_kind_of(DataSet, b)
-    assert_equal(b.data.length, 3)
-    assert_equal([ %w[a b c], %w[x y z], ["d","","e"] ], b.to_a)
-    assert_equal((a | @data), a.union(@data))
-  end
-  def test_difference
-    a = DataSet.new
-    a.fields = %w[ col1 col2 col3 ]
-    a << %w[ a b c ]
-    a << %w[ x y z ]
-    b = a - @data
-    assert_kind_of(DataSet, b)
-    assert_equal(b.data.length, 1)
-    assert_equal([ %w[x y z] ], b.to_a)
-    assert_equal((a - @data), a.difference(@data))
-  end
-  def test_intersection
-    a = DataSet.new
-    a.fields = %w[ col1 col2 col3 ]
-    a << %w[ a b c ]
-    a << %w[ x y z ]
-    b = a & @data
-    assert_kind_of(DataSet, b)
-    assert_equal(b.data.length, 1)
-    assert_equal([ %w[a b c] ], b.to_a)
-    assert_equal((a & @data), a.intersection(@data))
-  end
-  def test_concatenation
-    a = DataSet.new
-    a.fields = %w[ col1 col2 col3 ]
-    a << %w[ x y z ]
-    newdata = @data.concat(a)
-    assert_equal([ %w[a b c], ["d","","e"], %w[x y z] ], newdata.to_a)
-  end
-  def test_append_datarow
-    row = DataRow.new(%w[ x y z ],%w[ col1 col2 col3 ])
-    @data << row
-    assert_equal(@data[2], row)
-  end
-  def test_append_datarows
-    row = DataRow.new(%w[ x y z ],%w[ col1 col2 col3 ])
-    row2 = DataRow.new(%w[ u v w ], %w[ col1, col2, col3 ])
-    @data << [row, row2]
-    assert_equal(@data[2], row)
-    assert_equal(@data[3], row2)
-  end
-  def test_empty?
-    a = DataSet.new
-    a.fields = %w[a b c]
-    assert_equal(true,a.empty?)
-    assert_equal(false,@data.empty?)
-    a << [1,2,3]
-    assert_equal(false,a.empty?)
-  end
-  def test_length
-    assert_equal(2, @data.length)
-    @data << [1,2,3]
-    assert_equal(3, @data.length)
-  end
-  def test_load
-    loaded_data = DataSet.load("test/samples/data.csv")
-    assert_equal(@data,loaded_data)
-    loaded_data = DataSet.load("test/samples/data.csv") do |set,row|
-      set << row if row.include? 'b'
-    end
-    assert_equal([%w[a b c]],loaded_data.to_a)
-  end
-  def test_to_csv
-    loaded_data = DataSet.load("test/samples/data.csv" )
-    csv = loaded_data.to_csv
-    assert_equal("col1,col2,col3\na,b,c\nd,\"\",e\n",csv)
-  end
-  def test_to_html
-    assert_equal("<table>\n\t\t<tr>\n\t\t\t<th>col1 </th>\n\t\t\t"+
-                 "<th>col2 </th>\n\t\t\t<th>col3</th>\n\t\t</tr>\n"+
-                 "\t\t<tr>\n\t\t\t<td>a</td>\n\t\t\t<td>b</td>\n\t\t\t"+
-                 "<td>c</td>\n\t\t</tr>\n\t\t<tr>\n\t\t\t<td>d</td>\n\t"+
-                 "\t\t<td>e</td>\n\t\t</tr>\n\t</table>", @data.to_html )
-  end
-  def test_select_columns
-    assert_equal( [["a"],["d"]],
-                  @data.select_columns("col1").map { |r| r.to_a } )
-    assert_equal( [["b"],[""]] ,
-                  @data.select_columns("col2").map { |r| r.to_a } )
-    assert_equal( [["c"],["e"]],
-                  @data.select_columns("col3").map { |r| r.to_a } )
-    assert_equal( [["a","b","c"],["d","","e"]],
-                  @data.select_columns("col1","col2","col3").map { |r| r.to_a })
-    assert_equal( [["c","a"],["e","d"]],
-                  @data.select_columns("col3","col1").map { |r| r.to_a } )
-  end
-  def test_select_columns!
-    a = [[1,2],[3,4]].to_ds(%w[a b])
-    a.select_columns!(*%w[b a])
-    assert_equal(%w[b a],a.fields)
-    assert_equal([[2,1],[4,3]],a.to_a)
-    a.select_columns!('a')
-    assert_equal(%w[a], a.fields)
-    assert_equal([[1],[3]],a.to_a)
-    a.select_columns!('a','q')
-    assert_equal(%w[a q], a.fields)
-    assert_equal([[1,nil],[3,nil]],a.to_a)
-    a[0]['q'] =2
-    assert_equal([[1,2],[3,nil]],a.to_a)
-  end
-  def test_as
-    data = DataSet.new
-    data.fields = %w[ col1 col2 col3]
-    data << %w[ a b c]
-    data << %w[ d e f]
-    assert_equal("col1,col2,col3\na,b,c\nd,e,f\n",
-                 data.as(:csv) )
-    assert_equal("<table>\n\t\t<tr>\n\t\t\t<th>col1 </th>"+
-                 "\n\t\t\t<th>col2 </th>\n\t\t\t<th>col3</th>"+
-                 "\n\t\t</tr>\n\t\t<tr>\n\t\t\t<td>a</td>\n\t\t\t"+
-                 "<td>b</td>\n\t\t\t<td>c</td>\n\t\t</tr>\n\t\t<tr>"+
-                 "\n\t\t\t<td>d</td>\n\t\t\t<td>e</td>\n\t\t\t<td>f</td>"+
-                 "\n\t\t</tr>\n\t</table>", data.as(:html) )
-  end
-  def test_sigma
-    data = Ruport::DataSet.new(%w[x], :content => [[3],[5],[8],[2]])
-    sum = data.sigma { |r| r["x"] if (r["x"] % 2).zero? }
-    assert_equal(10, sum)
-    sum = data.sigma { |r| r["x"] }
-    assert_equal(18,sum)
-    #check alias
-    sum = data.sum { |r| r["x"] }
-    assert_equal(18,sum)
-  end
-  def test_remove_columns
-   data = @data.remove_columns("col1","col3")
-   assert_equal(["col2"],data.fields)
-   data.remove_columns!("col2")
-   assert_equal([],data.fields)
-   assert(data.empty?)
-  end
-  def test_bracket_equals
-    expected = DataRow.new(%w[apple banana orange], %w[col1 col2 col3])
-    raw = [ %w[apple banana orange],
-            { "col1" => "apple", "col2" => "banana", "col3" => "orange" },
-            DataRow.new(%w[apple banana orange], %w[col1 col2 col3])
-          ]
-    raw.each do |my_row|
-      @data[1] = my_row
-      assert_instance_of(DataRow, @data[1])
-      assert_equal(expected, @data[1])
-    end
-    assert_raise(ArgumentError) { @data[1] = "apple" }
-  end
-  def test_clone
-    data2 = @data.clone
-    assert( @data.object_id != data2.object_id )
-    assert_equal( @data, data2 )
-    data2 << %w[ f o o ]
-    assert( @data != data2 )
-    assert( data2 != @data )
-  end
-  def test_array_hack
-    assert_nothing_raised {
-      [ { :a => :b, :c => :d }, { :e => :f, :g => :h } ].to_ds(%w[a e])
-    }
-    assert_nothing_raised {
-      [ [1,2,3], [4,5,6], [7,8,9] ].to_ds(%w[a b c])
-    }
-    assert_raise(ArgumentError) {
-     %w[d e f].to_ds(%w[a b c])
-    }
-    assert_raise(ArgumentError) {
-     [:foo,:bar,:dog].to_ds(%w[tree cat animal])
-    }
-    assert_raise(ArgumentError) {
-     [1,2,3].to_ds(%w[foo bar soup])
-    }
-    assert_equal( DataSet.new(%w[a b], :content => [[1,2],[3,4]]),
-                  [[1,2],[3,4]].to_ds(%w[a b]) )
-    assert_equal( DataSet.new(%w[a b], :content => [{ "a" => 1 },{ "b" => 2}]),
-                  [{"a" => 1}, {"b" => 2}].to_ds(%w[a b]) )
-    assert_equal( DataSet.new(%w[a b], :content => [DataRow.new([1,2],%w[a b])]),
-                  [DataRow.new([1,2],%w[a b])].to_ds(%w[a b]) )
-   # FIXME: Decide whether this test should pass or fail.
-   #  assert_equal( DataSet.new(%w[a b], [DataRow.new([1,2],%w[a b])]),
-   #               [DataRow.new([1,2],%w[a q])].to_ds(%w[a b]) )
-  end
-  def test_append_chain
-    data2 = DataSet.new(%w[col1 col2 col3])
-    data2.default=""
-    data2 << %w[ a b c ] << { "col1" => "d", "col3" => "e" }
-    assert_equal @data, data2
-  end
-end