spout 0.10.0.beta9 → 0.10.0.beta10

data/lib/spout/models/form.rb

@@ -4,11 +4,12 @@
 #   "code_book": "Baseline-Visit-Intake-Questionnaire.pdf"
 # }
 
-require 'json'
+require 'spout/models/record'
 
 module Spout
   module Models
-    class Form
+    class Form < Spout::Models::Record
+
       attr_accessor :id, :display_name, :code_book
       attr_accessor :errors
 

data/lib/spout/models/graphables/choices_vs_choices.rb

@@ -0,0 +1,33 @@
+require 'spout/models/graphables/default'
+
+module Spout
+  module Models
+    module Graphables
+      class ChoicesVsChoices < Spout::Models::Graphables::Default
+
+        def categories
+          filtered_domain_options(@chart_variable).collect(&:display_name)
+        end
+
+        def units
+          'percent'
+        end
+
+        def series
+          filtered_domain_options(@variable).collect do |option|
+            filtered_subjects = @subjects.select{ |s| s.send(@variable.id) == option.value }
+            data = filtered_domain_options(@chart_variable).collect do |chart_option|
+              filtered_subjects.select{ |s| s.send(@chart_variable.id) == chart_option.value }.count
+            end
+            { name: option.display_name, data: data }
+          end
+        end
+
+        def stacking
+          'percent'
+        end
+
+      end
+    end
+  end
+end

data/lib/spout/models/graphables/choices_vs_numeric.rb

@@ -0,0 +1,56 @@
+require 'spout/models/graphables/default'
+require 'spout/helpers/array_statistics'
+
+module Spout
+  module Models
+    module Graphables
+      class ChoicesVsNumeric < Spout::Models::Graphables::Default
+
+        def categories
+          filtered_subjects = filter_and_sort_subjects
+
+          return [] if filtered_subjects.size == 0
+
+          [:quartile_one, :quartile_two, :quartile_three, :quartile_four].collect do |quartile|
+            quartile = filtered_subjects.send(quartile).collect(&@chart_variable.id.to_sym)
+            "#{quartile.min} to #{quartile.max}"
+          end
+        end
+
+        def units
+          'percent'
+        end
+
+        def series
+          filtered_subjects = filter_and_sort_subjects
+
+          return [] if filtered_subjects.size == 0
+
+          filtered_domain_options(@variable).collect do |option|
+            data = [:quartile_one, :quartile_two, :quartile_three, :quartile_four].collect do |quartile|
+              filtered_subjects.send(quartile).select{ |s| s.send(@variable.id) == option.value }.count
+            end
+            { name: option.display_name, data: data }
+          end
+        end
+
+        def stacking
+          'percent'
+        end
+
+        private
+
+        def filter_and_sort_subjects
+          @filter_and_sort_subjects ||= begin
+            @subjects.select do |s|
+              s.send(@variable.id) != nil and s.send(@chart_variable.id) != nil
+            end.sort_by(&@chart_variable.id.to_sym)
+          rescue
+            []
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/spout/models/graphables/default.rb

