spout 0.8.0.beta1 → 0.8.0.beta2

data/lib/spout/commands/images.rb

@@ -0,0 +1,276 @@
+require 'csv'
+require 'fileutils'
+require 'rubygems'
+require 'json'
+require 'yaml'
+
+require 'spout/helpers/subject_loader'
+require 'spout/helpers/chart_types'
+
+module Spout
+  module Commands
+    class Images
+
+      def initialize(types, variable_ids, sizes, standard_version)
+        @variable_files = Dir.glob('variables/**/*.json')
+        @standard_version = standard_version
+
+        @valid_ids = variable_ids
+
+        @number_of_rows = nil
+
+        spout_config = YAML.load_file('.spout.yml')
+
+        @visit = ''
+
+        if spout_config.kind_of?(Hash)
+          @visit = spout_config['visit'].to_s.strip
+        end
+
+        t = Time.now
+        FileUtils.mkpath "graphs/#{@standard_version}"
+
+        @subject_loader = Spout::Helpers::SubjectLoader.new(@variable_files, @valid_ids, @standard_version, @number_of_rows, @visit)
+
+        @subject_loader.load_subjects_from_csvs!
+        @subjects = @subject_loader.subjects
+
+        compute_images
+        puts "Took #{Time.now - t} seconds."
+      end
+
+      def compute_images
+
+        options_folder = "images/#{@standard_version}"
+        FileUtils.mkpath( options_folder )
+        tmp_options_file = File.join( options_folder, 'options.json' )
+
+        sizes = []
+
+        variable_files_count = @variable_files.count
+        @variable_files.each_with_index do |variable_file, file_index|
+          json = JSON.parse(File.read(variable_file)) rescue json = nil
+          next unless json
+          next unless @valid_ids.include?(json["id"].to_s.downcase) or @valid_ids.size == 0
+          next unless ["numeric", "integer", "choices"].include?(json["type"])
+          variable_name  = json['id'].to_s.downcase
+          next unless Spout::Models::Subject.method_defined?(variable_name)
+
+          puts "#{file_index+1} of #{variable_files_count}: #{variable_file.gsub(/(^variables\/|\.json$)/, '').gsub('/', ' / ')}"
+
+          filtered_subjects = @subjects.select{ |s| s.send(@visit) != nil }
+
+          File.open(tmp_options_file, "w") do |outfile|
+            chart_json = Spout::Helpers::ChartTypes::chart_histogram(@visit, filtered_subjects, json, variable_name)
+            outfile.puts <<-eos
+              {
+                "credits": {
+                  "enabled": false
+                },
+                "chart": {
+                  "type": "column"
+                },
+                "title": {
+                  "text": ""
+                },
+                "xAxis": {
+                  "categories": #{chart_json[:categories].to_json}
+                },
+                "yAxis": {
+                  "title": {
+                    "text": #{chart_json[:units].to_json}
+                  }
+                },
+                "plotOptions": {
+                  "column": {
+                    "pointPadding": 0.2,
+                    "borderWidth": 0,
+                    "stacking": #{chart_json[:stacking].to_json}
+                  }
+                },
+                "series": #{chart_json[:series].to_json}
+              }
+            eos
+          end
+
+
+          run_phantom_js("#{json['id']}-lg.png", 600, tmp_options_file) if sizes.size == 0 or sizes.include?('lg')
+          run_phantom_js("#{json['id']}.png",     75, tmp_options_file) if sizes.size == 0 or sizes.include?('sm')
+        end
+        File.delete(tmp_options_file) if File.exists?(tmp_options_file)
+      end
+
+
+      # def initialize(types, variable_ids, sizes, standard_version)
+      #   @standard_version = standard_version
+      #   total_index_count = Dir.glob("variables/**/*.json").count
+
+      #   last_completed = 0
+
+      #   options_folder = "images/#{@standard_version}"
+      #   FileUtils.mkpath( options_folder )
+      #   tmp_options_file = File.join( options_folder, 'options.json' )
+
+      #   Dir.glob("csvs/#{standard_version}/*.csv").each do |csv_file|
+      #     puts "Working on: #{csv_file}"
+      #     t = Time.now
+      #     csv_table = CSV.table(csv_file, encoding: 'iso-8859-1').by_col!
+      #     puts "Loaded #{csv_file} in #{Time.now - t} seconds."
+
+      #     total_header_count = csv_table.headers.count
+      #     csv_table.headers.each_with_index do |header, index|
+      #       puts "Column #{ index + 1 } of #{ total_header_count } for #{header} in #{csv_file}"
+      #       if variable_file = Dir.glob("variables/**/#{header.downcase}.json", File::FNM_CASEFOLD).first
+      #         json = JSON.parse(File.read(variable_file)) rescue json = nil
+      #         next unless json
+      #         next unless ["choices", "numeric", "integer"].include?(json["type"])
+      #         next unless types.size == 0 or types.include?(json['type'])
+      #         next unless variable_ids.size == 0 or variable_ids.include?(json['id'].to_s.downcase)
+
+      #         basename = File.basename(variable_file).gsub(/\.json$/, '').downcase
+      #         col_data = csv_table[header]
+
+      #         case json["type"] when "choices"
+      #           domain_file = Dir.glob("domains/**/#{json['domain']}.json").first
+      #           domain_json = JSON.parse(File.read(domain_file)) rescue domain_json = nil
+      #           next unless domain_json
+
+      #           create_pie_chart_options_file(col_data, tmp_options_file, domain_json)
+      #         when 'numeric', 'integer'
+      #           create_line_chart_options_file(col_data, tmp_options_file, json["units"])
+      #         else
+      #           next
+      #         end
+
+      #         run_phantom_js("#{basename}-lg.png", 600, tmp_options_file) if sizes.size == 0 or sizes.include?('lg')
+      #         run_phantom_js("#{basename}.png",     75, tmp_options_file) if sizes.size == 0 or sizes.include?('sm')
+      #       end
+      #     end
+      #   end
+      #   File.delete(tmp_options_file) if File.exists?(tmp_options_file)
+      # end
+
+      # def graph_values(col_data)
+      #   categories = []
+
+      #   col_data = col_data.select{|v| !['', 'null'].include?(v.to_s.strip.downcase)}.collect(&:to_f)
+
+      #   all_integers = false
+      #   all_integers = (col_data.count{|i| i.denominator != 1} == 0)
+
+      #   minimum = col_data.min || 0
+      #   maximum = col_data.max || 100
+
+      #   default_max_buckets = 30
+      #   max_buckets = all_integers ? [maximum - minimum + 1, default_max_buckets].min : default_max_buckets
+      #   bucket_size = (maximum - minimum + 1).to_f / max_buckets
+
+      #   (0..(max_buckets-1)).each do |bucket|
+      #     val_min = (bucket_size * bucket) + minimum
+      #     val_max = bucket_size * (bucket + 1) + minimum
+      #     # Greater or equal to val_min, less than val_max
+      #     # categories << "'#{val_min} to #{val_max}'"
+      #     categories << "#{all_integers || (maximum - minimum) > (default_max_buckets / 2)  ? val_min.round : "%0.02f" % val_min}"
+      #   end
+
+      #   new_values = []
+      #   (0..max_buckets-1).each do |bucket|
+      #     val_min = (bucket_size * bucket) + minimum
+      #     val_max = bucket_size * (bucket + 1) + minimum
+      #     # Greater or equal to val_min, less than val_max
+      #     new_values << col_data.count{|i| i >= val_min and i < val_max}
+      #   end
+
+      #   values = []
+
+      #   values << { name: '', data: new_values, showInLegend: false }
+
+      #   [ values, categories ]
+      # end
+
+
+      # def create_pie_chart_options_file(values, options_file, domain_json)
+
+      #   values.select!{|v| !['', 'null'].include?(v.to_s.strip.downcase) }
+      #   counts = values.group_by{|a| a}.collect{|k,v| [(domain_json.select{|h| h['value'] == k.to_s}.first['display_name'] rescue (k.to_s == '' ? 'NULL' : k)), v.count]}
+
+      #   total_count = counts.collect(&:last).inject(&:+)
+
+      #   data = counts.collect{|value, count| [value, (count * 100.0 / total_count)]}
+
+      #   File.open(options_file, "w") do |outfile|
+      #     outfile.puts <<-eos
+      #       {
+      #         "title": {
+      #           "text": ""
+      #         },
+
+      #         "credits": {
+      #             "enabled": false,
+      #         },
+      #         "series": [{
+      #                   "type": "pie",
+      #                   "name": "",
+      #                   "data": #{data.to_json}
+      #         }]
+      #       }
+      #     eos
+      #   end
+      # end
+
+
+      # def create_line_chart_options_file(values, options_file, units)
+      #   ( series, categories ) = graph_values(values)
+
+      #   File.open(options_file, "w") do |outfile|
+      #     outfile.puts <<-eos
+      #       {
+      #         "chart": {
+      #             "type": "areaspline"
+      #         },
+      #         "title": {
+      #           "text": ""
+      #         },
+      #         "credits": {
+      #             "enabled": false,
+      #         },
+      #         "xAxis": {
+      #             "categories": #{categories.to_json},
+      #             "labels": {
+      #                 "step": #{(categories.size.to_f / 12).ceil}
+      #             },
+      #             "title": {
+      #                 "text": #{units.to_json}
+      #             }
+      #         },
+      #         "yAxis": {
+      #             "maxPadding": 0,
+      #             "minPadding": 0,
+      #             "title": {
+      #               "text": "Count"
+      #             }
+      #         },
+      #         "series": #{series.to_json}
+      #       }
+      #     eos
+      #   end
+      # end
+
+      def run_phantom_js(png_name, width, tmp_options_file)
+        graph_path = File.join(Dir.pwd, 'images', @standard_version, png_name)
+        directory = File.join( File.dirname(__FILE__), '..', 'support', 'javascripts' )
+
+        open_command = if RUBY_PLATFORM.match(/mingw/) != nil
+          'phantomjs.exe'
+        else
+          'phantomjs'
+        end
+
+        phantomjs_command = "#{open_command} #{directory}/highcharts-convert.js -infile #{tmp_options_file} -outfile #{graph_path} -scale 2.5 -width #{width} -constr Chart"
+        # puts phantomjs_command
+        `#{phantomjs_command}`
+      end
+
+    end
+  end
+end

