ghaki-report 2011.11.30.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2010 Gerald Kalafut
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README

@@ -0,0 +1,23 @@
+= Ghaki Report - Basic reporting helpers
+
+Ghaki Report is a collection of extensions for basic reporting.
+
+== Download
+
+The latest version of Ghaki Report can be found at
+
+* git@github.com:ghaki/ghaki-report.git
+
+== Installation
+
+The preferred method of installing Ghaki Report is through its GEM file.
+
+  % [sudo] gem install ghaki-report-1.0.0.gem
+
+== License
+
+Ghaki Report is released under the MIT license.
+
+== Support
+
+Contact mailto:gerald@kalafut.org

data/VERSION

@@ -0,0 +1 @@
+2011.11.30.1

data/lib/ghaki/report/base.rb

@@ -0,0 +1,68 @@
+require 'ghaki/logger/mixin'
+require 'ghaki/stats/mixin'
+
+module Ghaki  #:nodoc:
+module Report #:nodoc:
+
+class Base
+  include Ghaki::Logger::Mixin
+  include Ghaki::Stats::Mixin
+
+  ######################################################################
+  class << self
+    attr_accessor :report_name
+  end
+
+  ######################################################################
+  def initialize opts={}
+    self.report_name = opts[:report_name] unless opts[:report_name].nil?
+    @stats = opts[:stats]
+    if not opts[:logger].nil?
+      @logger = opts[:logger]
+    elsif not opts[:log_file_name].nil?
+      @logger = Ghaki::Logger::Base.new( :file_name => opts[:log_file_name] )
+    elsif not opts[:log_file_handle].nil?
+      @logger = Ghaki::Logger::Base.new( :file_handle => opts[:log_file_handle] )
+    end
+  end
+
+  ######################################################################
+  def report_name= title
+    self.class.report_name = title
+  end
+
+  ######################################################################
+  def report_name title=nil
+    if title.nil?
+      self.class.report_name
+    elsif title[0,1] == '.'
+      self.class.report_name + title
+    else
+      title
+    end
+  end
+
+  ######################################################################
+  def minor_report_wrap title=nil, &block
+    logger.minor.wrap( report_name(title) ) do
+      begin
+        block.call
+      ensure
+        stats.flush self.logger
+      end
+    end
+  end
+
+  ######################################################################
+  def major_report_wrap title=nil, &block
+    logger.major.wrap( report_name(title) ) do
+      begin
+        block.call
+      ensure
+        stats.flush self.logger
+      end
+    end
+  end
+
+end
+end end

data/lib/ghaki/report/errors.rb

@@ -0,0 +1,6 @@
+module Ghaki  #:nodoc:
+module Report #:nodoc:
+
+class ReportContentError < RuntimeError; end
+
+end end

data/lib/ghaki/report/mixin/linear_parser.rb

