quby 4.0.2 → 5.0.0.pre4

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

data/spec/quby/questionnaires/dsl/calls_custom_methods_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Quby::Questionnaires::DSL
-  describe CallsCustomMethods do
-
-    class TestCustomMethod
-      prepend CallsCustomMethods
-
-      attr_reader :test
-      def initialize(*args)
-        @test = 'attribute'
-      end
-    end
-
-    let(:custom_methods) { {custom: -> { 'custom_method' }} }
-    let(:test_object) { TestCustomMethod.new(custom_methods: custom_methods) }
-
-    describe 'prepending' do
-      it 'does not skip the actual initializer' do
-        expect(test_object.test).to eq('attribute')
-      end
-    end
-
-    describe '#method_missing' do
-      it 'allows the class to receive messages defined in custom_methods' do
-        expect(test_object.custom).to eq('custom_method')
-      end
-    end
-
-    describe '#respond_to_missing?' do
-      it 'also considers custom methods' do
-        expect(test_object.send(:respond_to_missing?, :custom)).to eq(true)
-      end
-    end
-  end
-end

data/spec/quby/questionnaires/dsl/charting/bar_chart_builder_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Quby::Questionnaires::DSL
-  describe BarChartBuilder do
-    it_behaves_like ChartBuilder
-
-    let(:questionnaire) { double(key: 'questionnaire_key') }
-
-    it 'makes a bar chart' do
-      expect(dsl { }).to be_an_instance_of(::Quby::Questionnaires::Entities::Charting::BarChart)
-    end
-
-    def dsl(key = :test, options = {}, &block)
-      builder = BarChartBuilder.new(questionnaire, key, options)
-      builder.build(&block)
-    end
-
-    it 'sets y-axis range' do
-      expect(dsl { range 0..40 }.y_range).to eq (0..40)
-    end
-
-    it 'sets y-axis tick interval' do
-      expect(dsl { tick_interval 1 }.tick_interval).to eq 1
-    end
-
-    it 'sets plotlines' do
-      plotlines =
-        dsl do
-          plotline 40, :orange
-          plotline 60, :red
-        end.plotlines
-
-      expect(plotlines).to eq [
-        {value: 40, color: :orange, width: 1, zIndex: 3},
-        {value: 60, color: :red, width: 1, zIndex: 3}
-      ]
-    end
-  end
-end

data/spec/quby/questionnaires/dsl/charting/chart_builder_spec.rb

