ruby_reportable 0.1.0

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+

data/.rvmrc

@@ -0,0 +1,2 @@
+rvm use 1.9.3@gems
+

data/Gemfile

@@ -0,0 +1,3 @@
+source :rubygems
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,26 @@
+PATH
+  remote: .
+  specs:
+    ruby_reportable (0.0.2)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    rr (1.0.4)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.0)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rr
+  rspec
+  ruby_reportable!

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 John "asceth" Long
+
+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.md

@@ -0,0 +1,47 @@
+Ruby Reportable - reporting in ruby
+===================================
+
+
+## DESCRIPTION
+
+Ruby Reportable is a DSL for writing reports using pure ruby.  It allows you to use
+existing code (ie your Rails application) to grab data and the manipulate it.
+
+If you have loaded it then Ruby Reportable can report on it.
+
+
+## Examples
+
+See examples/ directory
+
+## Usage
+
+Using Ruby Reportable is as easy as ```include RubyReportable``` in a new class.  The include lets Ruby Reportable know this class is a new report and also brings in the DSL.
+
+### Source
+
+Your source is the start of your data.  All available configuration is shown below.
+
+```ruby
+source do
+  #
+  # define how your outputs will see each element of the source data
+  #
+  as :element  # this is the default
+
+  # Whatever you want your starting data to be
+  logic do
+    ObjectSpace.each_object.to_a.group_by(&:class).to_a
+  end
+end
+```
+
+## INSTALLATION
+
+Install as a gem or use as part of your Gemfile
+
+    $ [sudo] gem install ruby_reportable
+
+
+
+

data/Rakefile

@@ -0,0 +1,19 @@
+require "bundler"
+Bundler.setup
+
+require "rspec"
+require "rspec/core/rake_task"
+
+Rspec::Core::RakeTask.new(:spec)
+
+gemspec = eval(File.read(File.join(Dir.pwd, "ruby_reportable.gemspec")))
+
+task :build => "#{gemspec.full_name}.gem"
+
+task :test => :spec
+
+file "#{gemspec.full_name}.gem" => gemspec.files + ["ruby_reportable.gemspec"] do
+  system "gem build ruby_reportable.gemspec"
+  system "gem install ruby_reportable-#{RubyReportable::VERSION}.gem"
+end
+

data/design

@@ -0,0 +1,34 @@
+RubyReportable.define :test do
+  source do
+    as :client_application
+
+    logic do
+      ClientApplication.joins(:assigned_worker, :client)
+    end
+
+    filter(:unless => proc { meta[:current_user].roles.include?(:all) }) do
+      source.where('client_applications.assigned_worker_id' => meta[:current_user].id)
+    end
+  end
+
+  output('CLTC #')         { client_application.client.cltc_number }
+  output('Program')        { client_application.program.to_s }
+  output('Worker')         { client_application.assigned_worker.to_s }
+  output('Level of Care')  { client_application.latest_assessment.care_level.to_s }
+
+
+  filter('Program') do
+    require
+    key :program
+    on :data
+    input(:multiple) { Program.all.map(&:to_s) }
+
+    logic do
+      client_application.program.to_s == input
+    end
+  end
+end
+
+
+
+RubyReportable.reports[:test].run(:meta => {:current_user => nil}, :input => {:program => 'Community Choices'})

data/examples/object_space_report.rb

@@ -0,0 +1,16 @@
+class ObjectSpaceReport
+  include RubyReportable
+
+  name 'Object Space By Class'
+
+  source do
+    as :object
+
+    logic do
+      ObjectSpace.each_object.to_a.group_by(&:class).to_a
+    end
+  end
+
+  output('Class') { object.first.to_s }
+  output('Total') { object.last.size }
+end

data/lib/ruby_reportable.rb

@@ -0,0 +1,19 @@
+unless Kernel.respond_to?(:require_relative)
+  module Kernel
+    def require_relative(path)
+      require File.join(File.dirname(caller[0]), path.to_str)
+    end
+  end
+end
+
+require_relative 'ruby_reportable/base'
+require_relative 'ruby_reportable/filter'
+require_relative 'ruby_reportable/output'
+require_relative 'ruby_reportable/sandbox'
+require_relative 'ruby_reportable/source'
+
+
+require_relative 'ruby_reportable/report'
+
+
+