data/lib/spout/helpers/chart_types.rb

@@ -1,3 +1,4 @@
+require 'spout/helpers/array_statistics'
 require 'spout/helpers/table_formatting'
 
 module Spout
@@ -40,6 +41,16 @@ module Spout
         get_json(json['domain'], 'domain')
       end
 
+      def self.domain_array(variable_name)
+        variable_file = Dir.glob("variables/**/#{variable_name}.json").first
+        json = JSON.parse(File.read(variable_file)) rescue json = nil
+        if json
+          domain_json = get_domain(json)
+          domain_json ? domain_json.collect{|option_hash| [option_hash['display_name'], option_hash['value']]} : []
+        else
+          []
+        end
+      end
 
       def self.chart_arbitrary_choices_by_quartile(chart_type, subjects, json, method)
         # CHART TYPE IS THE QUARTILE VARIABLE
@@ -188,7 +199,7 @@ module Spout
 
       def self.chart_arbitrary_choices(chart_type, subjects, json, method)
         return unless chart_variable_json = get_variable(chart_type)
-        return unless chart_variable_domain = Spout::Commands::JsonChartsAndTables::domain_array(chart_type)
+        return unless chart_variable_domain = domain_array(chart_type)
         return unless domain_json = get_domain(json)
 
 
@@ -213,7 +224,7 @@ module Spout
 
       def self.chart_arbitrary(chart_type, subjects, json, method, visits)
         return unless chart_variable_json = get_variable(chart_type)
