quby 3.2.1 → 4.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ef09a9de962dda96eac0dc2aa3ef23b230ddae13b1e74f4420bd26bf2350a1d
-  data.tar.gz: 3959cbd4a5984daf406709f33927035bc8afa58542aac4c94716041c80f43eac
+  metadata.gz: 2515fe377284704a9e876a56f27babbf2b4895b49009806b511834975b04e2a8
+  data.tar.gz: a4902ca52517c9285868957f4362956875a34590ada0111f6ca2ea63dc326978
 SHA512:
-  metadata.gz: de85cd0ee70d9d1cf4f146a6b752b9a5923fb46979b9e87a21f733b7568c6e6c11cd3e1b00ab074c2060bbfd87e07c0e14b78f9474a3fe669b2c4c26cb59cb0c
-  data.tar.gz: a7f2e471ce980c28f8ec3b4c95f1b109a7af0d0b69a29396771b20fa824f16ba506779dc2cb561c343df88bb3d11783c7e3b3bc906ad532d489bcdb0a93a8903
+  metadata.gz: 7f9c41ade9e6ed49ce34b33ba7b828a9a52fbaa1c32a1040949f83008fddf05263b99fb8d8192eed4356f0f944a0dfeebe0d427944a49d2bef1dbfc42f051b2f
+  data.tar.gz: cf5941ba14f045484ad7c432aac40e23d44cfb03784e1e5ec372c16ede74d1f215dff470b2c73d42932acd138dc02055eb6d544a17732c80cadb9e0881977639

data/app/views/quby/v1/bulk/_item_question_number.html.haml

@@ -9,5 +9,5 @@
     - cls = [question.type]
     - cls << "subinput"  if subquestion
     - cls << question.as if question.as
-    = text_field :answer, question.key, :autocomplete => question.autocomplete, :class => cls, :disabled => (disabled ? "" : nil), :size => (question.size || 30), data: {"field-key" => question.key}
+    = text_field :answer, question.key, :autocomplete => question.autocomplete, :class => cls, :disabled => (disabled ? "" : nil), :size => question.size, data: {"field-key" => question.key}
     %span.unit= raw question.unit

data/app/views/quby/v1/paged/_item_question_number.html.haml

@@ -30,5 +30,5 @@
             - left = i * 100 / (question.labels.size - 1)
             %div{class: lcls, style: left != 100 ? "left: #{left}%" : ''}= transform_special_text(label).html_safe
     - else
-      = text_field :answer, question.key, :autocomplete => question.autocomplete, :class => cls, :disabled => (disabled ? "" : nil), :size => (question.size || 30), data: data
+      = text_field :answer, question.key, :autocomplete => question.autocomplete, :class => cls, :disabled => (disabled ? "" : nil), :size => question.size, data: data
     %span.unit= raw question.unit

data/app/views/quby/v1/table/_item_table_header.html.haml

@@ -5,12 +5,12 @@
   -#TODO: if a hidden option is checked it should get its own new scale header
   - cls = ['scaleheader']
   - if question.score_header == :question_description
-    %th.option{title: raw(question.description), class: cls, colspan: colspan, data: {for: question.key}}
+    %th.option{title: strip_tags(question.description), class: cls, colspan: colspan, data: {for: question.key}}
       = Quby::MarkdownParser.new(question.description).html_safe
   - else
     - question.options.each do |option|
       - next if (option.inner_title or option.hidden)
-      %th.option{title: raw(option.description), class: cls, data: {for: question.key}}
+      %th.option{title: strip_tags(option.description), class: cls, data: {for: question.key}}
         -#= raw cycle("<br/>", "", :name => "headbr" )
         - case question.score_header
         - when :value

data/lib/quby/answers.rb

@@ -4,6 +4,8 @@ require 'quby/answers/api'
 require 'quby/answers/dsl'
 
 require 'quby/answers/entities/answer'
+require 'quby/answers/entities/score'
+require 'quby/answers/entities/subscore'
 require 'quby/answers/entities/outcome'
 require 'quby/answers/entities/patient'
 require 'quby/answers/entities/respondent'

data/lib/quby/answers/entities/answer.rb

@@ -269,6 +269,14 @@ module Quby
           outcome.scores
         end
 