data/lib/ruby_reportable/base.rb

@@ -0,0 +1,15 @@
+module RubyReportable
+  @@reports = {}
+
+  def self.included(base)
+    base.send :extend, RubyReportable::Report
+    base.clear
+
+    @@reports[base.to_s] = base
+  end
+
+  def self.reports
+    @@reports
+  end
+end
+

data/lib/ruby_reportable/filter.rb

@@ -0,0 +1,47 @@
+module RubyReportable
+  class Filter
+    def initialize(name)
+      @options = {}
+      @options[:key] = name.to_s.downcase.gsub(' ', '_').gsub(/[^a-zA-Z_]+/, '')
+      @options[:name] = name
+      @options[:require] = false
+    end
+
+    def [](key)
+      @options[key]
+    end
+
+    def []=(key, value)
+      @options[key] = value
+    end
+
+    def require
+      self[:require] = true
+    end
+
+    def priority(value)
+      self[:priority] = value
+    end
+
+    def key(key)
+      self[:key] = key
+    end
+
+    def use?(&block)
+      self[:use] = block
+    end
+
+    def input(type, &block)
+      self[:input] = type
+      self[:collection] = block
+    end
+
+    def valid?(&block)
+      self[:valid] = block
+    end
+
+    def logic(&block)
+      self[:logic] = block
+    end
+  end
+end

data/lib/ruby_reportable/output.rb

@@ -0,0 +1,19 @@
+module RubyReportable
+  class Output
+    attr_accessor :name, :logic
+
+    def initialize(name, options, block)
+      @name = name
+      @options = options
+      @logic = block
+    end
+
+    def [](key)
+      @options[key]
+    end
+
+    def []=(key, value)
+      @options[key] = value
+    end
+  end
+end

data/lib/ruby_reportable/report.rb

