spout 0.10.0.beta9 → 0.10.0.beta10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1510bf903f7dada97ac4f63538881fe5cddb0825
-  data.tar.gz: 8678041008439bd0eaea5e163eb6d4fc6337469b
+  metadata.gz: cb6c2e9b16149cba7a217e1e5dfec5764ac33e8a
+  data.tar.gz: e1a7fbd00c9c5678089d8d6266e791121fc2d468
 SHA512:
-  metadata.gz: 390ca815b08364e3d3f8e068dd1104d784bdc48eb85bd2da9fc6e3d44562aec5ac75e22524d0580c1f0dba8ffec341021e463ac9b57d627ac7ae6b8e85d846f4
-  data.tar.gz: fa7bf7eb06e667c972354bd7b81f4d32e7f0c37de0a7115c06f484361943a7a9b737020b9434c4b7d132403035aa9c9f1caf89fccdfd3cf87e8b0357163fe935
+  metadata.gz: b93e28aa28e19ef8d3bec0fbc5107e8bae5b835eaca307bac36dec4c151ee3c7c7e27ba0ff8f050d81d1538256490b8cb786936b4d61acb1c71980da7860b662
+  data.tar.gz: 9e7d49b85dc352e0289de396ef75bfdebec45064a05ef992c2efe872519c61c901cc4811f60ea48c123dfa4b67c86aa634270e54c8f7a4dd1bec08f6281d143c

data/CHANGELOG.md

@@ -15,6 +15,11 @@
 - **Testing Changes**
   - Tests now include checks to assure that variable display_name fields don't exceed 255 length requirement
     - `include Spout::Tests::VariableDisplayNameLength`
+- **Gem Changes**
+  - Use of Ruby 2.1.4 is now recommended
+
+### Refactoring
+- Removing ChartTypes class in favor of a more modular Graph and Table class
 
 ## 0.9.1 (October 14, 2014)
 

data/lib/spout/commands/graphs.rb

@@ -7,6 +7,9 @@ require 'colorize'
 
 require 'spout/helpers/subject_loader'
 require 'spout/helpers/chart_types'
+require 'spout/models/variable'
+require 'spout/models/graphables'
+require 'spout/models/tables'
 require 'spout/helpers/config_reader'
 require 'spout/helpers/send_file'
 require 'spout/version'
@@ -27,7 +30,9 @@ module Spout
 
         @config = Spout::Helpers::ConfigReader.new
 
-        if Spout::Helpers::ChartTypes::get_json(@config.visit, 'variable') == nil
+        @stratification_variable = Spout::Models::Variable.find_by_id @config.visit
+
+        if @stratification_variable == nil
           if @config.visit == ''
             puts "The visit variable in .spout.yml can't be blank."
           else
@@ -36,7 +41,7 @@ module Spout
           return self
         end
 
-        missing_variables = @config.charts.select{|c| Spout::Helpers::ChartTypes::get_json(c['chart'], 'variable') == nil}
+        missing_variables = @config.charts.select{|c| Spout::Models::Variable.find_by_id(c['chart']) == nil}
         if missing_variables.count > 0
           puts "Could not find the following chart variable#{'s' unless missing_variables.size == 1}: #{missing_variables.join(', ')}"
           return self
@@ -54,7 +59,8 @@ module Spout
 
         @chart_variables = @config.charts.unshift( { "chart" => @config.visit, "title" => 'Histogram' } )
 
-        @variable_files = Dir.glob('variables/**/*.json')
+        @dictionary_root = Dir.pwd
+        @variable_files = Dir.glob(File.join(@dictionary_root, 'variables', '**', '*.json'))
 
         t = Time.now
         @graphs_folder = File.join("graphs", @standard_version)
@@ -87,22 +93,23 @@ module Spout
 
       def compute_tables_and_charts
         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)
+          variable = Spout::Models::Variable.new(variable_file, @dictionary_root)
+
+          next unless variable.errors.size == 0
+          next unless @valid_ids.include?(variable.id) or @valid_ids.size == 0
+          next unless ["numeric", "integer", "choices"].include?(variable.type)
+          next unless Spout::Models::Subject.method_defined?(variable.id)
 
           if @deploy_mode
             print "\r     Graph Generation: " + "#{"% 3d" % ((file_index+1)*100/variable_files_count)}% Uploaded".colorize(:white)
           else