@@ -0,0 +1,115 @@
+require 'spout/models/variable'
+require 'spout/models/bucket'
+
+module Spout
+  module Models
+    module Graphables
+      class Default
+
+        attr_reader :variable, :chart_variable, :stratification_variable, :subjects
+
+        def initialize(variable, chart_variable, stratification_variable, subjects)
+          @variable = variable
+          @chart_variable = chart_variable
+          @stratification_variable = stratification_variable
+          @subjects = subjects
+
+          @values = subjects.collect(&@variable.id.to_sym) rescue @values = []
+          @values_unique = @values.uniq
+
+          @buckets = continuous_buckets
+        end
+
+        def to_hash
+          if valid?
+            { title: title, subtitle: subtitle, categories: categories, units: units, series: series, stacking: stacking, x_axis_title: x_axis_title }
+          else
+            nil
+          end
+        end
+
+        def valid?
+          if @variable == nil or @chart_variable == nil or @values == []
+            false
+          elsif @variable.type == 'choices' and @variable.domain.options == []
+            false
+          elsif @chart_variable.type == 'choices' and @chart_variable.domain.options == []
+            false
+          else
+            true
+          end
+        end
+
+        def title
+          "#{@variable.display_name} by #{@chart_variable.display_name}"
+        end
+
+        def subtitle
+          "By Visit"
+        end
+
+        def categories
+          []
+        end
+
+        def units
+          nil
+        end
+
+        def series
+          []
+        end
+
+        def stacking
+          nil
+        end
+
+        def x_axis_title
+          nil
+        end
+
+        private
+
+        def continuous_buckets
+          values_numeric = @values.select{|v| v.kind_of? Numeric}
+          return [] if values_numeric.count == 0
+          minimum_bucket = values_numeric.min
+          maximum_bucket = values_numeric.max
+          max_buckets = 12
+          bucket_size = ((maximum_bucket - minimum_bucket) / max_buckets.to_f)
+          precision = (bucket_size == 0 ? 0 : [-Math.log10(bucket_size).floor, 0].max)
+
+          buckets = []
+          (0..(max_buckets-1)).to_a.each do |index|
+            start = (minimum_bucket + index * bucket_size)
+            stop = (start + bucket_size)
+            buckets << Spout::Models::Bucket.new(start.round(precision),stop.round(precision))
+          end
+          buckets
+        end
+
+        def get_bucket(value)
+          return nil if @buckets.size == 0 or not value.kind_of?(Numeric)
+          @buckets.each do |b|
+            return b.display_name if b.in_bucket?(value)
+          end
+          if value <= @buckets.first.start
+            @buckets.first.display_name
+          else
+            @buckets.last.display_name
+          end
+        end
+
+        # Returns variable options that are either:
+        # a) are not missing codes
+        # b) or are marked as missing codes but represented in the dataset
+        def filtered_domain_options(variable)
+          variable.domain.options.select do |o|
+            o.missing != true or (o.missing == true and @values_unique.include?(o.value))
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/spout/models/graphables/histogram.rb

@@ -0,0 +1,53 @@
+require 'spout/models/graphables/default'
+
+module Spout
+  module Models
+    module Graphables
+      class Histogram < Spout::Models::Graphables::Default
+
+        def title
+          @variable.display_name
+        end
+
+        def categories
+          if @variable.type == 'choices'
+            filtered_domain_options(@variable).collect(&:display_name)
+          else
+            @buckets.collect(&:display_name)
+          end
+        end
+
+        def units
+          'Subjects'
+        end
+
+        def series
+          @chart_variable.domain.options.collect do |option|
+            visit_subjects = @subjects.select{ |s| s.send(@chart_variable.id) == option.value and s.send(@variable.id) != nil } rescue visit_subjects = []
+            visit_subject_values = visit_subjects.collect(&@variable.id.to_sym).sort rescue visit_subject_values = []
+            next unless visit_subject_values.size > 0
+
+            data = []
+
+            if @variable.type == 'choices'
+              data = filtered_domain_options(@variable).collect do |option|
+                visit_subject_values.select{ |v| v == option.value }.count
+              end
+            else
+              visit_subject_values.group_by{|v| get_bucket(v) }.each do |key, values|
+                data[categories.index(key)] = values.count if categories.index(key)
+              end
+            end
+
+            { name: option.display_name, data: data }
+          end.compact
+        end
+
+        def x_axis_title
+          @variable.units
+        end
+
+      end
+    end
+  end
+end

data/lib/spout/models/graphables/numeric_vs_choices.rb

@@ -0,0 +1,47 @@
+require 'spout/models/graphables/default'
+
+module Spout
+  module Models
+    module Graphables
+      class NumericVsChoices < Spout::Models::Graphables::Default
+
+        def categories
+          categories_result = []
+          @stratification_variable.domain.options.each do |option|
+            visit_subjects = @subjects.select{ |s| s._visit == option.value and s.send(@variable.id) != nil } rescue visit_subjects = []
+            if visit_subjects.count > 0
+              categories_result << option.display_name
+            end
+          end
+          categories_result
+        end
+
+        def units
+          @variable.units
+        end
+
+        def series
+          data = []
+
+          @stratification_variable.domain.options.each do |option|
+            visit_subjects = @subjects.select{ |s| s._visit == option.value and s.send(@variable.id) != nil } rescue visit_subjects = []
+            if visit_subjects.count > 0
+
+              filtered_domain_options(@chart_variable).each_with_index do |option, index|
+                values = visit_subjects.select{|s| s.send(@chart_variable.id) == option.value }.collect(&@variable.id.to_sym)
+                data[index] ||= []
+                data[index] << (values.mean.round(2) rescue 0.0)
+              end
+
+            end
+          end
+
+          filtered_domain_options(@chart_variable).each_with_index.collect do |option, index|
+            { name: option.display_name, data: data[index] }
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/spout/models/graphables/numeric_vs_numeric.rb