@@ -0,0 +1,135 @@
+require 'ghaki/report/errors'
+
+module Ghaki  #:nodoc:
+module Report #:nodoc:
+module Mixin  #:nodoc:
+
+module LinearParser
+
+  PARSER_UNKNOWN_UNLIMITED = 0
+  PARSER_UNKNOWN_MAX_DEF = PARSER_UNKNOWN_UNLIMITED
+
+  PARSER_WARN_UNLIMITED = 0
+  PARSER_WARN_MAX_DEF = 10
+
+  PARSER_ERROR_UNLIMITED = 0
+  PARSER_ERROR_MAX_DEF = 1
+
+  attr_reader :parser_curr_line, :parser_curr_lcnt
+  attr_accessor :parser_unknown_max,
+    :parser_error_max, :parser_warn_max
+
+  def parser_startup
+    @parser_unknown_max ||= PARSER_UNKNOWN_MAX_DEF
+    @parser_warn_max    ||= PARSER_WARN_MAX_DEF
+    @parser_error_max   ||= PARSER_ERROR_MAX_DEF
+    parser_reset_stats
+    parser_reset_state
+  end
+
+  def parser_reset_state
+    @parser_curr_lcnt = 0
+  end
+
+  def parser_reset_stats
+    stats.clear
+    stats.def_zero 'Input Lines', 'Read'
+    stats.def_zero 'Input Lines', 'Skipped'
+    stats.def_zero 'Input Lines', 'Matched'
+    stats.def_zero 'Input Lines', 'Invalid'
+    stats.def_zero 'Input Lines', 'Unknown'
+  end
+
+  def parser_cleanup
+  end
+
+  def parser_advance line
+    @parser_curr_lcnt += 1
+    @parser_curr_line = line
+    stats.incr 'Input Lines', 'Read'
+  end
+
+  def parser_engine text, &block
+    parser_startup
+    text.each_line do |line|
+      parser_advance line
+      block.call( line )
+    end
+    parser_cleanup
+  end
+
+  #
+  # PARSING STATUS
+  #
+
+  def parser_matched msg=''
+    stats.incr 'Input Lines', 'Matched'
+    stats.incr 'Matched Lines', msg unless msg.empty?
+  end
+
+  def parser_skipped msg='Expected'
+    stats.incr 'Input Lines', 'Skipped'
+    stats.incr 'Skipped Lines', msg
+  end
+
+  def parser_unknown msg='Unknown Input'
+    logger.warn "#{msg} At Line #{@parser_curr_lcnt}"
+    logger.puts @parser_curr_line
+    _parser_unknown_check msg
+  end
+
+  def parser_invalid msg='Invalid Line'
+    stats.incr 'Input Lines', 'Invalid'
+    parser_error msg
+  end
+
+  def parser_error msg='Parser Error'
+    logger.error "#{msg} At Line #{@parser_curr_lcnt}"
+    logger.puts @parser_curr_line
+    _parser_error_check msg
+  end
+
+  def parser_warn msg='Parser Warning'
+    logger.warn "#{msg} At Line #{@parser_curr_lcnt}"
+    logger.puts @parser_curr_line
+    _parser_warn_check msg
+  end
+
+
+  #
+  # PARSER STATE CHECKS
+  #
+
+  def _parser_basic_check msg, max, unl, maj, min, exc
+    stats.incr maj, min
+    return if max == unl
+    raise ReportContentError, msg if max == 1
+    cnt = stats.get( maj, min )
+    if cnt >= max
+      raise ReportContentError, exc + ' Maximum Exceeded: ' + cnt.to_s
+    end
+  end
+
+  def _parser_error_check msg
+    _parser_basic_check( msg,
+                       @parser_error_max, PARSER_ERROR_UNLIMITED,
+                       'Parser State', 'Errors',
+                       'Parser Error' )
+  end
+
+  def _parser_warn_check msg
+    _parser_basic_check( msg,
+                       @parser_warn_max, PARSER_WARN_UNLIMITED,
+                       'Parser State', 'Warnings',
+                       'Parser Warning' )
+  end
+
+  def _parser_unknown_check msg
+    _parser_basic_check( msg,
+                       @parser_unknown_max, PARSER_UNKNOWN_UNLIMITED,
+                       'Input Lines', 'Unknown',
+                       'Unknown Line' )
+  end
+
+end
+end end end

data/lib/ghaki/report/output_file.rb

@@ -0,0 +1,41 @@
+require 'ghaki/core_ext/file/with_temp'
+require 'ghaki/report/base'
+
+module Ghaki  #:nodoc:
+module Report #:nodoc:
+
+class OutputFile < Base
+
+  ######################################################################
+  attr_accessor :output_file
+
+  ######################################################################
+  def initialize opts={} ; super opts
+    self.class.report_name ||= 'WRITING REPORT'
+    @output_file = opts[:output_file]
+  end
+
+  ######################################################################
+  def output_report
+    output_prepare
+    logger.info 'output file: ' + @output_file
+    File.with_opened_temp @output_file do |tmp_file|
+      output_to_format tmp_file
+    end
+    output_finish
+  end
+
+  ######################################################################
+  def output_finish
+  end
+
+  ######################################################################
+  def output_prepare
+  end
+
+  ######################################################################
+  def output_to_format out_file
+  end
+
+end
+end end

data/spec/ghaki/report/base_spec.rb