@@ -0,0 +1,202 @@
+module RubyReportable
+  module Report
+    attr_accessor :data_source, :outputs, :filters
+
+    def clear
+      @outputs = []
+      @filters = {}
+      @data_source = nil
+      @report = self.to_s
+      @category = 'Reports'
+      @meta = {}
+    end
+
+    def meta(key, value = nil, &block)
+      if block_given?
+        @meta[key] = block
+      else
+        if value.nil?
+          @meta[key]
+        else
+          @meta[key] = value
+        end
+      end
+    end
+
+    def report(string = nil)
+      if string.nil?
+        @report
+      else
+        @report = string
+      end
+    end
+
+    def category(string = nil)
+      if string.nil?
+        @category
+      else
+        @category = string
+      end
+    end
+
+    def source(&block)
+      @data_source = RubyReportable::Source.new
+      @data_source.instance_eval(&block)
+    end
+
+    def filter(name, &block)
+      @filters[name] = RubyReportable::Filter.new(name)
+      @filters[name].instance_eval(&block)
+    end
+
+    def finalize(&block)
+      @finalize = block
+    end
+
+    def output(name, options = {}, &block)
+      @outputs << RubyReportable::Output.new(name, options, block)
+    end
+
+
+    #
+    # methods you shouldn't use inside the blocks
+    #
+    def useable_filters(scope)
+      @filters.values.select {|filter| !filter[:input].nil? && (filter[:use].nil? || filter[:use].call(scope))}.sort_by {|filter| filter[:priority].to_i}
+    end
+
+    def _filter(filters, original_sandbox, options)
+      # sort filters by priority then apply to sandbox
+      filters.sort_by do |filter_name, filter|
+        filter[:priority]
+      end.inject(original_sandbox) do |sandbox, (filter_name, filter)|
+
+        # find input for given filter
+        sandbox[:input] = options[:input][filter[:key]] if options[:input].is_a?(Hash)
+
+        if filter[:valid].nil? || sandbox.instance_eval(&filter[:valid])
+          if filter[:logic].nil?
+            sandbox
+          else
+            sandbox.build(:source, filter[:logic])
+          end
+        else
+          sandbox
+        end
+      end
+    end
+
+    def _source(options = {})
+      # build sandbox for getting the data
+      RubyReportable::Sandbox.new(:meta => @meta, :source => @data_source[:logic], :inputs => options[:input] || {}, :input => nil)
+    end
+
+    def _data(sandbox, options = {})
+      _filter(@filters, sandbox, options)
+    end
+
+    def _finalize(sandbox, options = {})
+      if @finalize.nil?
+        sandbox
+      else
+        sandbox[:inputs] = options[:input] || {}
+        sandbox.build(:source, @finalize)
+      end
+    end
+
+    def _output(source_data, options = {})
+      # build sandbox for building outputs
+      sandbox = RubyReportable::Sandbox.new(:meta => @meta, @data_source[:as] => nil)
+
+      source_data.inject({:results => []}) do |rows, element|
+        # fill sandbox with data element
+        sandbox[@data_source[:as]] = element
+
+        # grab outputs
+        rows[:results] << @outputs.inject({}) do |row, output|
+          row[output.name] = sandbox.instance_eval(&output.logic)
+          row
+        end
+
+        rows
+      end
+    end
+
+    def _group(group, data, options = {})
+      unless group.to_s.empty?
+        data[:results].inject({}) do |hash, element|
+          key = element[group]
+          hash[key] ||= []
+          hash[key] << element
+          hash
+        end
+      else
+        data
+      end
+    end
+
+    def _sort(sort, data, options = {})
+      unless sort.to_s.empty?
+        data.inject(Hash.new([])) do |hash, (group, elements)|
+          hash[group] = elements.sort_by {|element| element[sort]}
+          hash
+        end
+      else
+        data
+      end
+    end
+
+    def run(options = {})
+      options = {:input => {}}.merge(options)
+
+      # initial sandbox
+      sandbox = _source(options)
+
+      # apply filters to source
+      filtered_sandbox = _data(sandbox, options)
+
+      # finalize raw data from source
+      source_data = _finalize(filtered_sandbox, options).source
+
+      # {:default => [{outputs => values}]
+      data = _output(source_data, options)
+
+      # transform into {group => [outputs => values]}
+      grouped = _group(options[:group], data, options)
+
+      # sort grouped data
+      _sort(options[:sort], grouped, options)
+    end # end def run
+
+    def valid?(options = {})
+      options = {:input => {}}.merge(options)
+
+      # initial sandbox
+      sandbox = _source(options)
+
+      # add in inputs
+      sandbox[:inputs] = options[:input]
+
+      validity = @filters.map do |filter_name, filter|
+        # find input for given filter
+        sandbox[:input] = options[:input][filter[:key]] if options[:input].is_a?(Hash)
+
+        filter_validity = filter[:valid].nil? || sandbox.instance_eval(&filter[:valid])
+
+        if filter_validity == false
+          # filter failed validity test, if it's a required filter
+          # we return false, otherwise its optional so return true
+          if filter[:require]
+            false
+          else
+            true
+          end
+        else
+          true
+        end
+      end
+
+      !validity.include?(false)
+    end # end def valid?
+  end
+end

data/lib/ruby_reportable/sandbox.rb

@@ -0,0 +1,52 @@
+module RubyReportable
+  class Sandbox
+    def metaclass
+      class << self; self; end
+    end
+
+    def initialize(_methods = {})
+      @values = {}
+
+      _methods.map do |key, value|
+        define(key, value)
+      end
+    end
+
+    def build(base, block)
+      @values[base] = instance_eval(&block)
+      self
+    end
+
+    def [](key)
+      @values[key]
+    end
+
+    def []=(key, value)
+      if value.is_a?(Proc)
+        @values[key] = value.call
+      else
+        @values[key] = value
+      end
+    end
+
+    def define(key, value)
+      if self.class.respond_to?(:define_singleton_method)
+        define_singleton_method(key) do
+          if value.is_a?(Proc)
+            @values[key] ||= value.call
+          else
+            @values[key] ||= value
+          end
+        end
+      else
+        metaclass.send(:define_method, key, Proc.new do
+                         if value.is_a?(Proc)
+                           @values[key] ||= value.call
+                         else
+                           @values[key] ||= value
+                         end
+                       end)
+      end
+    end
+  end
+end

data/lib/ruby_reportable/source.rb