+        def score_objects
+          scores.map do |score_key, score_hash|
+            score = Score.new score_schema: questionnaire.score_schemas[score_key],
+                              score_hash: score_hash
+            [score_key, score]
+          end.to_h.with_indifferent_access
+        end
+
         def actions
           outcome.actions
         end

data/lib/quby/answers/entities/score.rb

@@ -0,0 +1,46 @@
+module Quby
+  module Answers
+    module Entities
+      # Score instances enhance answer#scores hash results with score schema information.
+      # It also presents the subscores as Subscore objects.
+
+      class Score
+        attr_accessor :score_schema
+        attr_accessor :subscores
+
+        # The key of the corresponding score in the questionnaire definition
+        delegate :key, to: :score_schema
+        # A label describing the general purpose of the score
+        delegate :label, to: :score_schema
+        # An array of SubscoreSchemas describing each key that can be returned in the result hash of a score.
+        delegate :subscore_schemas, to: :score_schema
+        # access subscores through []
+        delegate :[], to: :subscores
+
+        def initialize(score_schema:, score_hash:)
+          self.score_schema = score_schema
+          @score_hash = score_hash
+          initialize_subscores
+        end
+
+        def initialize_subscores
+          self.subscores = subscore_schemas.map do |subschema|
+            [subschema.key, Entities::Subscore.new(subschema: subschema, score_hash: @score_hash)]
+          end.to_h.with_indifferent_access
+        end
+
+        def referenced_values
+          @score_hash[:referenced_values]
+        end
+
+        def error
+          if @score_hash.has_key?(:exception)
+            @score_hash.slice(:backtrace, :exception)
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/quby/answers/entities/subscore.rb

@@ -0,0 +1,30 @@
+module Quby
+  module Answers
+    module Entities
+      # Subscore instances describe the subscore keys of answer#scores using score schema information.
+
+      class Subscore
+        attr_accessor :subschema
+
+        # The key this subscore has in the hash returned by the score
+        delegate :key, to: :subschema
+        # The description of this subscore in the context of the score, like 'Mean', 'T-Score' or 'Interpretation'
+        delegate :label, to: :subschema
+        # The shortened key that will used as the field/column name for csv and oru exports,
+        # excluding the questionnaire key part
+        delegate :export_key, to: :subschema
+        # Whether this score will only be exported through oru/api/data exports, but not shown in interfaces
+        delegate :only_for_export, to: :subschema
+
+        def initialize(subschema:, score_hash:)
+          self.subschema = subschema
+          @score_hash = score_hash
+        end
+
+        def value
+          @score_hash[key]
+        end
+      end
+    end
+  end
+end

data/lib/quby/answers/services/outcome_calculation.rb

@@ -74,8 +74,7 @@ module Quby
         end
 
         def value_by_regular_values
-          regular_values = answer.value_by_regular_values
-          @value_by_regular_values ||= regular_values.sort_by do |key, value|
+          @value_by_regular_values ||= answer.value_by_regular_values.sort_by do |key, value|
             questionnaire.fields.question_hash.keys.index(key) || Float::INFINITY
           end.to_h
         end

data/lib/quby/answers/services/score_calculator.rb

@@ -231,10 +231,9 @@ module Quby
         end
 
         def table_lookup(table_key, parameters)
-          table_hash[table_key] ||= Quby::LookupTable.new table_key
-          table = table_hash[table_key]
-
-          table.lookup(parameters)
+          @questionnaire.lookup_tables[table_key] ||= Quby::LookupTable.new table_key
+          @questionnaire.lookup_tables[table_key] \
+                        .lookup(parameters)
         end
 
         # Public: Ensure given question_keys have answers. Strings with nothing but whitespace are

data/lib/quby/lookup_table.rb

@@ -15,7 +15,7 @@ module Quby
       all_data = data
       headers = all_data.shift
       compare = all_data.shift
-      @backing = Quby::TableBackend::RangeTree.new(headers, compare, all_data)
+      @backing = Quby::TableBackend::RangeTree.from_csv(levels: headers, compare: compare, data: all_data)
     end
 
     def lookup(parameters)

data/lib/quby/questionnaires/dsl/charting/chart_builder.rb

@@ -41,6 +41,10 @@ module Quby
           @chart.y_range_categories = RangeCategories.new(*y_range_categories).as_range_hash
         end
 