@@ -0,0 +1,70 @@
+require 'ghaki/report/base'
+
+module Ghaki module Report module BaseTesting
+describe Base do
+
+  before(:all) do
+    @log = stub_everything()
+    @maj = stub_everything()
+    @min = stub_everything()
+  end
+
+  class MyReport < Base
+    self.report_name = 'my_report'
+  end
+
+  context 'eigen class' do
+    subject { MyReport }
+    it { should respond_to :report_name }
+    describe '#report_name' do
+      it 'specifies report name' do
+        MyReport.report_name.should == 'my_report'
+      end
+    end
+  end
+
+  subject do MyReport.new( :logger => @log ) end
+
+  context 'object instance' do
+    it { should respond_to :logger }
+    it { should respond_to :logger= }
+    it { should respond_to :stats }
+  end
+
+  describe '#report_name' do
+    it 'defaults to eigen report name' do
+      subject.report_name == 'my_report'
+    end
+    it 'accepts normal report name' do
+      subject.report_name('quack').should == 'quack'
+    end
+    it 'accepts period leading report nmae' do
+      subject.report_name('.moo').should == 'my_report.moo'
+    end
+  end
+
+  describe '#report_name=' do
+    it 'assigns report name' do
+      subject.report_name = 'zap'
+      subject.report_name.should == 'zap'
+    end
+  end
+
+  describe '#minor_report_wrap' do
+    it 'calls logger minor mode' do
+      @log.expects(:minor).returns(@min).once
+      @min.expects(:wrap).with('my_report').once
+      subject.minor_report_wrap do end
+    end
+  end
+
+  describe '#major_report_wrap' do
+    it 'calls logger major mode' do
+      @log.expects(:major).returns(@maj).once
+      @maj.expects(:wrap).with('my_report').once
+      subject.major_report_wrap do end
+    end
+  end
+
+end
+end end end

data/spec/ghaki/report/mixin/linear_parser_spec.rb