@@ -0,0 +1,23 @@
+module RubyReportable
+  class Source
+    def initialize
+      @options = {:filters => [], :as => :element}
+    end
+
+    def [](key)
+      @options[key]
+    end
+
+    def []=(key, value)
+      @options[key] = value
+    end
+
+    def as(variable_name)
+      self[:as] = variable_name
+    end
+
+    def logic(&block)
+      self[:logic] = block
+    end
+  end
+end

data/lib/ruby_reportable/version.rb

@@ -0,0 +1,3 @@
+module RubyReportable
+  VERSION = "0.1.0"
+end

data/ruby_reportable.gemspec

@@ -0,0 +1,24 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "ruby_reportable/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ruby_reportable"
+  s.version     = RubyReportable::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["John 'asceth' Long"]
+  s.email       = ["machinist@asceth.com"]
+  s.homepage    = "http://github.com/asceth/ruby_reportable"
+  s.summary     = "Ruby Reporting"
+  s.description = "Allows you to write reports that use existing ruby classes/methods to present/filter the data"
+
+  s.rubyforge_project = "ruby_reportable"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rr'
+end
+

data/spec/base_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe RubyReportable do
+
+end
+

data/spec/filter_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+
+describe RubyReportable::Filter do
+
+  context "a filter" do
+    before do
+      @filter = RubyReportable::Filter.new('G Methods')
+    end
+
+    it "should store variables internally" do
+      @filter[:logic].should == nil
+
+      @filter.key(:g)
+      @filter.logic do
+        element.include?('g')
+      end
+
+      @filter[:key].should == :g
+      @filter[:logic].should_not == nil
+    end
+
+    context "#require" do
+      it "should automatically assume it is required when no block is given" do
+        @filter.require
+
+        @filter[:require].should == true
+      end
+    end
+  end
+end

data/spec/report_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+
+class FooReport; include RubyReportable; end
+
+describe RubyReportable::Report do
+
+  before do
+    @report = FooReport
+    @report.clear
+  end
+
+  context "#_source" do
+    before do
+      @report.source do
+        logic do
+          Object.methods
+        end
+      end
+    end
+
+    it "should contruct a sandbox to build up source data" do
+      sandbox = @report._source
+
+      sandbox.source.should == Object.methods
+    end
+  end
+
+  context "#_data" do
+    before do
+      @report.source do
+        logic do
+          Object.methods
+        end
+      end
+    end
+
+    it "should be able to filter on source data" do
+      @report.filter('G Methods') do
+        logic do
+          source.select {|element| element.to_s.include?('g')}
+        end
+      end
+
+      @report._data(@report._source).source.should == Object.methods.select {|method| method.to_s.include?('g')}
+    end
+
+    it "should use available input when filtering data" do
+      @report.filter('Filter Methods') do
+        key :letter
+
+        logic do
+          source.select {|element| element.to_s.include?(input)}
+        end
+      end
+
+      source_sandbox = @report._source
+      options = {:input => {:letter => 'g'}}
+      @report._data(source_sandbox, options).source.should == Object.methods.select {|method| method.to_s.include?('g')}
+
+      source_sandbox = @report._source
+      options = {:input => {:letter => 'r'}}
+      @report._data(source_sandbox, options).source.should == Object.methods.select {|method| method.to_s.include?('r')}
+    end
+
+    it "should handle multiple filters" do
+      @report.filter('G Methods') do
+        priority 0
+
+        logic do
+          source.select {|element| element.to_s.include?('g')}
+        end
+      end
+
+      @report.filter('R Methods') do
+        priority 1
+
+        logic do
+          source.select {|element| element.to_s.include?('r')}
+        end
+      end
+
+      source_sandbox = @report._source
+
+      @report._data(source_sandbox).source.should == Object.methods.select {|method| method.to_s.include?('g') && method.to_s.include?('r')}
+    end
+
+    it "should handle multiple filters in the right priority" do
+      @report.source do
+        logic do
+          Object.methods
+        end
+      end
+
+      @report.filter('G Methods') do
+        priority 0
+
+        logic do
+          source.map(&:to_s).select {|element| element.include?('g')}
+        end
+      end
+
+      @report.filter('R Methods') do
+        priority 1
+
+        logic do
+          source.select {|element| element.include?('r')}.map(&:to_sym)
+        end
+      end
+
+      source_sandbox = @report._source
+
+      # G Methods has to run first because otherwise Object.methods
+      # returns symbols and R Methods is trying to do a include? on a symbol
+      @report._data(source_sandbox).source.should == Object.methods.select {|method| method.to_s.include?('g') && method.to_s.include?('r')}
+    end
+  end
+
+  context "#_group" do
+    it "should group results" do
+      @report.source do
+        logic do
+          [:method]
+        end
+      end
+
+      @report.output('name') do
+        element
+      end
+
+      @report.output('letter') do
+        element.to_s[0]
+      end
+
+      source_data = @report._data(@report._source).source
+
+      @report._group('letter', @report._output(source_data)).should == {"m" => [{'name' => :method, 'letter' => 'm'}]}
+    end
+  end
+
+  context "#_sort" do
+    it "should sort results" do
+      @report.source do
+        logic do
+          Object.methods
+        end
+      end
+
+      @report.output('name') do
+        element
+      end
+
+      source_data = @report._data(@report._source).source
+      final = @report._sort('name', @report._output(source_data))
+
+      final.should == {:results => Object.methods.sort.map {|method| {'name' => method}}}
+    end
+  end
+end

