quby 5.0.0.pre2 → 5.0.0.pre3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d19ac693a1e2e0530ead24bd6154f8fb6bd29b7d12cac079cd605d3b79329ec
-  data.tar.gz: d73d97a84f5b8d3fefd5655d3dc6663a069f4519c42f4cef3121b955630480f1
+  metadata.gz: 2ff840130087f113cabb79c809f8046fd434993e436da3efedcc397597c43979
+  data.tar.gz: f8b6977b5802b86e676d06fa13771a70919acab2538dbfbfe8a2a5808211da78
 SHA512:
-  metadata.gz: a9e02fcd7b0116a1c38a34b611a8e460cfa052f83b6b977bfcf67ffb8a1851ac15b2394294266bc97da6892fd9f96edc105312a021dd708dffca8c23aa76d272
-  data.tar.gz: 8cf3fb6290472a64a730747bd2b5824a952d012c679645d1ddc907754677e94c2dce93ee8b6892d8f4decc1ce13c81a3cba5debd05a8d7afaac3db292d15f832
+  metadata.gz: 178d14bdac8b8fd8b2ac1e45cb6dfdd8b22c2d5270d51a832c6c01e5eb1207e4ad498a448ddb2908c55f029c6d9db35e1c507f473548112c72bfa45deb25a56e
+  data.tar.gz: c7ea63e6170b68d8b0fc48340a9f5db3333908e9fb08086a0557670b89c77e50f4010565692038f7acc8c5c53a03e312c3fdc8416a5515f28c5b157056b3b9c0

data/README.markdown

@@ -27,7 +27,6 @@ and where it can store its answers.
 ```ruby
 Quby.questionnaire_repo      = Quby::Questionnaires::Repos::DiskRepo.new(Rails.root.join("db/questionnaires/definitions"))
 Quby.answer_repo             = Quby::Answers::Repos::MongoidRepo.new
-Quby.lookup_table_repo       = Quby::LookupTableRepo::Disk.new(Rails.root.join("db/questionnaires/lookup_tables"))
 Quby::Settings.shared_secret = ENV["QUBY_SHARED_SECRET"]
 ```
 

data/lib/quby.rb

@@ -38,14 +38,6 @@ module Quby
       @questionnaires_api = nil
     end
 
-    def lookup_table_repo=(repo)
-      @lookup_table_repo = repo
-    end
-
-    def lookup_table_repo
-      @lookup_table_repo  || fail("Quby does not have its lookup table repo (Quby.lookup_table_repo) configured.")
-    end
-
     def fixtures_path
       File.expand_path File.join('..', '..', 'spec', 'fixtures'), __FILE__
     end
@@ -79,7 +71,7 @@ module Quby
 end
 
 require 'quby/settings'
+require 'quby/table_backend/range_tree'
 require 'quby/questionnaires'
 require 'quby/answers'
-require 'quby/engine'
-require 'quby/lookup_table_repo'
+require 'quby/engine'

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

@@ -82,7 +82,7 @@ module Quby
         attr_accessor :extra_question_values
         attr_accessor :extra_failed_validations
 