@@ -0,0 +1,289 @@
+require 'ghaki/logger/spec_helper'
+require 'ghaki/stats/spec_helper'
+require 'ghaki/report/base'
+require 'ghaki/report/mixin/linear_parser'
+
+module Ghaki module Report module Mixin module LinearParser_Testing
+describe LinearParser do
+  include Ghaki::Logger::SpecHelper
+  include Ghaki::Stats::SpecHelper
+
+  class MyParser < Base
+    include LinearParser
+  end
+
+  before(:each) do
+    setup_safe_stats
+    setup_safe_logger
+    @parser = MyParser.new({
+      :logger => @logger,
+      :stats  => @stats,
+    })
+  end
+
+  subject do @parser end
+
+  it { should respond_to :parser_curr_line }
+  it { should respond_to :parser_curr_lcnt }
+  it { should respond_to :parser_unknown_max  }
+  it { should respond_to :parser_unknown_max= }
+  it { should respond_to :parser_error_max  }
+  it { should respond_to :parser_error_max= }
+  it { should respond_to :parser_warn_max  }
+  it { should respond_to :parser_warn_max= }
+
+  before(:each) do
+    @stats.clear
+  end
+
+  describe '#parser_startup' do
+    it 'defaults parser unknown max' do
+      subject.parser_unknown_max = nil
+      subject.parser_startup
+      subject.parser_unknown_max.should == LinearParser::PARSER_UNKNOWN_MAX_DEF
+    end
+    it 'defaults parser warning max' do
+      subject.parser_warn_max = nil
+      subject.parser_startup
+      subject.parser_warn_max.should == LinearParser::PARSER_WARN_MAX_DEF
+    end
+    it 'defaults parser error max' do
+      subject.parser_error_max = nil
+      subject.parser_startup
+      subject.parser_error_max.should == LinearParser::PARSER_ERROR_MAX_DEF
+    end
+    it 'zeroes parser stats' do
+      subject.expects(:parser_reset_stats).once
+      subject.parser_startup
+    end
+    it 'resets parser state' do
+      subject.expects(:parser_reset_state).once
+      subject.parser_startup
+    end
+  end
+
+  describe '#parser_cleanup' do
+    it { should respond_to :parser_cleanup }
+  end
+
+  describe '#parser_advance' do
+    before(:each) do
+      subject.parser_startup
+    end
+    it 'increments line count' do
+      subject.parser_advance 'junk'
+      subject.parser_curr_lcnt.should == 1
+    end
+    it 'sets current line' do
+      subject.parser_advance 'junk'
+      subject.parser_curr_line.should  == 'junk'
+    end
+    it 'increments input lines read' do
+      subject.parser_advance 'junk'
+      @stats.get('Input Lines','Read').should == 1
+    end
+  end
+
+  describe '#parser_engine' do
+    it 'calls parser startup' do
+      subject.parser_startup # do actual init
+      subject.expects(:parser_startup).once # test for init
+      subject.parser_engine "\njunk\njunk\n" do
+        # do nothing
+      end
+    end
+    it 'calls parser advance for each line' do
+      subject.expects(:parser_advance).times(3)
+      subject.parser_engine "\njunk\njunk\n" do
+        # do nothing
+      end
+    end
+    it 'yields for each line' do
+      cnt = 0
+      subject.parser_engine "\njunk\njunk\n" do
+        cnt += 1
+      end
+      cnt.should == 3
+    end
+    it 'calls parser cleanup' do
+      subject.expects(:parser_cleanup)
+      subject.parser_engine "\njunk\njunk\n" do
+        # do nothing
+      end
+    end
+  end
+
+  describe '#parser_reset_stats' do
+    it 'clears existing stats' do
+      @stats.expects(:clear).once
+      subject.parser_reset_stats
+    end
+    it 'zeroes input lines read' do
+      @stats.put( 'Input Lines', 'Read', 20 )
+      subject.parser_reset_stats
+      @stats.get('Input Lines','Read').should == 0
+    end
+    it 'zeroes input lines skipped' do
+      @stats.put( 'Input Lines', 'Skipped', 20 )
+      subject.parser_reset_stats
+      @stats.get('Input Lines','Skipped').should == 0
+    end
+    it 'zeroes input lines matched' do
+      @stats.put( 'Input Lines', 'Matched', 20 )
+      subject.parser_reset_stats
+      @stats.get('Input Lines','Matched').should == 0
+    end
+    it 'zeroes input lines invalid' do
+      @stats.put( 'Input Lines', 'Invalid', 20 )
+      subject.parser_reset_stats
+      @stats.get('Input Lines','Invalid').should == 0
+    end
+    it 'zeroes input lines unknown' do
+      @stats.put( 'Input Lines', 'Unknown', 20 )
+      subject.parser_reset_stats
+      @stats.get('Input Lines','Unknown').should == 0
+    end
+  end
+
+  describe '#parser_matched' do
+    it 'increments counters' do
+      subject.parser_matched 'Zap'
+      subject.stats.get('Input Lines','Matched').should == 1
+      subject.stats.get('Matched Lines','Zap').should == 1
+    end
+  end
+
+  describe '#parser_skipped' do
+    it 'increments counters' do
+      subject.parser_skipped 'Whitespace'
+      subject.stats.get('Input Lines','Skipped').should == 1
+      subject.stats.get('Skipped Lines','Whitespace').should == 1
+    end
+  end
+
+  describe '#parser_unknown' do
+    before(:each) do
+      @logger.expects(:warn).once
+      @logger.expects(:puts).once
+    end
+    it 'increments counters' do
+      subject.parser_unknown_max = 10
+      subject.parser_engine 'junk' do
+        subject.parser_unknown
+      end
+      subject.stats.get('Input Lines','Unknown').should == 1
+    end
+    it 'alarms at threshold at one' do
+      subject.parser_unknown_max = 1
+      lambda do
+        subject.parser_engine 'junk' do
+          subject.parser_unknown
+        end
+      end.should raise_error(ReportContentError,%r{Unknown\sInput})
+    end
+    it 'alarms at threshold at many' do
+      subject.parser_unknown_max = 10
+      lambda do
+        subject.parser_engine 'junk' do
+          subject.stats.put('Input Lines','Unknown',10)
+          subject.parser_unknown
+        end
+      end.should raise_error(ReportContentError,%r{Unknown\sLine\sMaximum})
+    end
+  end
+
+  describe '#parser_warn' do
+    before(:each) do
+      @logger.expects(:warn).once
+      @logger.expects(:puts).once
+    end
+    it 'increments counters' do
+      subject.parser_warn_max = 10
+      subject.parser_engine 'junk' do
+        subject.parser_warn
+      end
+      subject.stats.get('Parser State','Warnings').should == 1
+    end
+    it 'alarms at threshold of one' do
+      subject.parser_warn_max = 1
+      lambda do
+        subject.parser_engine 'junk' do
+          subject.parser_warn
+        end
+      end.should raise_error(ReportContentError,%r{Parser\sWarning})
+    end
+    it 'alarms at threshold of many' do
+      subject.parser_warn_max = 10
+      lambda do
+        subject.parser_engine 'junk' do
+          subject.stats.put('Parser State','Warnings',10)
+          subject.parser_warn
+        end
+      end.should raise_error(ReportContentError,%r{Parser\sWarning\sMaximum})
+    end
+  end
+
+  describe '#parser_error' do
+    before(:each) do
+      @logger.expects(:error).once
+      @logger.expects(:puts).once
+    end
+    it 'increments counters' do
+      subject.parser_error_max = 10
+      subject.parser_engine 'junk' do
+        subject.parser_error
+      end
+      subject.stats.get('Parser State','Errors').should == 1
+    end
+    it 'alarms at threshold of one' do
+      subject.parser_error_max = 1
+      lambda do
+        subject.parser_engine 'junk' do
+          subject.parser_error
+        end
+      end.should raise_error(ReportContentError,%r{Parser\sError})
+    end
+    it 'alarms at threshold of many' do
+      subject.parser_error_max = 10
+      lambda do
+        subject.parser_engine 'junk' do
+          subject.stats.put('Parser State','Errors',10)
+          subject.parser_error
+        end
+      end.should raise_error(ReportContentError,%r{Parser\sError\sMaximum})
+    end
+  end
+
+  describe '#parser_invalid' do
+    before(:each) do
+      @logger.expects(:error).once
+      @logger.expects(:puts).once
+    end
+    it 'increments counters' do
+      subject.parser_error_max = 10
+      subject.parser_engine 'junk' do
+        subject.parser_invalid
+      end
+      subject.stats.get('Input Lines','Invalid').should == 1
+    end
+    it 'alarms at threshold of one' do
+      subject.parser_error_max = 1
+      lambda do
+        subject.parser_engine 'junk' do
+          subject.parser_invalid
+        end
+      end.should raise_error(ReportContentError,%r{Invalid\sLine})
+    end
+    it 'alarms at threshold of many' do
+      subject.parser_error_max = 10
+      lambda do
+        subject.parser_engine 'junk' do
+          subject.stats.put('Parser State','Errors',10)
+          subject.parser_invalid
+        end
+      end.should raise_error(ReportContentError,%r{Parser\sError\sMaximum})
+    end
+  end
+
+end
+end end end end