data/spec/sandbox_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe RubyReportable::Sandbox do
+
+  context "a sandbox" do
+    before do
+      @sandbox = RubyReportable::Sandbox.new(:source => [1, 2])
+    end
+
+    it "should create new methods based on options" do
+      RubyReportable::Sandbox.new.respond_to?(:source).should == false
+      @sandbox.respond_to?(:source).should == true
+    end
+
+    it "should store the value of a defined call" do
+      @sandbox.source.should == [1, 2]
+      @sandbox[:source].should == [1, 2]
+    end
+
+    it "should not call a method when trying to retrieve the stored value directly" do
+      @sandbox[:source].should == nil
+    end
+
+    it "should be able to define a new method with value dynamically" do
+      @sandbox.define(:arbitrary, proc { Time.now })
+      @sandbox.respond_to?(:arbitrary).should == true
+    end
+
+    it "should not override a stored value with a method call" do
+      @sandbox[:source] = [3, 4]
+      @sandbox.source.should == [3, 4]
+    end
+
+    it "should allow you to build up a stored value" do
+      @sandbox[:source] = [1, 2, 3, 4, 5, 6, 7, 8, 9]
+      @sandbox.build(:source, proc { source.select(&:odd?) })
+
+      @sandbox[:source].should == [1, 3, 5, 7, 9]
+    end
+  end
+end

data/spec/source_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe RubyReportable::Source do
+
+  context "a source" do
+    before do
+      @source = RubyReportable::Source.new
+    end
+
+    it "should store as and logic variables" do
+      @source.as(:element)
+      @source.logic do
+        Object.methods.sort
+      end
+
+      @source[:as].should == :element
+      @source[:logic].call.should == Object.methods.sort
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'bundler'
+Bundler.setup
+
+require 'rspec'
+require 'ruby_reportable'
+
+RSpec.configure do |config|
+  config.mock_with :rr
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: ruby_reportable
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- John 'asceth' Long
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Allows you to write reports that use existing ruby classes/methods to
+  present/filter the data
+email:
+- machinist@asceth.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gemtest
+- .rspec
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- design
+- examples/object_space_report.rb
+- lib/ruby_reportable.rb
+- lib/ruby_reportable/base.rb
+- lib/ruby_reportable/filter.rb
+- lib/ruby_reportable/output.rb
+- lib/ruby_reportable/report.rb
+- lib/ruby_reportable/sandbox.rb
+- lib/ruby_reportable/source.rb
+- lib/ruby_reportable/version.rb
+- ruby_reportable.gemspec
+- spec/base_spec.rb
+- spec/filter_spec.rb
+- spec/report_spec.rb
+- spec/sandbox_spec.rb
+- spec/source_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/asceth/ruby_reportable
+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: '0'
+requirements: []
+rubyforge_project: ruby_reportable
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Ruby Reporting
+test_files:
+- spec/base_spec.rb
+- spec/filter_spec.rb
+- spec/report_spec.rb
+- spec/sandbox_spec.rb
+- spec/source_spec.rb
+- spec/spec_helper.rb