-        return unless chart_variable_domain = Spout::Commands::JsonChartsAndTables::domain_array(chart_type)
+        return unless chart_variable_domain = domain_array(chart_type)
         return chart_arbitrary_by_quartile(chart_type, subjects, json, method, visits) if ['numeric', 'integer'].include?(chart_variable_json['type'])
 
         return chart_arbitrary_choices(chart_type, subjects, json, method) if json['type'] == 'choices'
@@ -248,7 +259,7 @@ module Spout
 
       def self.table_arbitrary(chart_type, subjects, json, method, subtitle = nil)
         return unless chart_variable_json = get_variable(chart_type)
-        return unless chart_variable_domain = Spout::Commands::JsonChartsAndTables::domain_array(chart_type)
+        return unless chart_variable_domain = domain_array(chart_type)
         return table_arbitrary_by_quartile(chart_type, subjects, json, method, subtitle) if ['numeric', 'integer'].include?(chart_variable_json['type'])
         return table_arbitrary_choices(chart_type, subjects, json, method, subtitle) if json['type'] == 'choices'
 
@@ -284,7 +295,7 @@ module Spout
 
       def self.table_arbitrary_choices(chart_type, subjects, json, method, subtitle)
         return unless chart_variable_json = get_variable(chart_type)
-        return unless chart_variable_domain = Spout::Commands::JsonChartsAndTables::domain_array(chart_type)
+        return unless chart_variable_domain = domain_array(chart_type)
         return unless domain_json = get_domain(json)
 
         headers = [
@@ -330,7 +341,7 @@ module Spout
       def self.chart_histogram_choices(chart_type, subjects, json, method)
         return unless domain_json = get_domain(json)
         return unless chart_variable_json = get_variable(chart_type)
-        return unless chart_variable_domain = Spout::Commands::JsonChartsAndTables::domain_array(chart_type)
+        return unless chart_variable_domain = domain_array(chart_type)
 
 
         title = "#{json['display_name']}"
@@ -360,7 +371,7 @@ module Spout
       def self.chart_histogram(chart_type, subjects, json, method)
         return chart_histogram_choices(chart_type, subjects, json, method) if json['type'] == 'choices'
         return unless chart_variable_json = get_variable(chart_type)
-        return unless chart_variable_domain = Spout::Commands::JsonChartsAndTables::domain_array(chart_type)
+        return unless chart_variable_domain = domain_array(chart_type)
 
         title = "#{json['display_name']}"
         subtitle = "By Visit"

data/lib/spout/helpers/subject_loader.rb

@@ -0,0 +1,71 @@
+require 'spout/models/subject'
+
+
+module Spout
+  module Helpers
+    class SubjectLoader
+      attr_accessor :subjects
+
+      def initialize(variable_files, valid_ids, standard_version, number_of_rows, visit)
+        @subjects = []
+        @variable_files = variable_files
+        @valid_ids = valid_ids
+        @standard_version = standard_version
+        @number_of_rows = number_of_rows
+        @visit = visit
+      end
+
+      def load_subjects_from_csvs!
+        load_subjects_from_csvs_part_one!
+        load_subjects_from_csvs_part_two!
+      end
+
+      def load_subjects_from_csvs_part_one!
+        @subjects = []
+
+        csv_files = Dir.glob("csvs/#{@standard_version}/*.csv")
+        csv_files.each_with_index do |csv_file, index|
+          count = 0
+          puts "Parsing: #{csv_file}"
+          CSV.parse( File.open(csv_file, 'r:iso-8859-1:utf-8'){|f| f.read}, headers: true, header_converters: lambda { |h| h.to_s.downcase } ) do |line|
+
+            row = line.to_hash
+            count += 1
+            puts "Line: #{count}" if (count % 1000 == 0)
+            @subjects << Spout::Models::Subject.create do |t|
+              t._visit = row[@visit]
+
+              row.each do |key,value|
+                unless t.respond_to?(key)
+                  t.class.send(:define_method, "#{key}") { instance_variable_get("@#{key}") }
+                  t.class.send(:define_method, "#{key}=") { |value| instance_variable_set("@#{key}", value) }
+                end
+
+                unless value == nil
+                  t.send("#{key}=", value)
+                end
+              end
+            end
+            # puts "Memory Used: " + (`ps -o rss -p #{$$}`.strip.split.last.to_i / 1024).to_s + " MB" if count % 1000 == 0
+            # break if count >= 1000
+            break if @number_of_rows != nil and count >= @number_of_rows
+          end
+        end
+      end
+
+      def load_subjects_from_csvs_part_two!
+        @variable_files.each do |variable_file|
+          json = JSON.parse(File.read(variable_file)) rescue json = nil
+          next unless json
+          next unless @valid_ids.include?(json["id"].to_s.downcase) or @valid_ids.size == 0
+          next unless ["numeric", "integer"].include?(json["type"])
+          method  = json['id'].to_s.downcase
+          next unless Spout::Models::Subject.method_defined?(method)
+
+          @subjects.each{ |s| s.send(method) != nil ? s.send("#{method}=", s.send("#{method}").to_f) : nil }
+        end
+        @subjects
+      end
+    end
+  end
+end

data/lib/spout/models/coverage_result.rb

@@ -0,0 +1,65 @@
+require 'spout/tests/variable_type_validation'
+
+module Spout
+  module Models
+    class CoverageResult
+      attr_accessor :error, :error_message, :file_name_test, :json_id_test, :values_test, :valid_values, :csv_values, :variable_type_test, :json, :domain_test
+
+      def initialize(csv, column, csv_values)
+        load_json(column)
+        load_valid_values
+
+        @csv_values = csv_values
+        @values_test = check_values
+        @variable_type_test = check_variable_type
+        @domain_test = check_domain_specified
+      end
+
+      def load_json(column)
+        file = Dir.glob("variables/**/#{column}.json").first
+        @file_name_test = (file != nil)
+        @json = JSON.parse(File.read(file)) rescue @json = {}
+        @json_id_test = (@json['id'].to_s.downcase == column)
+      end
+
+      def load_valid_values
+        valid_values = []
+        if @json['type'] == 'choices'
+          file = Dir.glob("domains/**/#{@json['domain']}.json").first
+          if json = JSON.parse(File.read(file)) rescue false
+            valid_values = json.collect{|hash| hash['value']}
+          end
+        end
+        @valid_values = valid_values
+      end
+
+      def number_of_errors
+        @file_name_test && @json_id_test && @values_test && @variable_type_test && @domain_test ? 0 : 1
+      end
+
+      def check_values
+        @json['type'] != 'choices' || (@valid_values | @csv_values.compact).size == @valid_values.size
+      end
+
+      def check_variable_type
+        Spout::Tests::VariableTypeValidation::VALID_VARIABLE_TYPES.include?(@json['type'])
+      end
+
+      def check_domain_specified
+        if @json['type'] != 'choices'
+          true
+        else
+          domain_file = Dir.glob("domains/**/#{@json['domain']}.json").first
+          if domain_json = JSON.parse(File.read(domain_file)) rescue false
+            return domain_json.kind_of?(Array)
+          end
+          false
+        end
+      end
+
+      def errored?
+        error == true
+      end
+    end
+  end
+end

data/lib/spout/tasks/engine.rake

@@ -46,160 +46,28 @@ namespace :spout do
 
   desc 'Match CSV dataset with JSON repository'
   task :coverage do
-    require 'spout/tests/variable_type_validation'
-
-    choice_variables = []
-
-    Dir.glob("variables/**/*.json").each do |file|
-      if json = JSON.parse(File.read(file)) rescue false
-        choice_variables << json['id'] if json['type'] == 'choices'
-      end
-    end
-
-    all_column_headers = []
-    value_hash = {}
-    csv_names = []
-
-    Dir.glob("csvs/*.csv").each do |csv_file|
-      csv_name = csv_file.split('/').last.to_s
-      csv_names << csv_name
-      puts "\nParsing: #{csv_name}"
-
-      column_headers = []
-      row_count = 0
-
-      CSV.parse( File.open(csv_file, 'r:iso-8859-1:utf-8'){|f| f.read}, headers: true ) do |line|
-        row = line.to_hash
-        column_headers = row.collect{|key, val| [csv_name, key.to_s.downcase]} if row_count == 0
-
-        print "." if row_count % 100 == 0
-
-        choice_variables.each do |column_name|
-          value_hash[column_name] ||= []
-          value_hash[column_name] = value_hash[column_name] | [row[column_name]] if row[column_name]
-        end
-
-        row_count += 1
-      end
-
-      print "done\n"
-
-      all_column_headers += column_headers
-    end
-
-    @matching_results = []
-
-    all_column_headers.each do |csv, column|
-      scr = SpoutCoverageResult.new(csv, column, value_hash[column])
-      @matching_results << [ csv, column, scr ]
-    end
-
-    @matching_results.sort!{|a,b| [b[2].number_of_errors, a[0].to_s, a[1].to_s] <=> [a[2].number_of_errors, b[0].to_s, b[1].to_s]}
-
-    @coverage_results = []
-
-    csv_names.each do |csv_name|
-      total_column_count = @matching_results.select{|mr| mr[0] == csv_name}.count
-      mapped_column_count = @matching_results.select{|mr| mr[0] == csv_name and mr[2].number_of_errors == 0}.count
-      @coverage_results << [ csv_name, total_column_count, mapped_column_count ]
-    end
-
-    coverage_folder = File.join(Dir.pwd, 'coverage')
-    FileUtils.mkpath coverage_folder
-    coverage_file = File.join(coverage_folder, 'index.html')
-
-    print "\nGenerating: index.html\n\n"
-
-    File.open(coverage_file, 'w+') do |file|
-      erb_location = File.join( File.dirname(__FILE__), '../views/index.html.erb' )
-      file.puts ERB.new(File.read(erb_location)).result(binding)
-    end
-
-    open_command = 'open'  if RUBY_PLATFORM.match(/darwin/) != nil
-    open_command = 'start' if RUBY_PLATFORM.match(/mingw/) != nil
-
-    system "#{open_command} #{coverage_file}" if ['start', 'open'].include?(open_command)
-    puts "#{coverage_file}\n\n"
+    require 'spout/commands/coverage'
+    Spout::Commands::Coverage.new(standard_version)
   end
 
   desc 'Match CSV dataset with JSON repository'
-  task :graphs do
-    require 'spout/commands/graphs'
+  task :images do
+    require 'spout/commands/images'
     types         = ENV['types'].to_s.split(',').collect{|t| t.to_s.downcase}
     variable_ids  = ENV['variable_ids'].to_s.split(',').collect{|vid| vid.to_s.downcase}
     sizes         = ENV['sizes'].to_s.split(',').collect{|s| s.to_s.downcase}
-    Spout::Commands::Graphs.new(types, variable_ids, sizes)
+    Spout::Commands::Images.new(types, variable_ids, sizes, standard_version)
   end
 
   desc 'Generate JSON charts and tables'
   task :json do
-    require 'spout/commands/json_charts_and_tables'
+    require 'spout/commands/graphs'
     variables = ENV['variables'].to_s.split(',').collect{|s| s.to_s.downcase}
-    Spout::Commands::JsonChartsAndTables.new(variables)
+    Spout::Commands::Graphs.new(variables, standard_version)
   end
 
 end
 
-class SpoutCoverageResult
-  attr_accessor :error, :error_message, :file_name_test, :json_id_test, :values_test, :valid_values, :csv_values, :variable_type_test, :json, :domain_test
-
-  def initialize(csv, column, csv_values)
-    load_json(column)
-    load_valid_values
-
-    @csv_values = csv_values
-    @values_test = check_values
-    @variable_type_test = check_variable_type
-    @domain_test = check_domain_specified
-  end
-
-  def load_json(column)
-    file = Dir.glob("variables/**/#{column}.json").first
-    @file_name_test = (file != nil)
-    @json = JSON.parse(File.read(file)) rescue @json = {}
-    @json_id_test = (@json['id'].to_s.downcase == column)
-  end
-
-  def load_valid_values
-    valid_values = []
-    if @json['type'] == 'choices'
-      file = Dir.glob("domains/**/#{@json['domain']}.json").first
-      if json = JSON.parse(File.read(file)) rescue false
-        valid_values = json.collect{|hash| hash['value']}
-      end
-    end
-    @valid_values = valid_values
-  end
-
-  def number_of_errors
-    @file_name_test && @json_id_test && @values_test && @variable_type_test && @domain_test ? 0 : 1
-  end
-
-  def check_values
-    @json['type'] != 'choices' || (@valid_values | @csv_values.compact).size == @valid_values.size
-  end
-
-  def check_variable_type
-    Spout::Tests::VariableTypeValidation::VALID_VARIABLE_TYPES.include?(@json['type'])
-  end
-
-  def check_domain_specified
-    if @json['type'] != 'choices'
-      true
-    else
-      domain_file = Dir.glob("domains/**/#{@json['domain']}.json").first
-      if domain_json = JSON.parse(File.read(domain_file)) rescue false
-        return domain_json.kind_of?(Array)
-      end
-      false
-    end
-  end
-
-  def errored?
-    error == true
-  end
-end
-
 def number_with_delimiter(number, delimiter = ",")
   number.to_s.gsub(/(\d)(?=(\d\d\d)+(?!\d))/, "\\1#{delimiter}")
 end

data/lib/spout/templates/gitignore

@@ -9,4 +9,4 @@
 /coverage
 /csvs
 /graphs
-/charts
+/images

data/lib/spout/version.rb

@@ -3,7 +3,7 @@ module Spout
     MAJOR = 0
     MINOR = 8
     TINY = 0
-    BUILD = "beta1" # nil, "pre", "rc", "rc2"
+    BUILD = "beta2" # nil, "pre", "rc", "rc2"
 
     STRING = [MAJOR, MINOR, TINY, BUILD].compact.join('.')
   end