quby 4.0.2 → 5.0.0.pre4

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/lib/quby/questionnaires/dsl/base.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'quby/questionnaires/dsl/helpers'
-require 'quby/questionnaires/dsl/calls_custom_methods'
-
-module Quby
-  module Questionnaires
-    module DSL
-      class Base
-        include Helpers
-
-        def self.build(*args, &block)
-          builder = new(*args)
-          builder.instance_eval(&block) if block
-          builder.build
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module Quby
-  module Questionnaires
-    module DSL
-      module CallsCustomMethods
-        attr_reader :custom_methods
-
-        def initialize(*args)
-          options = args.last.is_a?(::Hash) ? args.last : {}
-          @custom_methods = options[:custom_methods] || {}
-          super
-        end
-
-        def method_missing(method_sym, *args, &block)
-          if @custom_methods.key? method_sym
-            instance_exec(*args, &custom_methods[method_sym])
-          else
-            super
-          end
-        end
-
-        def respond_to_missing?(method_name, include_private = false)
-          custom_methods.key?(method_name) || super
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'quby/questionnaires/entities/charting/bar_chart'
-require_relative 'chart_builder'
-
-module Quby
-  module Questionnaires
-    module DSL
-      class BarChartBuilder < ChartBuilder
-        set_chart_class(Entities::Charting::BarChart)
-
-        def plotline(value, color)
-          @chart.plotlines << {value: value, color: color, width: 1, zIndex: 3}
-        end
-      end
-    end
-  end
-end

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

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require 'quby/questionnaires/entities'
-
-module Quby
-  module Questionnaires
-    module DSL
-      class ChartBuilder
-        # rubocop:disable AccessorMethodName
-        def self.set_chart_class(chart_class)
-          @chart_class = chart_class
-        end
-        # rubocop:enable AccessorMethodName
-
-        def self.chart_class
-          @chart_class
-        end
-
-        def initialize(questionnaire, key, options = {})
-          @chart = self.class.chart_class.new(key, options)
-          @questionnaire = questionnaire
-        end
-
-        def title(title)
-          @chart.title = title
-        end
-
-        def range(range)
-          @chart.y_range = range
-        end
-
-        def tick_interval(tick_interval)
-          @chart.tick_interval = tick_interval
-        end
-
-        def y_categories(y_categories)
-          @chart.y_categories = y_categories
-        end
-
-        def y_range_categories(*y_range_categories)
-          @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}"
-          end
-
-          configure_options plottable, options
-
-          @chart.plottables << Entities::Charting::Plottable.new(plottable.key, options)
-        end
-
-        def chart_type(type)
-          @chart.chart_type = type
-        end
-
-        def build(&block)
-          instance_eval(&block)
-          validate!
-          @chart
-        end
-
-        def validate!
-          if @chart.y_categories.present? && @chart.y_range.present? &&
-             @chart.y_range != (0..(@chart.y_categories.count - 1))
-            fail ArgumentError, 'Y_categories size and range do not match'
-          end
-
-          true
-        end
-
-        private
-
-        def configure_options(plottable, options)
-          case plottable
-          when Entities::ScoreCalculation
-            options.reverse_merge! plottable.options
-          when Entities::Question
-            options[:label] ||= plottable.title
-          end
-          options[:questionnaire_key] = @questionnaire.key
-        end
-      end
-    end
-  end
-end

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

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-
-require 'quby/questionnaires/entities/charting/line_chart'
-require_relative 'chart_builder'
-
-module Quby
-  module Questionnaires
-    module DSL
-      class LineChartBuilder < ChartBuilder
-        set_chart_class(Entities::Charting::LineChart)
-
-        def y_axis_label(label)
-          @chart.y_label = label
-        end
-
-        def tonality(value)
-          @chart.tonality = value
-        end
-
-        def baseline(value = nil, &block)
-          unless value.nil? ^ block.nil?
-            fail ArgumentError, "Must give either value or a block"
-          end
-
-          if value
-            @chart.baseline = ->(age, gender) { value }
-          end
-
-          if block
-            if block.arity != 2
-              fail ArgumentError, "Given block must take two arguments"
-            end
-            @chart.baseline = block
-          end
-        end
-
-        def clinically_relevant_change(value)
-          @chart.clinically_relevant_change = value
-        end
-
-        def validate!
-          fail "Chart #{@chart.key} has no range specified" unless @chart.y_range
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-require 'quby/questionnaires/entities/charting/overview_chart'
-require_relative 'chart_builder'
-
-module Quby
-  module Questionnaires
-    module DSL
-      class OverviewChartBuilder < ChartBuilder
-        set_chart_class(Entities::Charting::OverviewChart)
-
-        def initialize(questionnaire, options = {})
-          @questionnaire = questionnaire
-          @chart = self.class.chart_class.new
-        end
-
-        def subscore(key)
-          @chart.subscore = key
-        end
-
-        def y_max(value)
-          @chart.y_max = value
-        end
-
-        def validate!
-          fail ArgumentError, "subscore not specified" unless @chart.subscore.present?
-          fail ArgumentError, "y_max not specified" unless @chart.y_max.present?
-          true
-        end
-      end
-    end
-  end
-end

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

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'quby/questionnaires/entities/charting/radar_chart'
-require_relative 'chart_builder'
-
-module Quby
-  module Questionnaires
-    module DSL
-      class RadarChartBuilder < ChartBuilder
-        set_chart_class(Entities::Charting::RadarChart)
-
-        def plotline(value, color)
-          @chart.plotlines << {value: value, color: color, width: 1, zIndex: 3}
-        end
-      end
-    end
-  end
-end

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

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-module Quby
-  module Questionnaires
-    module DSL
-      module Helpers
-        def image_tag(*args)
-          options = args.extract_options!
-
-          ActionController::Base.helpers.image_tag(
-            *args, options.reverse_merge(alt: image_alt(args.first))
-          )
-        end
-
-        # Copied from ActionController::Base.helpers.image_alt, because it will be removed from Rails 6.0, but we want
-        # to keep using this functionality
-        def image_alt(source)
-          File.basename(source, ".*").sub(/-[[:xdigit:]]{32,64}\z/, "").tr("-_", " ").capitalize
-        end
-
-        def check_question_keys_uniqueness(key, options, questionnaire)
-          keys = QuestionBuilder.build(key, options).claimed_keys
-          if keys.any? { |k| questionnaire.key_in_use? k }
-            fail "#{questionnaire.key}:#{key}: A question or option with input key #{key} is already defined."
-          end
-        end
-
-        def video_tag(*urls, poster: nil, autoplay: false, loop: false)
-          # assume the file extension is the video format
-          # otherwise, the host's declared mime type is used to figure out compatibility
-          # which is usually wrong
-          sources = urls.map { |url| [url, url.match(/[^\.]*\z/)&.[](0).downcase] }
-          sources.each { |_url, ext| raise 'unknown video url file extension' unless %w[mp4 webm].include?(ext) }
-
-          ActionController::Base.helpers.tag.video\
-            width: '100%',
-            preload: 'none',
-            poster: poster,
-            loop: loop,
-            autoplay: autoplay,
-            muted: autoplay,
-            controls: '' do |tag|
-              sources.map { |url, ext| tag.source src: url, type: "video/#{ext}" }
-                .append(I18n.t('video_not_supported'))
-                .yield_self(&tag.method(:safe_join))
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-
-require 'quby/questionnaires/entities'
-
-module Quby
-  module Questionnaires
-    module DSL
-      class PanelBuilder < Base
-        attr_reader :title
-        attr_reader :questionnaire
-
-        def initialize(title, options = {})
-          @panel = Entities::Panel.new(options.merge(title: title, items: []))
-          @default_question_options = options[:default_question_options] || {}
-          @questionnaire = options[:questionnaire]
-          @custom_methods = options[:custom_methods] || {}
-        end
-
-        def build
-          @panel
-        end
-
-        def title(value)
-          @panel.title = value
-        end
-
-        def text(value, options = {})
-          @panel.items << Entities::Text.new(value.to_s, options)
-        end
-
-        def html(value)
-          @panel.items << Entities::Text.new('', html_content: value.to_s)
-        end
-
-        def raw_html(value)
-          @panel.items << Entities::Text.new('', raw_content: value.to_s)
-        end
-
-        def video(*urls, **options)
-          video_html = video_tag *urls, **options
-          @panel.items << Entities::Text.new('', raw_content: video_html)
-        end
-
-        def default_question_options(options = {})
-          @default_question_options = @default_question_options.merge(options)
-        end
-
-        def question(key, options = {}, &block)
-          options = @default_question_options.merge(options).merge(questionnaire: @panel.questionnaire)
-
-          check_question_keys_uniqueness key, options, @questionnaire
-
-          question = QuestionBuilder.build(key, options, &block)
-
-          @questionnaire.register_question(question)
-          @panel.items << question
-        end
-
-        def table(options = {}, &block)
-          table_builder = TableBuilder.new(@panel, options.merge(questionnaire: @panel.questionnaire,
-                                                                 default_question_options: @default_question_options,
-                                                                 custom_methods: @custom_methods))
-          table_builder.instance_eval(&block) if block
-        end
-
-        def method_missing(method_sym, *args, &block)
-          if @custom_methods.key? method_sym
-            instance_exec(*args, &@custom_methods[method_sym])
-          else
-            super
-          end
-        end
-
-        def respond_to_missing?(method_name, include_private = false)
-          @custom_methods.key?(method_name) || super
-        end
-      end
-    end
-  end
-end