-            puts "#{file_index+1} of #{variable_files_count}: #{variable_file.gsub(/(^variables\/|\.json$)/, '').gsub('/', ' / ')}"
+            puts "#{file_index+1} of #{variable_files_count}: #{variable.folder}#{variable.id}"
           end
 
-          @progress[variable_name] ||= {}
-          next if (not @deploy_mode and @progress[variable_name]['generated'] == true) or (@deploy_mode and @progress[variable_name]['uploaded'] == true)
+          @progress[variable.id] ||= {}
+          next if (not @deploy_mode and @progress[variable.id]['generated'] == true) or (@deploy_mode and @progress[variable.id]['uploaded'] == true)
 
           stats = {
             charts: {},
@@ -112,38 +119,43 @@ module Spout
           @chart_variables.each do |chart_type_hash|
             chart_type = chart_type_hash["chart"]
             chart_title = chart_type_hash["title"].downcase.gsub(' ', '-')
+            chart_variable = Spout::Models::Variable.find_by_id(chart_type)
 
             if chart_type == @config.visit
-              filtered_subjects = @subjects.select{ |s| s.send(chart_type) != nil }  # and s.send(variable_name) != nil
+              filtered_subjects = @subjects.select{ |s| s.send(chart_type) != nil }
               if filtered_subjects.count > 0
-                stats[:charts][chart_title] = Spout::Helpers::ChartTypes::chart_histogram(chart_type, filtered_subjects, json, variable_name)
-                stats[:tables][chart_title] = Spout::Helpers::ChartTypes::table_arbitrary(chart_type, filtered_subjects, json, variable_name)
+                graph = Spout::Models::Graphables.for(variable, chart_variable, nil, filtered_subjects)
+                stats[:charts][chart_title] = graph.to_hash
+                table = Spout::Models::Tables.for(variable, chart_variable, filtered_subjects, nil)
+                stats[:tables][chart_title] = table.to_hash
               end
             else
-              filtered_subjects = @subjects.select{ |s| s.send(chart_type) != nil } # and s.send(variable_name) != nil
-              if filtered_subjects.collect(&variable_name.to_sym).compact.count > 0
-                stats[:charts][chart_title] = Spout::Helpers::ChartTypes::chart_arbitrary(chart_type, filtered_subjects, json, variable_name, visits)
-                stats[:tables][chart_title] = visits.collect do |visit_display_name, visit_value|
-                  visit_subjects = filtered_subjects.select{ |s| s._visit == visit_value }
-                  unknown_subjects = visit_subjects.select{ |s| s.send(variable_name) == nil }
-                  (visit_subjects.count > 0 && visit_subjects.count != unknown_subjects.count) ? Spout::Helpers::ChartTypes::table_arbitrary(chart_type, visit_subjects, json, variable_name, visit_display_name) : nil
+              filtered_subjects = @subjects.select{ |s| s.send(chart_type) != nil }
+              if filtered_subjects.collect(&variable.id.to_sym).compact.count > 0
+                graph = Spout::Models::Graphables.for(variable, chart_variable, @stratification_variable, filtered_subjects)
+                stats[:charts][chart_title] = graph.to_hash
+                stats[:tables][chart_title] = @stratification_variable.domain.options.collect do |option|
+                  visit_subjects = filtered_subjects.select{ |s| s._visit == option.value }
+                  unknown_subjects = visit_subjects.select{ |s| s.send(variable.id) == nil }
+                  table = Spout::Models::Tables.for(variable, chart_variable, visit_subjects, option.display_name)
+                  (visit_subjects.count > 0 && visit_subjects.count != unknown_subjects.count) ? table.to_hash : nil
                 end.compact
               end
             end
           end
 
-          chart_json_file = File.join(@graphs_folder, "#{json['id']}.json")
+          chart_json_file = File.join(@graphs_folder, "#{variable.id}.json")
           File.open(chart_json_file, 'w') { |file| file.write( JSON.pretty_generate(stats) + "\n" ) }
 
-          @progress[variable_name]['generated'] = true
+          @progress[variable.id]['generated'] = true
 
-          if @deploy_mode and not @progress[variable_name]['uploaded'] == true
+          if @deploy_mode and not @progress[variable.id]['uploaded'] == true
             response = send_to_server(chart_json_file)
             if response.kind_of?(Hash) and response['upload'] == 'success'
-              @progress[variable_name]['uploaded'] = true
+              @progress[variable.id]['uploaded'] = true
             else
               puts "\nUPLOAD FAILED: ".colorize(:red) + File.basename(chart_json_file)
-              @progress[variable_name]['uploaded'] = false
+              @progress[variable.id]['uploaded'] = false
             end
           end
 
@@ -156,13 +168,6 @@ module Spout
         response = Spout::Helpers::SendFile.post("#{@url}/datasets/#{@slug}/upload_graph.json", chart_json_file, @standard_version, @token)
       end
 
-      # [["Visit 1", "1"], ["Visit 2", "2"], ["CVD Outcomes", "3"]]
-      def visits
-        @visits ||= begin
-          Spout::Helpers::ChartTypes::domain_array(@config.visit)
-        end
-      end
-
     end
   end
 end

data/lib/spout/commands/images.rb

@@ -4,6 +4,8 @@ require 'rubygems'
 require 'json'
 require 'yaml'
 
+require 'spout/models/variable'
+require 'spout/models/graphables'
 require 'spout/helpers/subject_loader'
 require 'spout/helpers/chart_types'
 require 'spout/helpers/config_reader'
@@ -68,7 +70,9 @@ module Spout
         FileUtils.mkpath( options_folder )
         tmp_options_file = File.join( options_folder, 'options.json' )
 
+        chart_variable = Spout::Models::Variable.find_by_id(@config.visit)
         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
@@ -90,9 +94,10 @@ module Spout
 
           filtered_subjects = @subjects.select{ |s| s.send(@config.visit) != nil }
 
-          chart_json = Spout::Helpers::ChartTypes::chart_histogram(@config.visit, filtered_subjects, json, variable_name)
+          variable = Spout::Models::Variable.find_by_id variable_name
+          graph = Spout::Models::Graphables.for(variable, chart_variable, nil, filtered_subjects)
 
-          if chart_json
+          if graph.valid?
             File.open(tmp_options_file, "w") do |outfile|
               outfile.puts <<-eos
                 {
@@ -106,21 +111,21 @@ module Spout
                     "text": ""
                   },
                   "xAxis": {
-                    "categories": #{chart_json[:categories].to_json}
+                    "categories": #{graph.categories.to_json}
                   },
                   "yAxis": {
                     "title": {
-                      "text": #{chart_json[:units].to_json}
+                      "text": #{graph.units.to_json}
                     }
                   },
                   "plotOptions": {
                     "column": {
                       "pointPadding": 0.2,
                       "borderWidth": 0,
-                      "stacking": #{chart_json[:stacking].to_json}
+                      "stacking": #{graph.stacking.to_json}
                     }
                   },
-                  "series": #{chart_json[:series].to_json}
+                  "series": #{graph.series.to_json}
                 }
               eos
             end