-        def initialize(_id: nil, questionnaire_id: nil, questionnaire_key: nil,
+        def initialize(_id: nil, questionnaire_id: nil, questionnaire_key: nil, questionnaire: nil,
           raw_params: nil, value: nil, patient_id: nil, patient: nil,
           token: nil, active: true, test: false, created_at: nil, updated_at: nil,
           started_at: nil, completed_at: nil, outcome: nil, outcome_generated_at: nil,
@@ -111,6 +111,8 @@ module Quby
           self.import_notes = import_notes || {}
           self.flags = flags
           self.textvars = textvars
+
+          @questionnaire = questionnaire
         end
 
         def id
@@ -162,7 +164,7 @@ module Quby
 
         # Faux belongs_to :questionnaire
         def questionnaire
-          Quby.questionnaires.find(questionnaire_key)
+          @questionnaire ||= Quby.questionnaires.find(questionnaire_key)
         end
 
         def mark_completed(start_time)

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

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

data/lib/quby/engine.rb

@@ -15,7 +15,6 @@ require 'jquery-ui-rails'
 require 'compass-blueprint'
 
 require 'susy'
-require 'quby/lookup_table'
 require 'quby/range_categories'
 require 'quby/pdf_renderer'
 

data/lib/quby/questionnaires/dsl.rb

@@ -3,14 +3,16 @@
 module Quby
   module Questionnaires
     module DSL
+      # Deprecated, precompile elsewhere and use from_json
       def self.build_from_definition(definition)
-        compiled = Quby::Compiler.compile(definition.key, definition.sourcecode, seeds: [], path: definition.path)
+        compiled = Quby::Compiler.compile(definition.key, definition.sourcecode, seeds: [], lookup_tables: {}, path: definition.path)
         data = JSON.parse(compiled[:outputs][:quby_frontend_v1].content)
         Deserializer.from_json(data)
       end
 
+      # Deprecated, precompile elsewhere and use from_json
       def self.build(key, sourcecode = nil, timestamp: nil, &block)
-        compiled = Quby::Compiler.compile(key, sourcecode, seeds: [], &block)
+        compiled = Quby::Compiler.compile(key, sourcecode, seeds: [], lookup_tables: {}, &block)
         data = JSON.parse(compiled[:outputs][:quby_frontend_v1].content)
         Deserializer.from_json(data)
       end

data/lib/quby/table_backend/range_tree.rb

@@ -2,8 +2,6 @@
 
 # A lookup tree to find values by multiple arguments.
 #
-# Created by LookupTable from a csv file or by add_lookup_tree from dsl.
-#
 # Example tree:
 # Inhibitie:
 #   male:
@@ -36,27 +34,6 @@ module Quby::TableBackend
       @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
     # level in the tree, find and return the normscore.
     # ie. `lookup({age: 10, raw: 5, scale: 'Inhibitie', gender: 'male'})` => 39
@@ -67,34 +44,6 @@ module Quby::TableBackend
 
     private
 
-    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 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 @levels[0...-1].sort != parameters.keys.map(&:to_s).sort

data/lib/quby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Quby
-  VERSION = "5.0.0.pre2"
+  VERSION = "5.0.0.pre3"
 end

data/spec/quby/answers/services/score_calculator_spec.rb

@@ -485,26 +485,16 @@ module Quby::Answers::Services
       let(:calculator) { ScoreCalculator.new(questionnaire: questionnaire, values: {}, timestamp: timestamp) }
       let(:table_double) { double.as_null_object }
 
-      before do
-        allow(Quby::LookupTable).to receive(:new).and_return(table_double)
-      end
-
-      it 'instantiates a new Quby::Answers::Entities::LookupTable if the table_hash cache does not know the key' do
+      it 'raises an error if lookup table cannot be found' do
         expect(questionnaire.lookup_tables).to be_empty
-        calculator.table_lookup :test_table, score: 1
-        expect(questionnaire.lookup_tables[:test_table]).to be(table_double)
-      end
-
-      it 'uses the memoized lookuptable if there is a cache hit' do
-        calculator.table_lookup :test_table, score: 1
-        expect(table_double).to receive(:lookup)
-        calculator.table_lookup :test_table, score: 1
+        expect { calculator.table_lookup :test_table, score: 1 }.to raise_error(KeyError)
       end
 
       it 'looks up the given parameters on the given table' do
+        questionnaire.lookup_tables[:test_table] = table_double
         parameters = {score: 1}
-        expect(table_double).to receive(:lookup).with parameters
         calculator.table_lookup :test_table, parameters
+        expect(table_double).to have_received(:lookup).with parameters
       end
 
       context 'with add_lookup_tree inside dsl' do

data/spec/quby/table_backend/range_tree_spec.rb

@@ -1,17 +1,22 @@
 require 'spec_helper'
 
 describe Quby::TableBackend::RangeTree do
-  let(:csv_key) { 'test' }
-  let(:data) { Quby.lookup_table_repo.retrieve(csv_key) }
-  let(:tree) { described_class.from_csv(levels: data.shift, compare: data.shift, data: data) }
-
-  describe '#from_csv' do
-    context 'invalid csv data' do
-      let(:csv_key) { 'bad_range' }
-      it 'fails when csv data contains a range between two equal values' do
-        expect { tree }.to raise_error(RuntimeError, 'Cannot create range between two equal values')
-      end
-    end
+  let(:tree) do
+    described_class.new(
+      levels: ["scale", "gender", "age", "raw", "norm"],
+      tree: {
+        "Inhibitie" => {
+          "male" => {
+            (10.0...11.0) => {
+              (-Float::INFINITY...10.0) => 39.0,
+              (10.0...20.0) => 42.0,
+              (20.0...30.0) => 71.0,
+              (30.0...Float::INFINITY) => 75.0
+            }
+          }
+        }
+      }
+    )
   end
 
   describe '#lookup' do
@@ -68,7 +73,23 @@ describe Quby::TableBackend::RangeTree do
     end
 
     describe 'definition containing range with float values' do
-      let(:csv_key) { 'float_test' }
+      let(:tree) do
+        described_class.new(
+          levels: ["scale", "gender", "age", "raw", "norm"],
+          tree: {
+            "Inhibitie" => {
+              "male" => {
+                (10.0...11.0) => {
+                  (-Float::INFINITY...10.5) => 39.0,
+                  (10.5...20.1) => 42.0,
+                  (20.1...30.7) => 71.0,
+                  (30.7...Float::INFINITY) => 75.0
+                }
+              }
+            }
+          }
+        )
+      end
 
       it 'returns the correct scores' do
         params = {age: 10, raw: 15.8, scale: 'Inhibitie', gender: 'male'}
@@ -80,7 +101,12 @@ describe Quby::TableBackend::RangeTree do
     end
 
     describe 'definition containing float values' do
-      let(:csv_key) { 'test2' }
+      let(:tree) do
+        described_class.new(
+          levels: ["scale", "raw", "norm"],
+          tree: {"Inhibitie" => {15.0=>39.0, 16.0=>42.0, 17.0=>71.0, 18.0=>75.0}}
+        )
+      end
 
       it 'returns the correct scores when using integers in lookup path' do
         params = {scale: 'Inhibitie', raw: 17}

data/spec/spec_helper.rb

@@ -94,6 +94,5 @@ RSpec.configure do |config|
   config.before(:each) do
     Quby.questionnaire_repo = Quby::Questionnaires::Repos::DiskRepo.new(Quby.fixtures_path)
     Quby.answer_repo = Quby::Answers::Repos::MemoryRepo.new
-    Quby.lookup_table_repo = Quby::LookupTableRepo::Disk.new(Rails.root.join('..', 'fixtures', 'lookup_tables'))
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: quby
 version: !ruby/object:Gem::Version
-  version: 5.0.0.pre2
+  version: 5.0.0.pre3
 platform: ruby
 authors:
 - Marten Veldthuis
@@ -11,7 +11,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-27 00:00:00.000000000 Z
+date: 2020-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -750,8 +750,6 @@ files:
 - lib/quby/answers/specs/api_specs.rb
 - lib/quby/answers/specs/repo_specs.rb
 - lib/quby/engine.rb
-- lib/quby/lookup_table.rb
-- lib/quby/lookup_table_repo.rb
 - lib/quby/markdown_parser.rb
 - lib/quby/pdf_renderer.rb
 - lib/quby/questionnaires.rb
@@ -810,7 +808,6 @@ files:
 - spec/active_model_modules/type_validator_spec.rb
 - spec/benchmarks/answer_instantiation_speed_spec.rb
 - spec/benchmarks/large_questionnaire_spec.rb
-- spec/benchmarks/load_normscore_csv.rb
 - spec/controllers/quby/answers_controller/authorize_with_hmac_spec.rb
 - spec/controllers/quby/answers_controller/authorize_with_id_from_session_spec.rb
 - spec/controllers/quby/answers_controller_spec.rb
@@ -6380,8 +6377,6 @@ files:
 - spec/quby/answers/services/text_transformation_spec.rb
 - spec/quby/answers/services/updates_answers_spec.rb
 - spec/quby/i18n_spec.rb
-- spec/quby/lookup_table_repo_spec.rb
-- spec/quby/lookup_table_spec.rb
 - spec/quby/markdown_parser_spec.rb
 - spec/quby/pdf_renderer_spec.rb
 - spec/quby/questionnaires/deserializer/questionnaire_spec.rb
@@ -6521,10 +6516,8 @@ test_files:
 - spec/quby/answers/entities/score_spec.rb
 - spec/quby/answers/entities/patient_spec.rb
 - spec/quby/answers/entities/answer_spec.rb
-- spec/quby/lookup_table_spec.rb
 - spec/quby/pdf_renderer_spec.rb
 - spec/quby/markdown_parser_spec.rb
-- spec/quby/lookup_table_repo_spec.rb
 - spec/spec.opts
 - spec/features/hiding_questions_spec.rb
 - spec/features/javascript_question_dependencies_spec.rb
@@ -12060,7 +12053,6 @@ test_files:
 - spec/support/validation_helpers.rb
 - spec/support/feature_helpers.rb
 - spec/benchmarks/large_questionnaire_spec.rb
-- spec/benchmarks/load_normscore_csv.rb
 - spec/benchmarks/answer_instantiation_speed_spec.rb
 - spec/javascripts/ajax_callbacks_spec.coffee
 - spec/javascripts/init_questions_spec.coffee

data/lib/quby/lookup_table.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'quby/table_backend/range_tree'
-
-module Quby
-  class LookupTable
-    attr_accessor :key
-
-    def initialize(key)
-      @key = key
-    end
-
-    def backing
-      return @backing if @backing.present?
-      all_data = data
-      headers = all_data.shift
-      compare = all_data.shift
-      @backing = Quby::TableBackend::RangeTree.from_csv(levels: headers, compare: compare, data: all_data)
-    end
-
-    def lookup(parameters)
-      backing.lookup(parameters)
-    end
-
-    def data
-      Quby.lookup_table_repo.retrieve(key)
-    end
-  end
-end

data/lib/quby/lookup_table_repo.rb

@@ -1,24 +0,0 @@
-require 'pathname'
-require 'csv'
-
-module Quby
-  module LookupTableRepo
-    def self.validate_key(key)
-      raise 'invalid key' unless key =~ /\A[a-z][a-z_0-9]{1,50}\z/
-    end
-
-    class Disk
-      attr_reader :disk_table_root
-
-      def initialize(disk_table_root)
-        @disk_table_root = Pathname.new(disk_table_root)
-      end
-
-      def retrieve(key)
-        Quby::LookupTableRepo.validate_key(key)
-        path = disk_table_root.join(key + '.csv')
-        CSV.read(path, col_sep: ';', skip_blanks: true)
-      end
-    end
-  end
-end

data/spec/benchmarks/load_normscore_csv.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-feature 'Load normscore csv file', benchmark: true do
-  it 'loads a csv file' do
-    10.times do
-      Quby.lookup_table_repo.retrieve('test')
-    end
-  end
-
-  it 'builds a tree' do
-    data = Quby.lookup_table_repo.retrieve('test')
-    10.times do
-      Quby::TableBackend::RangeTree.new(data).send :tree
-    end
-  end
-end

data/spec/quby/lookup_table_repo_spec.rb

@@ -1,20 +0,0 @@
-require 'spec_helper'
-
-describe Quby::LookupTableRepo::Disk do
-  subject { Quby.lookup_table_repo }
-
-  it 'Quby.lookup_table_repo is a disk repo by default' do
-    expect(subject).to be_an_instance_of(described_class)
-  end
-
-  describe '#retrieve' do
-    it 'reads the csv file' do
-      expect(CSV).to receive(:read).and_call_original
-      subject.retrieve 'test'
-    end
-
-    it 'fails when csv file is not found' do
-      expect { subject.retrieve 'not_there' }.to raise_error(Errno::ENOENT)
-    end
-  end
-end

data/spec/quby/lookup_table_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Quby
-  describe LookupTable do
-    let(:table) { described_class.new('test') }
-    let(:fake_backing) { double(:"present?" => true).as_null_object }
-
-    describe '#lookup' do
-      it 'passes lookup calls on to the backing' do
-        expect(Quby::TableBackend::RangeTree).to receive(:from_csv).and_return(fake_backing)
-        parameters = {a: 1}
-        expect(table.backing).to receive(:lookup).with(parameters)
-        table.lookup(parameters)
-      end
-
-      it 'initializes the disktree lazily' do
-        headers = double
-        compare = double
-        data = double
-        data_double = [headers, compare, data]
-        table
-        expect_any_instance_of(described_class).to receive(:data).and_return(data_double)
-        expect(Quby::TableBackend::RangeTree).to receive(:from_csv).with(levels: headers, compare: compare, data:[data]).and_return(fake_backing)
-        table.lookup(some: :thing)
-      end
-    end
-
-    describe '#data' do
-      it 'calls Quby.lookup_table_repo.retrieve(table.key)' do
-        table
-        expect(Quby.lookup_table_repo).to receive(:retrieve).with(table.key)
-        table.data
-      end
-    end
-  end
-end