data/spec/ghaki/report/output_file_spec.rb

@@ -0,0 +1,32 @@
+require 'ghaki/report/output_file'
+
+module Ghaki module Report module OutputFileTesting
+describe OutputFile do
+
+  before(:all) do
+    @log = stub_everything()
+    @out = '/tmp/myfile.txt'
+  end
+
+  subject do OutputFile.new( :logger => @log, :output_file => @out ) end
+
+  it { should respond_to :output_file }
+  it { should respond_to :output_file= }
+  it { should respond_to :output_report }
+  it { should respond_to :output_finish }
+  it { should respond_to :output_prepare }
+  it { should respond_to :output_to_format }
+
+  describe '#output_report' do
+    it 'should create file' do
+      abc = sequence('reporting')
+      subject.expects(:output_prepare).once.in_sequence(abc)
+      ::File.expects(:with_opened_temp).with(@out).yields(@out).once.in_sequence(abc)
+      subject.expects(:output_to_format).with(@out).once.in_sequence(abc)
+      subject.expects(:output_finish).once.in_sequence(abc)
+      subject.output_report
+    end
+  end
+
+end
+end end end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'mocha'
+
+RSpec.configure do |cfg|
+  cfg.mock_with :mocha
+  cfg.color_enabled = true
+end

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification
+name: ghaki-report
+version: !ruby/object:Gem::Version
+  version: 2011.11.30.1
+  prerelease: 
+platform: ruby
+authors:
+- Gerald Kalafut
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-30 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ghaki-app
+  requirement: &80031340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2011.11.29.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *80031340
+- !ruby/object:Gem::Dependency
+  name: ghaki-ext-file
+  requirement: &80031120 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2011.11.29.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *80031120
+- !ruby/object:Gem::Dependency
+  name: ghaki-logger
+  requirement: &80030900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2011.11.29.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *80030900
+- !ruby/object:Gem::Dependency
+  name: ghaki-match
+  requirement: &80030680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2011.11.30.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *80030680
+- !ruby/object:Gem::Dependency
+  name: ghaki-stats
+  requirement: &80030460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2011.11.29.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *80030460
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &80030240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.4.0
+  type: :development
+  prerelease: false
+  version_requirements: *80030240
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: &80030010 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.9.12
+  type: :development
+  prerelease: false
+  version_requirements: *80030010
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: &80029780 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.9.4
+  type: :development
+  prerelease: false
+  version_requirements: *80029780
+description: Collection of extensions for basic reporting.
+email: gerald@kalafut.org
+executables: []
+extensions: []
+extra_rdoc_files:
+- README
+files:
+- lib/ghaki/report/mixin/linear_parser.rb
+- lib/ghaki/report/output_file.rb
+- lib/ghaki/report/errors.rb
+- lib/ghaki/report/base.rb
+- README
+- LICENSE
+- VERSION
+- spec/ghaki/report/base_spec.rb
+- spec/ghaki/report/mixin/linear_parser_spec.rb
+- spec/ghaki/report/output_file_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/ghaki
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: ghaki-report
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Basic reporting helpers
+test_files:
+- spec/ghaki/report/base_spec.rb
+- spec/ghaki/report/mixin/linear_parser_spec.rb
+- spec/ghaki/report/output_file_spec.rb
+- spec/spec_helper.rb