+        def plotband(from, to, color)
+          @chart.plotbands << {from: from, to: to, color: color}
+        end
+
         def plot(key, options = {})
           unless plottable = @questionnaire.find_plottable(key)
             fail "Questionnaire #{@questionnaire.key} chart #{@chart.key} references unknown score or question #{key}"

data/lib/quby/questionnaires/dsl/charting/line_chart_builder.rb

@@ -17,12 +17,22 @@ module Quby
           @chart.tonality = value
         end
 
+        # value - Number or a hash `{from_age..to_age => {female: 5, default: 4}, .., default: { default: 3 }}`
+        # block - deprecated.
         def baseline(value = nil, &block)
           unless value.nil? ^ block.nil?
             fail ArgumentError, "Must give either value or a block"
           end
 
-          if value
+          if value && value.is_a?(Hash)
+            @chart.baseline = ->(age, gender) {
+              age_match = value.find { |age_range, _v| age && age_range === age }
+              hash_by_gender = (age_match&.last || value.stringify_keys["default"])
+
+              gender_match = hash_by_gender.find {|gender_key, _v| gender && gender_key.to_s == gender.to_s }
+              gender_match&.last || hash_by_gender.stringify_keys['default']
+            }
+          elsif value
             @chart.baseline = ->(age, gender) { value }
           end
 

data/lib/quby/questionnaires/dsl/questionnaire_builder.rb

@@ -145,6 +145,10 @@ module Quby
           @custom_methods[key] = block
         end
 
+        def add_lookup_tree(key, levels:, tree:)
+          @questionnaire.lookup_tables[key] = Quby::TableBackend::RangeTree.new(levels: levels, tree: tree)
+        end
+
         def default_question_options(options = {})
           @default_question_options.merge!(options)
         end

data/lib/quby/questionnaires/entities.rb

@@ -6,7 +6,7 @@ require 'quby/questionnaires/entities/question_option'
 require 'quby/questionnaires/entities/item'
 require 'quby/questionnaires/entities/score_calculation'
 
-require 'quby/questionnaires/entities/sub_score_schema'
+require 'quby/questionnaires/entities/subscore_schema'
 require 'quby/questionnaires/entities/score_schema'
 
 require 'quby/questionnaires/entities/fields'

data/lib/quby/questionnaires/entities/charting/chart.rb

@@ -57,7 +57,10 @@ module Quby
           # @return [Float]
           attr_accessor :tick_interval
 
-          def initialize(key, title: nil, plottables: nil, y_categories: nil, y_range_categories: nil, chart_type: nil, y_range: nil, tick_interval: nil)
+          # @return [Array]
+          attr_accessor :plotbands
+
+          def initialize(key, title: nil, plottables: nil, y_categories: nil, y_range_categories: nil, chart_type: nil, y_range: nil, tick_interval: nil, plotbands: nil)
             self.key = key.to_sym
             self.title = title
             self.plottables = plottables || []
@@ -66,6 +69,7 @@ module Quby
             self.chart_type = chart_type
             self.y_range = y_range
             self.tick_interval = tick_interval
+            self.plotbands = plotbands || []
           end
 
           def type

data/lib/quby/questionnaires/entities/fields.rb

@@ -108,7 +108,7 @@ module Quby
         def score_descriptions
           @score_variable_descriptions ||=
             @questionnaire.score_schemas.values.map do |score_schema|
-              score_schema.sub_score_schemas.map do |subschema|
+              score_schema.subscore_schemas.map do |subschema|
                 [subschema.export_key, "#{score_schema.label} #{subschema.label}"]
               end
             end.flatten(1).to_h.with_indifferent_access

data/lib/quby/questionnaires/entities/outcome_table.rb

@@ -20,7 +20,7 @@ module Quby
           (score_keys - questionnaire.score_schemas.values.map(&:key)).each do |missing_key|
             errors.add :score_keys, "#{missing_key.inspect} not found in score schemas"
           end
-          existing_subscore_keys = questionnaire.score_schemas.values.flat_map(&:sub_score_schemas).map(&:key)
+          existing_subscore_keys = questionnaire.score_schemas.values.flat_map(&:subscore_schemas).map(&:key)
           (subscore_keys - existing_subscore_keys).each do |missing_key|
             errors.add :subscore_keys, "#{missing_key.inspect} not found in subscore schemas"
           end

data/lib/quby/questionnaires/entities/question.rb

