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

ruport 0.4.9 → 0.4.11

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