data/lib/spout/helpers/chart_types.rb

@@ -33,389 +33,6 @@ module Spout
         end
         buckets
       end
-
-      def self.get_json(file_name, file_type)
-        file = Dir.glob("#{file_type.to_s.downcase}s/**/#{file_name.to_s.downcase}.json", File::FNM_CASEFOLD).first
-        json = JSON.parse(File.read(file)) rescue json = nil
-        json
-      end
-
-      def self.get_variable(variable_name)
-        get_json(variable_name, 'variable')
-      end
-
-      def self.get_domain(json)
-        get_json(json['domain'], 'domain')
-      end
-
-      def self.domain_array(variable_name)
-        variable_file = Dir.glob("variables/**/#{variable_name.to_s.downcase}.json", File::FNM_CASEFOLD).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
-        return unless chart_variable_json = get_variable(chart_type)
-        return unless domain_json = get_domain(json)
-
-        title = "#{json['display_name']} by #{chart_variable_json['display_name']}"
-        subtitle = "By Visit"
-        # categories = ["Quartile One", "Quartile Two", "Quartile Three", "Quartile Four"]
-        units = 'percent'
-        series = []
-
-        filtered_subjects = subjects.select{ |s| s.send(method) != nil and s.send(chart_type) != nil }.sort_by(&chart_type.to_sym)
-
-        all_subject_values = filtered_subjects.collect(&method.to_sym).compact.sort
-        domain_json = remove_unused_missing_codes_from_domain(domain_json, all_subject_values.uniq)
-
-        categories = [:quartile_one, :quartile_two, :quartile_three, :quartile_four].collect do |quartile|
-          bucket = filtered_subjects.send(quartile).collect(&chart_type.to_sym)
-          "#{bucket.min} to #{bucket.max}"
-        end
-
-        domain_json.each do |option_hash|
-          data = [:quartile_one, :quartile_two, :quartile_three, :quartile_four].collect do |quartile|
-            filtered_subjects.send(quartile).select{ |s| s.send(method) == option_hash['value'] }.count
-          end
-
-          series << { name: option_hash['display_name'], data: data } unless filtered_subjects.size == 0
-        end
-
-        { title: title, subtitle: subtitle, categories: categories, units: units, series: series, stacking: 'percent' }
-      end
-
-      def self.chart_arbitrary_by_quartile(chart_type, subjects, json, method, visits)
-        # CHART TYPE IS THE QUARTILE VARIABLE
-        return unless chart_variable_json = get_variable(chart_type)
-        return chart_arbitrary_choices_by_quartile(chart_type, subjects, json, method) if json['type'] == 'choices'
-
-        title = "#{json['display_name']} by #{chart_variable_json['display_name']}"
-        subtitle = "By Visit"
-        categories = ["Quartile One", "Quartile Two", "Quartile Three", "Quartile Four"]
-        units = json["units"]
-        series = []
-
-        series = []
-
-        visits.each do |visit_display_name, visit_value|
-          data = []
-          filtered_subjects = subjects.select{ |s| s._visit == visit_value and s.send(method) != nil and s.send(chart_type) != nil }.sort_by(&chart_type.to_sym)
-
-          [:quartile_one, :quartile_two, :quartile_three, :quartile_four].each do |quartile|
-            array = filtered_subjects.send(quartile).collect(&method.to_sym)
-            data << {       y: (array.mean.round(1) rescue 0.0),
-                         stddev: ("%0.1f" % array.standard_deviation rescue ''),
-                         median: ("%0.1f" % array.median rescue ''),
-                            min: ("%0.1f" % array.min rescue ''),
-                            max: ("%0.1f" % array.max rescue ''),
-                              n: array.n }
-          end
-
-          series << { name: visit_display_name, data: data } unless filtered_subjects.size == 0
-        end
-
-        { title: title, subtitle: subtitle, categories: categories, units: units, series: series }
-      end
-
-      def self.table_arbitrary_by_quartile(chart_type, subjects, json, method, subtitle = nil)
-        return table_arbitrary_choices_by_quartile(chart_type, subjects, json, method, subtitle) if json['type'] == 'choices'
-        # CHART TYPE IS THE QUARTILE VARIABLE
-        return unless chart_variable_json = get_variable(chart_type)
-
-
-        headers = [
-          [""] + Spout::Helpers::ArrayStatistics::calculations.collect{|calculation_label, calculation_method| calculation_label} + ["Total"]
-        ]
-
-        filtered_subjects = subjects.select{ |s| s.send(method) != nil and s.send(chart_type) != nil }.sort_by(&chart_type.to_sym)
-
-        rows = [:quartile_one, :quartile_two, :quartile_three, :quartile_four].collect do |quartile|
-          bucket = filtered_subjects.send(quartile)
-          row_subjects = bucket.collect(&method.to_sym)
-          data = Spout::Helpers::ArrayStatistics::calculations.collect do |calculation_label, calculation_method, calculation_type, calculation_format|
-            TableFormatting::format_number(row_subjects.send(calculation_method), calculation_type, calculation_format)
-          end
-
-          row_name = if row_subjects.size == 0
-            quartile.to_s.capitalize.gsub('_one', ' One').gsub('_two', ' Two').gsub('_three', ' Three').gsub('_four', ' Four')
-          else
-            "#{bucket.collect(&chart_type.to_sym).min} to #{bucket.collect(&chart_type.to_sym).max} #{chart_variable_json['units']}"
-          end
-
-          [row_name] + data + [{ text: TableFormatting::format_number(row_subjects.count, :count), style: 'font-weight:bold'}]
-        end
-
-        total_values = Spout::Helpers::ArrayStatistics::calculations.collect do |calculation_label, calculation_method, calculation_type, calculation_format|
-          total_count = filtered_subjects.collect(&method.to_sym).send(calculation_method)
-          { text: TableFormatting::format_number(total_count, calculation_type, calculation_format), style: "font-weight:bold" }
-        end
-
-        footers = [
-          [{ text: "Total", style: "font-weight:bold" }] + total_values + [{ text: TableFormatting::format_number(filtered_subjects.count, :count), style: 'font-weight:bold'}]
-        ]
-
-        { title: "#{chart_variable_json['display_name']} vs #{json['display_name']}", subtitle: subtitle, headers: headers, footers: footers, rows: rows }
-
-      end
-
-      def self.table_arbitrary_choices_by_quartile(chart_type, subjects, json, method, subtitle)
-        # CHART TYPE IS THE QUARTILE VARIABLE
-        return unless chart_variable_json = get_variable(chart_type)
-        return unless domain_json = get_domain(json)
-
-        filtered_subjects = subjects.select{ |s| s.send(method) != nil and s.send(chart_type) != nil }.sort_by(&chart_type.to_sym)
-        all_subject_values = filtered_subjects.collect(&method.to_sym).compact.sort
-        domain_json = remove_unused_missing_codes_from_domain(domain_json, all_subject_values.uniq)
-
-        categories = [:quartile_one, :quartile_two, :quartile_three, :quartile_four].collect do |quartile|
-          bucket = filtered_subjects.send(quartile).collect(&chart_type.to_sym)
-          "#{bucket.min} to #{bucket.max} #{chart_variable_json['units']}"
-        end
-
-        headers = [
-          [""] + categories + ["Total"]
-        ]
-
-        rows = []
-
-        rows = domain_json.collect do |option_hash|
-          row_subjects = filtered_subjects.select{ |s| s.send(method) == option_hash['value'] }
-
-          data = [:quartile_one, :quartile_two, :quartile_three, :quartile_four].collect do |quartile|
-            bucket = filtered_subjects.send(quartile).select{ |s| s.send(method) == option_hash['value'] }
-            TableFormatting::format_number(bucket.count, :count)
-          end
-
-          [option_hash['display_name']] + data + [{ text: TableFormatting::format_number(row_subjects.count, :count), style: 'font-weight:bold'}]
-        end
-
-
-        total_values = [:quartile_one, :quartile_two, :quartile_three, :quartile_four].collect do |quartile|
-          { text: TableFormatting::format_number(filtered_subjects.send(quartile).count, :count), style: "font-weight:bold" }
-        end
-
-        footers = [
-          [{ text: "Total", style: "font-weight:bold" }] + total_values + [{ text: TableFormatting::format_number(filtered_subjects.count, :count), style: 'font-weight:bold'}]
-        ]
-
-        { title: "#{json['display_name']} vs #{chart_variable_json['display_name']}", subtitle: subtitle, headers: headers, footers: footers, rows: rows }
-      end
-
-
-      def self.chart_arbitrary_choices(chart_type, subjects, json, method)
-        return unless chart_variable_json = get_variable(chart_type)
-        return unless chart_variable_domain = domain_array(chart_type)
-        return unless domain_json = get_domain(json)
-
-
-        title = "#{json['display_name']} by #{chart_variable_json['display_name']}"
-        subtitle = "By Visit"
-        categories = chart_variable_domain.collect{|a| a[0]}
-        units = 'percent'
-        series = []
-
-        all_subject_values = subjects.collect(&method.to_sym).compact.sort
-        domain_json = remove_unused_missing_codes_from_domain(domain_json, all_subject_values.uniq)
-
-        domain_json.each do |option_hash|
-          domain_values = subjects.select{ |s| s.send(method) == option_hash['value'] }
-
-          data = chart_variable_domain.collect do |display_name, value|
-            domain_values.select{ |s| s.send(chart_type) == value }.count
-          end
-          series << { name: option_hash['display_name'], data: data }
-        end
-
-        { title: title, subtitle: subtitle, categories: categories, units: units, series: series, stacking: 'percent' }
-      end
-
-      def self.chart_arbitrary(chart_type, subjects, json, method, visits)
-        return unless chart_variable_json = get_variable(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'
-
-        title = "#{json['display_name']} by #{chart_variable_json['display_name']}"
-        subtitle = "By Visit"
-        categories = []
-        units = json["units"]
-        series = []
-
-        data = []
-
-        visits.each do |visit_display_name, visit_value|
-          visit_subjects = subjects.select{ |s| s._visit == visit_value and s.send(method) != nil }
-          if visit_subjects.count > 0
-            chart_variable_domain.each_with_index do |(display_name, value), index|
-              values = visit_subjects.select{|s| s.send(chart_type) == value }.collect(&method.to_sym)
-              data[index] ||= []
-              data[index] << (values.mean.round(2) rescue 0.0)
-            end
-            categories << visit_display_name
-          end
-        end
-
-        chart_variable_domain.each_with_index do |(display_name, value), index|
-          series << { name: display_name, data: data[index] }
-        end
-
-        { title: title, subtitle: subtitle, categories: categories, units: units, series: series }
-      end
-
-
-      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 = 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'
-
-        headers = [
-          [""] + Spout::Helpers::ArrayStatistics::calculations.collect{|calculation_label, calculation_method| calculation_label} + ["Total"]
-        ]
-
-        filtered_subjects = subjects.select{ |s| s.send(chart_type) != nil }
-
-        rows = chart_variable_domain.collect do |display_name, value|
-          row_subjects = filtered_subjects.select{ |s| s.send(chart_type) == value }
-
-          row_cells = Spout::Helpers::ArrayStatistics::calculations.collect do |calculation_label, calculation_method, calculation_type, calculation_format|
-            count = row_subjects.collect(&method.to_sym).send(calculation_method)
-            (count == 0 && calculation_method == :count) ? { text: '-', class: 'text-muted' } : TableFormatting::format_number(count, calculation_type, calculation_format)
-          end
-
-          [display_name] + row_cells + [{ text: TableFormatting::format_number(row_subjects.count, :count), style: 'font-weight:bold'}]
-        end
-
-        total_values = Spout::Helpers::ArrayStatistics::calculations.collect do |calculation_label, calculation_method, calculation_type, calculation_format|
-          total_count = filtered_subjects.collect(&method.to_sym).send(calculation_method)
-          { text: TableFormatting::format_number(total_count, calculation_type, calculation_format), style: "font-weight:bold" }
-        end
-
-        footers = [
-          [{ text: "Total", style: "font-weight:bold" }] + total_values + [{ text: TableFormatting::format_number(filtered_subjects.count, :count), style: 'font-weight:bold'}]
-        ]
-
-        { title: "#{chart_variable_json['display_name']} vs #{json['display_name']}", subtitle: subtitle, headers: headers, footers: footers, rows: rows }
-
-      end
-
-      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 = domain_array(chart_type)
-        return unless domain_json = get_domain(json)
-
-        headers = [
-          [""] + chart_variable_domain.collect{|display_name, value| display_name} + ["Total"]
-        ]
-
-        filtered_subjects = subjects.select{ |s| s.send(chart_type) != nil }
-
-        all_subject_values = filtered_subjects.collect(&method.to_sym).compact.sort
-        domain_json = remove_unused_missing_codes_from_domain(domain_json, all_subject_values.uniq)
-
-        rows = domain_json.collect do |option_hash|
-          row_subjects = filtered_subjects.select{ |s| s.send(method) == option_hash['value'] }
-          row_cells = chart_variable_domain.collect do |display_name, value|
-            count = row_subjects.select{ |s| s.send(chart_type) == value }.count
-            count > 0 ? TableFormatting::format_number(count, :count) : { text: '-', class: 'text-muted' }
-          end
-
-          total = row_subjects.count
-
-          [option_hash['display_name']] + row_cells + [total == 0 ? { text: '-', class: 'text-muted' } : { text: TableFormatting::format_number(total, :count), style: 'font-weight:bold'}]
-        end
-
-        if filtered_subjects.select{|s| s.send(method) == nil }.count > 0
-          unknown_values = chart_variable_domain.collect do |display_name, value|
-            { text: TableFormatting::format_number(filtered_subjects.select{ |s| s.send(chart_type) == value and s.send(method) == nil }.count, :count), class: 'text-muted' }
-          end
-          rows << [{ text: 'Unknown', class: 'text-muted'}] + unknown_values + [ { text: TableFormatting::format_number(filtered_subjects.select{|s| s.send(method) == nil}.count, :count), style: 'font-weight:bold', class: 'text-muted' } ]
-        end
-
-
-
-        total_values = chart_variable_domain.collect do |display_name, value|
-          total_count = filtered_subjects.select{|s| s.send(chart_type) == value }.count
-          { text: (total_count == 0 ? "-" : TableFormatting::format_number(total_count, :count)), style: "font-weight:bold" }
-        end
-
-        footers = [
-          [{ text: "Total", style: "font-weight:bold" }] + total_values + [{ text: TableFormatting::format_number(filtered_subjects.count, :count), style: 'font-weight:bold'}]
-        ]
-
-        { title: "#{json['display_name']} vs #{chart_variable_json['display_name']}", subtitle: subtitle, headers: headers, footers: footers, rows: rows }
-      end
-
-      def self.chart_histogram(chart_type, subjects, json, method)
-        domain_json = get_domain(json)
-        return if json['type'] == 'choices' and not domain_json
-        return unless chart_variable_json = get_variable(chart_type)
-        return unless chart_variable_domain = domain_array(chart_type)
-
-        title = "#{json['display_name']}"
-        subtitle = "By Visit"
-        units = "Subjects"
-        x_axis_units = json["units"]
-        series = []
-
-        all_subject_values = subjects.collect(&method.to_sym).compact.sort
-        return nil if all_subject_values.count == 0
-
-        domain_json = remove_unused_missing_codes_from_domain(domain_json, all_subject_values.uniq) if domain_json
-
-        categories = pull_categories(json, method, all_subject_values, domain_json)
-
-        buckets = continuous_buckets(all_subject_values)
-
-        chart_variable_domain.each do |display_name, value|
-          visit_subjects = subjects.select{ |s| s.send(chart_type) == value and s.send(method) != nil }.collect(&method.to_sym).sort
-          next unless visit_subjects.size > 0
-
-          data = pull_data(json, visit_subjects, buckets, categories, domain_json)
-
-          series << { name: display_name, data: data }
-        end
-
-        { title: title, subtitle: subtitle, categories: categories, units: units, series: series, x_axis_title: x_axis_units }
-      end
-
-      def self.pull_categories(json, method, all_subject_values, domain_json)
-        categories = []
-        if json['type'] == 'choices'
-          categories = domain_json.collect{|option_hash| option_hash['display_name']}
-        else
-          buckets = continuous_buckets(all_subject_values)
-          categories = buckets.collect{|b| "#{b[0]} to #{b[1]}"}
-        end
-        categories
-      end
-
-      def self.pull_data(json, visit_subjects, buckets, categories, domain_json)
-        data = []
-        if json['type'] == 'choices'
-          domain_json.each do |option_hash|
-            data << visit_subjects.select{ |v| v == option_hash['value'] }.count
-          end
-        else
-          visit_subjects.group_by{|v| get_bucket(buckets, v) }.each do |key, values|
-            data[categories.index(key)] = values.count if categories.index(key)
-          end
-        end
-        data
-      end
-
-      def self.remove_unused_missing_codes_from_domain(domain_json, unique_subject_values)
-        domain_json.select{|option_hash| option_hash['missing'] != true or (option_hash['missing'] == true and unique_subject_values.include?(option_hash['value']))}
-      end
-
     end
   end
 end

data/lib/spout/models/bucket.rb

@@ -0,0 +1,22 @@
+module Spout
+  module Models
+    class Bucket
+
+      attr_accessor :start, :stop
+
+      def initialize(start, stop)
+        @start = start
+        @stop = stop
+      end
+
+      def in_bucket?(value)
+        value >= @start and value <= @stop
+      end
+
+      def display_name
+        "#{@start} to #{@stop}"
+      end
+
+    end
+  end
+end

data/lib/spout/models/domain.rb

@@ -1,11 +1,13 @@
 require 'json'
 
+require 'spout/models/record'
 require 'spout/models/option'
 
 module Spout
   module Models
 
-    class Domain
+    class Domain < Spout::Models::Record
+
       attr_accessor :id, :folder, :options
       attr_reader :errors