@@ -232,6 +232,7 @@ module Quby
             description: Quby::MarkdownParser.new(description).to_html,
             type: type,
             unit: unit,
+            size: size,
             hidden: hidden?,
             displayModes: display_modes,
             defaultInvisible: default_invisible,

data/lib/quby/questionnaires/entities/question_option.rb

@@ -26,6 +26,7 @@ module Quby
           @question    = question
           @value       = options[:value]
           @description = options[:description]
+          @context_free_description = options[:context_free_description]
           @questions   = []
           @inner_title = options[:inner_title]
           @hides_questions = options[:hides_questions] || []
@@ -48,11 +49,16 @@ module Quby
           false
         end
 
+        def context_free_description
+          @context_free_description || @description
+        end
+
         def as_json(options = {})
           {
             key: key,
             value: value,
             description: Quby::MarkdownParser.new(description).to_html,
+            context_free_description: Quby::MarkdownParser.new(context_free_description).to_html,
             questions: questions,
             innerTitle: inner_title,
             hidesQuestions: hides_questions,

data/lib/quby/questionnaires/entities/questionnaire.rb

@@ -51,6 +51,7 @@ module Quby
           @score_schemas = {}.with_indifferent_access
           @outcome_tables = []
           @check_score_keys_consistency = true
+          @lookup_tables = {}
         end
 
         attr_accessor :key
@@ -96,6 +97,7 @@ module Quby
 
         attr_accessor :outcome_tables
         attr_accessor :score_schemas
+        attr_accessor :lookup_tables
 
         delegate :question_hash, :input_keys, :answer_keys, :expand_input_keys, to: :fields
 
@@ -245,8 +247,8 @@ module Quby
           score_calculations[builder.key] = builder
         end
 
-        def add_score_schema(key, label, sub_schema_options)
-          schema = Entities::ScoreSchema.new(key: key, label: label, sub_score_schemas: sub_schema_options)
+        def add_score_schema(key, label, subschema_options)
+          schema = Entities::ScoreSchema.new(key: key, label: label, subscore_schemas: subschema_options)
           schema.valid?
           schema.errors.each do |attribute, message|
             errors.add("Score schema '#{key}'", "#{attribute} #{message}")

data/lib/quby/questionnaires/entities/questions/float_question.rb

@@ -5,6 +5,9 @@ module Quby
     module Entities
       module Questions
         class FloatQuestion < Question
+          def size
+            @size || 30
+          end
         end
       end
     end

data/lib/quby/questionnaires/entities/questions/integer_question.rb

@@ -5,6 +5,9 @@ module Quby
     module Entities
       module Questions
         class IntegerQuestion < Question
+          def size
+            @size || 30
+          end
         end
       end
     end

data/lib/quby/questionnaires/entities/questions/string_question.rb

@@ -6,7 +6,7 @@ module Quby
       module Questions
         class StringQuestion < Question
           def as_json(options = {})
-            super.merge(autocomplete: @autocomplete)
+            super.merge(autocomplete: @autocomplete, size: @size || 30)
           end
         end
       end

data/lib/quby/questionnaires/entities/questions/text_question.rb

@@ -6,7 +6,7 @@ module Quby
       module Questions
         class TextQuestion < Question
           def as_json(options = {})
-            super.merge(autocomplete: @autocomplete)
+            super.merge(autocomplete: @autocomplete, lines: lines, cols: cols)
           end
         end
       end

data/lib/quby/questionnaires/entities/score_schema.rb

@@ -15,23 +15,23 @@ module Quby
         attr_accessor :key
         # A label describing the general purpose of the score
         attr_accessor :label
-        # An array of SubScoreSchemas describing each key that can be returned in the result hash of a score.
-        attr_accessor :sub_score_schemas
+        # An array of SubscoreSchemas describing each key that can be returned in the result hash of a score.
+        attr_accessor :subscore_schemas
 
-        validates :key, :label, :sub_score_schemas, presence: true
-        validates :sub_score_schemas, 'quby/array_attribute_valid': true
+        validates :key, :label, :subscore_schemas, presence: true
+        validates :subscore_schemas, 'quby/array_attribute_valid': true
 
         def initialize(attributes)
           super(attributes)
-          initialize_sub_score_schemas
+          initialize_subscore_schemas
         end
 
-        def initialize_sub_score_schemas
-          self.sub_score_schemas = sub_score_schemas&.map { |suboptions| Entities::SubScoreSchema.new suboptions }
+        def initialize_subscore_schemas
+          self.subscore_schemas = subscore_schemas&.map { |suboptions| Entities::SubscoreSchema.new suboptions }
         end
 
         def export_key_labels
-          sub_score_schemas.map { |schema| [schema.export_key, schema.label] }.to_h.with_indifferent_access
+          subscore_schemas.map { |schema| [schema.export_key, schema.label] }.to_h.with_indifferent_access
         end
       end
     end

data/lib/quby/questionnaires/entities/{sub_score_schema.rb → subscore_schema.rb}

@@ -1,9 +1,9 @@
 module Quby
   module Questionnaires
     module Entities
-      # SubScoreSchema instances describe each key that could be returned in a score result hash
+      # SubscoreSchema instances describe each key that could be returned in a score result hash
 
-      class SubScoreSchema
+      class SubscoreSchema
         include ActiveModel::Model
 
         # The key this subscore has in the hash returned by the score

data/lib/quby/table_backend/range_tree.rb

@@ -1,35 +1,64 @@
 # frozen_string_literal: true
 
-# Create a value lookup tree from a headers array, a compare (type) array and a data array of arrays.
-# The #lookup method will try to find the data row where each of the comparison columns matches
-# the given parameters and return the value from the norm column.
+# A lookup tree to find values by multiple arguments.
 #
-# #initialize params:
-# headers: An array of column names
-# compare: An array of lookup types (string, float or range) for each column
-# data: An array of arrays containing the rows describing the mapping from the
-#   different lookup columns to the `norm` value.
+# Created by LookupTable from a csv file or by add_lookup_tree from dsl.
 #
-# The last column of the headers must be called 'norm' and
-# must have the 'float' type (in compare array).
+# Example tree:
+# Inhibitie:
+#   male:
+#     10...11:
+#       -Infinity...10: 39
+#       10...20: 42
+#     11...12:
+#       -Infinity...10: 40
+#       10...20: : 43
+#   female:
+#     10...11: 38
+#     ...
 #
-# String and float types are used to make an exact match.
-# A range is always a range between two floats where the range is between
-# the low value (inclusive) and the high value (exclusive),
-# written as 4:5 (low:high). These boundaries can be given as floats or
-# integers, but internally they are always treated as a floats.
-# The low and high values of a range cannot be equal.
-# Use minfinity or infinity to create infinite ranges.
+# with levels:
+# ['scale', 'gender', 'age', 'raw', 'norm']
+#
+# will allow a lookup like:
+# lookup({age: 10, raw: 5, scale: 'Inhibitie', gender: 'male'})` => 39
+#
+# Keys in the tree will be matched by hash lookup of the parameter value with the following exeptions:
+# floats: can be found by integer as well
+# strings: can be found by symbol as well.
+# enumerables: will find the first key for which `include?(param)` returns true.
 module Quby::TableBackend
   class RangeTree
-    def initialize(headers, compare, data)
-      @data = data
-      @headers = headers
-      @compare = compare
+    # @param tree [Hash<>] hash of hashes leading from parameter values/ranges to a result.
+    # @params levels [Array<String>] the argument name for each level of the tree.
+    def initialize(levels:, tree:)
+      @levels = levels
+      @tree = tree
+    end
+
+    # load csv data into a tree.
+    # each row is a path through the tree.
+    # String and float types are used to make an exact match.
+    # A range is always a range between two floats where the range is between
+    # the low value (inclusive) and the high value (exclusive),
+    # written as 4:5 (low:high). These boundaries can be given as floats or
+    # integers, but internally they are always treated as a floats.
+    # The low and high values of a range cannot be equal.
+    # Use minfinity or infinity to create infinite ranges.
+    #
+    # @params levels [Array<String>] An array of column names
+    # @param compare [Array<String>]An array of lookup types (string, float or range) for each column
+    # @param data [Array<Array<>>] The rows describing a path through the tree.
+    def self.from_csv(levels:, compare:, data:)
+      tree = data.each_with_object({}) do |row, tree|
+        add_to_tree(tree, row, levels, compare)
+      end
+      new(levels: levels, tree: tree)
     end
 
+
     # Given a parameters hash that contains a value or range for every
-    # header, find and return the normscore.
+    # level in the tree, find and return the normscore.
     # ie. `lookup({age: 10, raw: 5, scale: 'Inhibitie', gender: 'male'})` => 39
     def lookup(parameters)
       validate_parameters(parameters)
@@ -38,67 +67,60 @@ module Quby::TableBackend
 
     private
 
-    # Build a lookup tree (hash) from the csv input data.
-    # Starting with the first column, it returns a hash with entries
-    # for every value in the column. The value for such an entry
-    # is a hash with all entries for the next column, etc. Example:
-    # Inhibitie:
-    #   male:
-    #     10...11:
-    #       -Infinity...10:
-    #         39: 39
-    #       10...20:
-    #         42: 42
-    #     11...12:
-    #       -Infinity...10:
-    #         40: 40
-    #       10...20:
-    #         43: 43
-    #   female:
-    #     10...11:
-    #       etc. etc. etc.
-    def tree
-      @tree ||= @data.each_with_object({}) do |row, current_node|
-        row.each_with_index do |v, idx|
-          key =
-            case @compare[idx]
-            when 'string' then v.to_s
-            when 'float' then parse_float(v)
-            when 'range' then create_range(v)
+    def self.add_to_tree(tree, (value, *path), (level, *levels), (compare, *compares))
+      key = case compare
+            when 'string' then value.to_s
+            when 'float' then parse_float(value)
+            when 'range' then create_range(value)
             end
 
-          if @headers[idx] == 'norm'
-            current_node[key] = key
-          else
-            current_node[key] ||= {}
-          end
-          current_node = current_node[key]
-        end
+      if levels.empty?
+        return key
+      end
+
+      tree.merge! key => add_to_tree(tree[key] || {}, path, levels, compares)
+    end
+
+    def self.create_range(value)
+      min, max = value.split(':').map { |val| parse_float(val) }
+      fail 'Cannot create range between two equal values' if min == max
+      (min...max)
+    end
+
+    def self.parse_float(value)
+      case value
+      when 'infinity'  then Float::INFINITY
+      when 'minfinity' then -Float::INFINITY
+      else Float(value)
       end
     end
 
     # All parameters must be present to do a lookup but the order does not matter.
     def validate_parameters(parameters)
-      if (@headers - ['norm']).sort != parameters.keys.map(&:to_s).sort
+      if @levels[0...-1].sort != parameters.keys.map(&:to_s).sort
         fail 'Incompatible score parameters found'
       end
     end
 
     # Reduce the tree (a hash) to a normscore by looking up the correct values/ranges
-    # for each column in @headers.
+    # for each column in @levels.
     # Returns a single normscore when found.
     # Returns nil and reports to AppSignal when normscore could not be found.
     def lookup_score(parameters)
-      (@headers - ['norm']).each_with_index.reduce(tree) do |acc, (header, idx)|
-        case @compare[idx]
-        when 'string'
-          acc[parameters[header.to_sym].to_s]
-        when 'float'
-          acc[parameters[header.to_sym].to_f]
-        when 'range'
-          acc.select { |k, _v| k.cover?(parameters[header.to_sym].to_f) }.values.first
+      @levels[0...-1].reduce(@tree) do |node, level|
+        value = parameters[level.to_sym]
+        # binding.pry
+        case node.first.first # all keys for one level are the same type.
+        when String
+          node[value.to_s] # from csv it's always a string, but should also allow symbol param.
+        when Float
+          node[value.to_f] # from csv it's always a float, but should also allow int param.
+        when Enumerable
+          node.find { |k, _v| k.include? value }.last
+        else
+          node[value]
         end
-      end.values.first # normscore is a hash with a single element, get the value.
+      end
     rescue StandardError => exception
       # Normscore could not be found for the given parameters.
       if defined? Roqua::Support::Errors
@@ -106,19 +128,5 @@ module Quby::TableBackend
       end
       nil
     end
-
-    def create_range(value)
-      min, max = value.split(':').map { |val| parse_float(val) }
-      fail 'Cannot create range between two equal values' if min == max
-      (min...max)
-    end
-
-    def parse_float(value)
-      case value
-      when 'infinity'  then Float::INFINITY
-      when 'minfinity' then -Float::INFINITY
-      else Float(value)
-      end
-    end
   end
 end