@@ -0,0 +1,55 @@
+require 'spout/models/graphables/default'
+require 'spout/helpers/array_statistics'
+
+module Spout
+  module Models
+    module Graphables
+      class NumericVsNumeric < Spout::Models::Graphables::Default
+
+        def categories
+          ["Quartile One", "Quartile Two", "Quartile Three", "Quartile Four"]
+        end
+
+        def units
+          @variable.units
+        end
+
+        def series
+          @stratification_variable.domain.options.collect do |option|
+            filtered_subjects = filter_and_sort_subjects_by_stratification_option(option)
+            next if filtered_subjects.size == 0
+
+            data = [:quartile_one, :quartile_two, :quartile_three, :quartile_four].collect do |quartile|
+              array = filtered_subjects.send(quartile).collect(&@variable.id.to_sym)
+              array_statistics(array)
+            end
+
+            { name: option.display_name, data: data }
+          end.compact
+        end
+
+        private
+
+        def filter_and_sort_subjects_by_stratification_option(option)
+          begin
+            @subjects.select do |s|
+              s._visit == option.value and s.send(@variable.id) != nil and s.send(@chart_variable.id) != nil
+            end.sort_by(&@chart_variable.id.to_sym)
+          rescue
+            []
+          end
+        end
+
+        def array_statistics(array)
+          {      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
+
+      end
+    end
+  end
+end

data/lib/spout/models/graphables.rb

@@ -0,0 +1,46 @@
+require 'spout/models/graphables/default'
+require 'spout/models/graphables/histogram'
+require 'spout/models/graphables/numeric_vs_choices'
+require 'spout/models/graphables/choices_vs_choices'
+require 'spout/models/graphables/numeric_vs_numeric'
+require 'spout/models/graphables/choices_vs_numeric'
+
+
+module Spout
+  module Models
+    module Graphables
+
+      DEFAULT_CLASS = Spout::Models::Graphables::Default
+      GRAPHABLE_CLASSES = {
+        'histogram' =>          Spout::Models::Graphables::Histogram,
+        'numeric_vs_choices' => Spout::Models::Graphables::NumericVsChoices,
+        'choices_vs_choices' => Spout::Models::Graphables::ChoicesVsChoices,
+        'numeric_vs_numeric' => Spout::Models::Graphables::NumericVsNumeric,
+        'choices_vs_numeric' => Spout::Models::Graphables::ChoicesVsNumeric
+      }
+
+      def self.for(variable, chart_variable, stratification_variable, subjects)
+        graph_type = get_graph_type(variable, chart_variable, stratification_variable)
+        (GRAPHABLE_CLASSES[graph_type] || DEFAULT_CLASS).new(variable, chart_variable, stratification_variable, subjects)
+      end
+
+      def self.get_graph_type(variable, chart_variable, stratification_variable)
+        if stratification_variable == nil
+          'histogram'
+        else
+          "#{variable_to_graph_type(variable)}_vs_#{variable_to_graph_type(chart_variable)}"
+        end
+      end
+
+      def self.variable_to_graph_type(variable)
+        variable_type = (variable ? variable.type : nil)
+        case variable_type when 'numeric', 'integer'
+          'numeric'
+        else
+          variable_type
+        end
+      end
+
+    end
+  end
+end

data/lib/spout/models/option.rb

@@ -1,10 +1,10 @@
 module Spout
   module Models
     class Option
-      attr_accessor :display_name, :value, :description
+      attr_accessor :display_name, :value, :description, :missing
 
       def initialize(option_hash)
-        %w( display_name value description ).each do |method|
+        %w( display_name value description missing ).each do |method|
           instance_variable_set("@#{method}", (option_hash.kind_of?(Hash) ? option_hash : {})[method])
         end
       end

data/lib/spout/models/record.rb

@@ -0,0 +1,19 @@
+require 'json'
+require 'fileutils'
+
+module Spout
+  module Models
+    class Record
+
+      class << self
+        # Only returns records with zero json errors, nil otherwise
+        def find_by_id(id)
+          dictionary_root = FileUtils.pwd # '.'
+          file_name = Dir.glob(File.join(dictionary_root, "#{self.name.split("::").last.to_s.downcase}s", "**", "#{id.to_s.downcase}.json"), File::FNM_CASEFOLD).first
+          variable = new(file_name, dictionary_root)
+          (variable.errors.size > 0 ? nil : variable)
+        end
+      end
+    end
+  end
+end

data/lib/spout/models/tables/choices_vs_choices.rb

@@ -0,0 +1,52 @@
+require 'spout/models/tables/default'
+
+module Spout
+  module Models
+    module Tables
+      class ChoicesVsChoices < Spout::Models::Tables::Default
+
+        def title
+          "#{@variable.display_name} vs #{@chart_variable.display_name}"
+        end
+
+        def headers
+          [ [""] + filtered_domain_options(@chart_variable).collect(&:display_name) + ["Total"] ]
+        end
+
+        def footers
+          total_values = filtered_domain_options(@chart_variable).collect do |option|
+            total_count = @filtered_subjects.select{|s| s.send(@chart_variable.id) == option.value }.count
+            { text: (total_count == 0 ? "-" : Spout::Helpers::TableFormatting::format_number(total_count, :count)), style: "font-weight:bold" }
+          end
+          [
+            [{ text: "Total", style: "font-weight:bold" }] + total_values + [{ text: Spout::Helpers::TableFormatting::format_number(@filtered_subjects.count, :count), style: 'font-weight:bold'}]
+          ]
+        end
+
+        def rows
+          rows_result = []
+          rows_result = filtered_domain_options(@variable).collect do |option|
+            row_subjects = @filtered_subjects.select{ |s| s.send(@variable.id) == option.value }
+            row_cells = filtered_domain_options(@chart_variable).collect do |chart_option|
+              count = row_subjects.select{ |s| s.send(@chart_variable.id) == chart_option.value }.count
+              count > 0 ? Spout::Helpers::TableFormatting::format_number(count, :count) : { text: '-', class: 'text-muted' }
+            end
+
+            total = row_subjects.count
+
+            [option.display_name] + row_cells + [total == 0 ? { text: '-', class: 'text-muted' } : { text: Spout::Helpers::TableFormatting::format_number(total, :count), style: 'font-weight:bold'}]
+          end
+
+          if @filtered_subjects.select{|s| s.send(@variable.id) == nil }.count > 0
+            unknown_values = filtered_domain_options(@chart_variable).collect do |chart_option|
+              { text: Spout::Helpers::TableFormatting::format_number(@filtered_subjects.select{ |s| s.send(@chart_variable.id) == chart_option.value and s.send(@variable.id) == nil }.count, :count), class: 'text-muted' }
+            end
+            rows_result << [{ text: 'Unknown', class: 'text-muted'}] + unknown_values + [ { text: Spout::Helpers::TableFormatting::format_number(@filtered_subjects.select{|s| s.send(@variable.id) == nil}.count, :count), style: 'font-weight:bold', class: 'text-muted' } ]
+          end
+          rows_result
+        end
+
+      end
+    end
+  end
+end

data/lib/spout/models/tables/choices_vs_numeric.rb

@@ -0,0 +1,49 @@
+require 'spout/models/tables/default'
+require 'spout/helpers/array_statistics'
+
+module Spout
+  module Models
+    module Tables
+      class ChoicesVsNumeric < Spout::Models::Tables::Default
+
+        def title
+          "#{@variable.display_name} vs #{@chart_variable.display_name}"
+        end
+
+        def headers
+          categories = [:quartile_one, :quartile_two, :quartile_three, :quartile_four].collect do |quartile|
+            bucket = @filtered_both_variables_subjects.send(quartile).collect(&@chart_variable.id.to_sym)
+            "#{bucket.min} to #{bucket.max} #{@chart_variable.units}"
+          end
+
+          [ [""] + categories + ["Total"] ]
+        end
+
+        def footers
+          total_values = [:quartile_one, :quartile_two, :quartile_three, :quartile_four].collect do |quartile|
+            { text: Spout::Helpers::TableFormatting::format_number(@filtered_both_variables_subjects.send(quartile).count, :count), style: "font-weight:bold" }
+          end
+
+          [
+            [{ text: "Total", style: "font-weight:bold" }] + total_values + [{ text: Spout::Helpers::TableFormatting::format_number(@filtered_both_variables_subjects.count, :count), style: 'font-weight:bold'}]
+          ]
+        end
+
+        def rows
+          filtered_both_variables_domain_options(@variable).collect do |option|
+            row_subjects = @filtered_both_variables_subjects.select{ |s| s.send(@variable.id) == option.value }
+
+            data = [:quartile_one, :quartile_two, :quartile_three, :quartile_four].collect do |quartile|
+              bucket = @filtered_both_variables_subjects.send(quartile).select{ |s| s.send(@variable.id) == option.value }
+              Spout::Helpers::TableFormatting::format_number(bucket.count, :count)
+            end
+
+            [option.display_name] + data + [{ text: Spout::Helpers::TableFormatting::format_number(row_subjects.count, :count), style: 'font-weight:bold'}]
+          end
+        end
+
+
+      end
+    end
+  end
+end

data/lib/spout/models/tables/default.rb

@@ -0,0 +1,86 @@
+require 'spout/models/variable'
+require 'spout/helpers/table_formatting'
+
+module Spout
+  module Models
+    module Tables
+      class Default
+
+        attr_reader :variable, :chart_variable, :subjects, :subtitle
+
+        def initialize(variable, chart_variable, subjects, subtitle)
+          @variable = variable
+          @chart_variable = chart_variable
+          @subjects = subjects
+          @subtitle = subtitle
+
+          @filtered_subjects = @subjects.select{ |s| s.send(@chart_variable.id) != nil } rescue @filtered_subjects = []
+          @filtered_both_variables_subjects = subjects.select{ |s| s.send(@variable.id) != nil and s.send(@chart_variable.id) != nil }.sort_by(&@chart_variable.id.to_sym) rescue @filtered_both_variables_subjects = []
+
+          @values = @filtered_subjects.collect(&@variable.id.to_sym).uniq rescue @values = []
+
+          @values_unique = @values.uniq
+
+          @values_both_variables = @filtered_both_variables_subjects.collect(&@variable.id.to_sym).uniq rescue @values_both_variables = []
+          @values_both_variables_unique = @values_both_variables.uniq
+        end
+
+        def to_hash
+          if valid?
+            { title: title, subtitle: @subtitle, headers: headers, footers: footers, rows: rows }
+          else
+            nil
+          end
+        end
+
+        # TODO: Same as graphables/default.rb REFACTOR
+        def valid?
+          if @variable == nil or @chart_variable == nil or @values == []
+            false
+          elsif @variable.type == 'choices' and @variable.domain.options == []
+            false
+          elsif @chart_variable.type == 'choices' and @chart_variable.domain.options == []
+            false
+          else
+            true
+          end
+        end
+
+        def title
+          ""
+        end
+
+        def headers
+          []
+        end
+
+        def footers
+          []
+        end
+
+        def rows
+          []
+        end
+
+
+        private
+
+        # Returns variable options that are either:
+        # a) are not missing codes
+        # b) or are marked as missing codes but represented in the dataset
+        def filtered_domain_options(variable)
+          variable.domain.options.select do |o|
+            o.missing != true or (o.missing == true and @values_unique.include?(o.value))
+          end
+        end
+
+        def filtered_both_variables_domain_options(variable)
+          variable.domain.options.select do |o|
+            o.missing != true or (o.missing == true and @values_both_variables_unique.include?(o.value))
+          end
+        end
+
+      end
+    end
+  end
+end