@@ -1,127 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Quby::Questionnaires::DSL
-  describe ChartBuilder do
-
-    let(:plottable_key) { :some_key }
-    let(:plottable) { Quby::Questionnaires::Entities::ScoreCalculation.new plottable_key, {} }
-    let(:questionnaire) do
-      double(key: 'questionnaire_key').tap do |questionnaire|
-        allow(questionnaire).to receive(:find_plottable).with(plottable_key).and_return plottable
-      end
-    end
-    let(:chart_plottables) { [] }
-    let(:chart_class) { Quby::Questionnaires::Entities::Charting::Chart }
-    before { ChartBuilder.set_chart_class(chart_class) }
-    let(:chart_builder) { ChartBuilder.new questionnaire, 'chart_key' }
-
-    def dsl(key = :test, options = {}, &block)
-      builder = ChartBuilder.new(questionnaire, key, options)
-      builder.build(&block)
-    end
-
-    describe '#plot' do
-      it 'fetches a plottable by key from the questionnaire' do
-        expect(questionnaire).to receive(:find_plottable).with(plottable_key)
-        chart_builder.plot plottable_key
-      end
-
-      it 'creates a plottable with the options merged into the plottable options' do
-        allow(plottable).to receive(:options).and_return({some: 'options', other: 'options'})
-        expect(Quby::Questionnaires::Entities::Charting::Plottable).to receive(:new)
-          .with(plottable.key,
-                some: 'different_options',
-                other: 'options',
-                questionnaire_key: 'questionnaire_key')
-        chart_builder.plot plottable_key, some: 'different_options'
-      end
-
-      it 'sets the label from a question title when no label is present' do
-        plottable = Quby::Questionnaires::Entities::Question.new plottable_key, title: 'some_title'
-        expect(questionnaire).to receive(:find_plottable).with(plottable_key).and_return plottable
-        expect(Quby::Questionnaires::Entities::Charting::Plottable).to receive(:new)
-          .with(plottable_key, questionnaire_key: 'questionnaire_key', label: 'some_title')
-        chart_builder.plot plottable_key
-      end
-
-      it 'does not set the label when it is given in the options' do
-        plottable = Quby::Questionnaires::Entities::Question.new plottable_key, title: 'some_title'
-        expect(questionnaire).to receive(:find_plottable).with(plottable_key).and_return plottable
-        expect(Quby::Questionnaires::Entities::Charting::Plottable).to receive(:new)
-          .with(plottable_key, questionnaire_key: 'questionnaire_key', label: 'some_label')
-        chart_builder.plot plottable_key, label: 'some_label'
-      end
-    end
-
-    describe '#y_categories' do
-      it 'assigns y_categories' do
-        categories = %w(Bad Great Best)
-        chart_builder.y_categories categories
-        expect(chart_builder.build { }.y_categories).to eq(categories)
-      end
-    end
-
-    describe '#plotband' do
-      it 'can set plotbands' do
-        plotbands =
-          dsl do
-            plotband 2, 5, :yellow
-            plotband 5, 8, :red
-          end.plotbands
-  
-        expect(plotbands).to eq [
-          {from: 2, to: 5, color: :yellow},
-          {from: 5, to: 8, color: :red}
-        ]
-      end
-    end
-
-    describe '#y_range_categories' do
-      it 'sets RangeCategories.new(*parameters).as_range_hash to the chart y_range_categories' do
-        expect(RangeCategories).to receive(:new).with(0, 'Zeer laag', 30).and_return(double(as_range_hash: 'foo'))
-        chart_builder.y_range_categories 0, 'Zeer laag', 30
-        expect(chart_builder.build { }.y_range_categories).to eq('foo')
-      end
-
-      it 'converts the parameters to a range hash' do
-        expected_categories = {(0.0...30.0) => "Zeer laag", (30.0...40.0) => "Laag", (40.0...60.0) => "Gemiddeld",
-                               (60.0...70.0) => "Hoog", (70.0..100.0) => "Zeer hoog"}
-        chart_builder.y_range_categories 0, 'Zeer laag',
-                                         30, 'Laag',
-                                         40, 'Gemiddeld',
-                                         60, 'Hoog',
-                                         70, 'Zeer hoog', 100
-        expect(chart_builder.build { }.y_range_categories).to eq(expected_categories)
-      end
-    end
-
-    describe '#range' do
-      it 'assigns y_range' do
-        chart_builder.range 0..5
-        expect(chart_builder.build { }.y_range).to eq(0..5)
-      end
-    end
-    describe '#validate' do
-      describe 'when there is no range defined but y_categories are present' do
-        it 'uses the 0..y_categories.count-1 as a range' do
-          chart_builder.y_categories %w(Bad Great Best)
-          expect(chart_builder.build { }.y_range).to eq(0..2)
-        end
-      end
-      describe 'when range and y_categories are present' do
-        it 'raises if the range does not correspond to the y_categories length' do
-          chart_builder.range 0..3
-          chart_builder.y_categories %w(Bad Great Best)
-          expect { chart_builder.build { } }.to raise_error(ArgumentError)
-        end
-        it 'does not raise if the range matches the y_categories' do
-          chart_builder.range 0..2
-          chart_builder.y_categories %w(Bad Great Best)
-          expect { chart_builder.build { } }.not_to raise_error
-        end
-      end
-    end
-  end
-end

data/spec/quby/questionnaires/dsl/charting/line_chart_builder_spec.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Quby::Questionnaires::DSL
-  describe LineChartBuilder do
-    it_behaves_like ChartBuilder
-
-    let(:questionnaire) { double(key: 'questionnaire_key') }
-
-    it 'sets y-axis label' do
-      expect(dsl { y_axis_label 'Label' }.y_label).to eq 'Label'
-    end
-
-    it 'sets y-axis range' do
-      expect(dsl { range 0..40 }.y_range).to eq (0..40)
-    end
-
-    it 'sets y-axis tick interval' do
-      expect(dsl { tick_interval 1 }.tick_interval).to eq 1
-    end
-
-    it 'raises when y-axis range is not specified' do
-      expect { dsl(:test, {}) { } }.to raise_error(/no range specified/)
-    end
-
-    it 'sets tonality' do
-      expect(dsl { tonality :higher_is_better }.tonality).to eq :higher_is_better
-    end
-
-    it 'sets baseline to constant value' do
-      expect(dsl { baseline 5 }.baseline.call(1, :male)).to eq 5.0
-    end
-
-    it 'sets baseline to proc' do
-      expect(dsl { baseline { |age, gender| age } }.baseline.call(5, :male)).to eq(5.0)
-      expect { dsl { baseline { |age| age } } }.to raise_error(ArgumentError, /must take two arguments/)
-    end
-
-    it 'raises error if not giving baseline value or block' do
-      expect { dsl { baseline } }.to raise_error(ArgumentError, /either value or a block/)
-      expect { dsl { baseline(5.0) { |age, gender| age } } }.to raise_error(ArgumentError, /either value or a block/)
-    end
-
-    it 'sets clinically relevant change' do
-      expect(dsl { clinically_relevant_change 5 }.clinically_relevant_change).to eq 5.0
-    end
-
-    it 'makes a line chart' do
-      expect(dsl { }).to be_an_instance_of(::Quby::Questionnaires::Entities::Charting::LineChart)
-    end
-
-    def dsl(key = :test, options = {y_range: (0..20)}, &block)
-      builder = LineChartBuilder.new(questionnaire, key, options)
-      builder.build(&block)
-    end
-  end
-end

data/spec/quby/questionnaires/dsl/charting/radar_chart_builder_spec.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Quby::Questionnaires::DSL
-  describe RadarChartBuilder do
-    it_behaves_like ChartBuilder
-
-    let(:questionnaire) { double(key: 'questionnaire_key') }
-
-    it 'makes a radar chart' do
-      expect(dsl { }).to be_an_instance_of(::Quby::Questionnaires::Entities::Charting::RadarChart)
-    end
-
-    it 'sets y-axis range' do
-      expect(dsl { range 0..40 }.y_range).to eq (0..40)
-    end
-
-    it 'sets y-axis tick interval' do
-      expect(dsl { tick_interval 1 }.tick_interval).to eq 1
-    end
-
-    it 'sets plotlines' do
-      plotlines =
-        dsl {
-          plotline 40, :orange
-          plotline 60, :red
-        }.plotlines
-
-      expect(plotlines).to eq [
-        {value: 40, color: :orange, width: 1, zIndex: 3},
-        {value: 60, color: :red, width: 1, zIndex: 3}
-      ]
-    end
-
-    def dsl(key = :test, options = {}, &block)
-      builder = RadarChartBuilder.new(questionnaire, key, options)
-      builder.build(&block)
-    end
-  end
-end

data/spec/quby/questionnaires/dsl/helpers_spec.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Quby::Questionnaires::DSL
-  describe Helpers do
-    let(:questionnaire) { Quby::Questionnaires::Entities::Questionnaire.new("example") }
-    let(:builder) { QuestionnaireBuilder.new(questionnaire) }
-
-    # this helper has some extra tests to check that helpers are included everywhere
-    describe '.image_tag' do
-      let(:expected_html) { %r{<p><img alt=\"Happy face\" src=\"/assets/quby/happy-face.*.png\" /></p>} }
-
-      it 'builds image tags outside of panels' do
-        dsl { text image_tag('quby/happy-face.png') }
-        expect(questionnaire.panels.first.items.first.text).to match(expected_html)
-      end
-
-      it 'builds image tags inside of panels' do
-        dsl do
-          panel do
-            text image_tag('quby/happy-face.png')
-          end
-        end
-
-        expect(questionnaire.panels.first.items.first.text).to match(expected_html)
-      end
-
-      it 'builds image tags inside of questions' do
-        # this one is different because markdown/maruku transforms double quotes into single quotes
-        # and question descriptions are not passed through markdown/maruku
-        expected_html = %r{<img .*?src="/assets/quby/happy-face.*.png"}
-        dsl do
-          panel do
-            question :v_1, type: :radio do
-              option :a1, description: image_tag('quby/happy-face.png')
-            end
-          end
-        end
-        expect(questionnaire.panels.first.items.first.options.first.description).to match(expected_html)
-      end
-    end
-
-    describe 'video_tag' do
-      it 'makes a text item with a html 5 video player for the given video source urls' do
-        html = builder.video_tag 'https://www.example.com/video.mp4', 'https://www.example.com/video.webm'
-
-        expect(html).to \
-          eq("<video width=\"100%\" preload=\"none\" controls=\"controls\"><source src=\"https://www.example.com/video.mp4\" type=\"video/mp4\">\
-<source src=\"https://www.example.com/video.webm\" type=\"video/webm\">\
-Helaas kan je browser dit filmpje niet afspelen. Probeer een andere browser te gebruiken.</video>")
-      end
-
-      it 'can add a autoplay attribute (with muted added to allow chrome autoplay)' do
-        html = builder.video_tag 'https://www.example.com/video.mp4', autoplay: true
-
-        expect(html).to \
-          include('<video width="100%" preload="none" autoplay="autoplay" muted="muted" controls="controls">')
-      end
-
-      it 'can add a loop attribute' do
-        html = builder.video_tag 'https://www.example.com/video.mp4', loop: true
-
-        expect(html).to \
-          include('<video width="100%" preload="none" loop="loop" controls="controls">')
-      end
-
-      it 'can add a poster url' do
-        html = builder.video_tag 'https://www.example.com/video.mp4', poster: 'https://www.example.com/poster.jpg'
-
-        expect(html).to \
-          include('<video width="100%" preload="none" poster="https://www.example.com/poster.jpg" controls="controls">')
-      end
-    end
-
-    def dsl(&block)
-      builder.instance_eval(&block)
-    end
-  end
-end