effective_questions 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d948f3c70d98667858558ab90fc1da83bb053636c058c3684dad93f7ccdab507
+  data.tar.gz: 479a4faf525f5d1f31a5fcc4d2039b0d23783eb736d1cc0338a711316e7cf3bb
+SHA512:
+  metadata.gz: af99111296b23031caa4325bc8fe7a85460d54defc6344efb7627b65d5f9d55e4f60909d9d10cdece24b041c1aad36155e03759f2f77bc6949c5a8624eb6936d
+  data.tar.gz: 65db1d73024c9a9457da21febc75789578e7ca28a4efd607aabd443692a017536e512e7455fc7ffabf46221d1bff6671c9a76712df78a97800d8ceb97810919f

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2026 Code and Effect Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,133 @@
+# Effective Questions
+
+Underlying questions and responses module for use with polls, cpd audits and more.
+
+An admin creates an acts_as_questionable resource with one or more questions.
+
+The responses are collected by an acts_as_responsable resource with one or more responses
+
+Works with action_text for content bodies, and active_storage for file uploads.
+
+## Getting Started
+
+This requires Rails 6 and Twitter Bootstrap 4 and just works with Devise.
+
+Please first install the [effective_datatables](https://github.com/code-and-effect/effective_datatables) gem.
+
+Please download and install the [Twitter Bootstrap4](http://getbootstrap.com)
+
+Add to your Gemfile:
+
+```ruby
+gem 'haml'
+gem 'effective_questions'
+```
+
+Run the bundle command to install it:
+
+```console
+bundle install
+```
+
+Then run the generator:
+
+```ruby
+rails generate effective_questions:install
+```
+
+The generator will install an initializer which describes all configuration options and creates a database migration.
+
+If you want to tweak the table names, manually adjust both the configuration file and the migration now.
+
+Then migrate the database:
+
+```ruby
+rake db:migrate
+```
+
+Set up your permissions:
+
+```ruby
+# Regular signed up user. Guest users not supported.
+if user.persisted?
+end
+
+if user.admin?
+end
+```
+
+## Usage
+
+You can render the results with ``.
+
+## Authorization
+
+All authorization checks are handled via the config.authorization_method found in the `app/config/initializers/effective_questions.rb` file.
+
+It is intended for flow through to CanCan or Pundit, but neither of those gems are required.
+
+This method is called by all controller actions with the appropriate action and resource
+
+Action will be one of [:index, :show, :new, :create, :edit, :update, :destroy]
+
+Resource will the appropriate object or class
+
+The authorization method is defined in the initializer file:
+
+```ruby
+# As a Proc (with CanCan)
+config.authorization_method = Proc.new { |controller, action, resource| authorize!(action, resource) }
+```
+
+```ruby
+# As a Custom Method
+config.authorization_method = :my_authorization_method
+```
+
+and then in your application_controller.rb:
+
+```ruby
+def my_authorization_method(action, resource)
+  current_user.is?(:admin) || EffectivePunditPolicy.new(current_user, resource).send('#{action}?')
+end
+```
+
+or disabled entirely:
+
+```ruby
+config.authorization_method = false
+```
+
+If the method or proc returns false (user is not authorized) an Effective::AccessDenied exception will be raised
+
+You can rescue from this exception by adding the following to your application_controller.rb:
+
+```ruby
+rescue_from Effective::AccessDenied do |exception|
+  respond_to do |format|
+    format.html { render 'static_pages/access_denied', status: 403 }
+    format.any { render text: 'Access Denied', status: 403 }
+  end
+end
+```
+
+## License
+
+MIT License.  Copyright [Code and Effect Inc.](http://www.codeandeffect.com/)
+
+## Testing
+
+Run tests by:
+
+```ruby
+rails test
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Bonus points for test coverage
+6. Create new Pull Request

data/Rakefile

@@ -0,0 +1,18 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/assets/config/effective_questions_manifest.js

@@ -0,0 +1 @@
+//= link_directory ../stylesheets .css

data/app/controllers/admin/questions_controller.rb

@@ -0,0 +1,13 @@
+module Admin
+  class QuestionsController < ApplicationController
+    before_action(:authenticate_user!) if defined?(Devise)
+    before_action { EffectiveResources.authorize!(self, :admin, :effective_questions) }
+
+    include Effective::CrudController
+
+    def permitted_params
+      params.require(:effective_question).permit!
+    end
+
+  end
+end

data/app/datatables/admin/effective_questionable_results_datatable.rb

@@ -0,0 +1,44 @@
+class Admin::EffectiveQuestionableResultsDatatable < Effective::Datatable
+  datatable do
+    col :responsable
+
+    col :position, visible: false
+    col :category, search: Effective::Question::CATEGORIES, visible: false
+
+    col :question, search: questionable.questions.pluck(:title).sort
+    col :responses
+  end
+
+  collection do
+    questionable.completed_responses.flat_map do |response|
+      rows = if response.question.question_option?
+        response.question_options.map do |question_option|
+          [
+            response.responsable.try(:token) || response.responsable_id,
+            response.question.position,
+            response.question.category,
+            response.question.to_s,
+            question_option.to_s
+          ]
+        end
+      elsif response.response.present?
+        [
+          [
+            response.responsable.try(:token) || response.responsable_id,
+            response.question.position,
+            response.question.category,
+            response.question.to_s,
+            response.response.to_s
+          ]
+        ]
+      else
+        []
+      end
+    end
+  end
+
+  def questionable
+    @questionable ||= (attributes[:questionable_type].constantize).where(id: attributes[:questionable_id]).first!
+  end
+
+end

data/app/datatables/admin/effective_questions_datatable.rb

@@ -0,0 +1,45 @@
+class Admin::EffectiveQuestionsDatatable < Effective::Datatable
+  datatable do
+    reorder :position
+
+    col :updated_at, visible: false
+    col :created_at, visible: false
+    col :id, visible: false
+
+    if attributes[:follow_up]
+      col :show_if_value_to_s, label: 'When answered with'
+    else
+      col :questionable
+    end
+
+    col :position, visible: false do |question|
+      question.position.to_i + 1
+    end
+
+    col :title
+    col :body, as: :text, visible: !attributes[:follow_up]
+    col :required
+
+    col :category, label: 'Type'
+    col :question_options, label: 'Options'
+
+    unless attributes[:follow_up]
+      col :follow_up_questions, action: false, label: 'Follow up questions'
+    end
+
+    actions_col
+  end
+
+  collection do
+    scope = Effective::Question.all.deep
+
+    if attributes[:follow_up]
+      scope = scope.where(follow_up: true, question_id: attributes[:question_id])
+    else
+      scope = scope.where(question_id: nil)
+    end
+
+    scope
+  end
+
+end

data/app/helpers/effective_questions_helper.rb

@@ -0,0 +1,2 @@
+module EffectiveQuestionsHelper
+end

data/app/models/concerns/acts_as_questionable.rb

@@ -0,0 +1,30 @@
+#
+# ActsAsQuestionable
+#
+module ActsAsQuestionable
+  extend ActiveSupport::Concern
+
+  module Base
+    def acts_as_questionable(options = nil)
+      include ::ActsAsQuestionable
+    end
+  end
+
+  module ClassMethods
+    def acts_as_questionable?; true; end
+  end
+
+  included do
+    has_many :questions, -> { order(:position) }, class_name: 'Effective::Question', as: :questionable, dependent: :destroy
+    accepts_nested_attributes_for :questions, allow_destroy: true
+
+    has_many :responses, -> { order(:id) }, class_name: 'Effective::Response', as: :questionable, dependent: :destroy
+    accepts_nested_attributes_for :responses, allow_destroy: true
+  end
+
+  def completed_responses(question: nil)
+    return responses.select(&:completed?) if question.nil?
+    responses.select { |response| response.completed? && response.question_id == question.id }
+  end
+
+end

data/app/models/concerns/acts_as_responsable.rb

@@ -0,0 +1,30 @@
+#
+# ActsAsResponsable
+#
+module ActsAsResponsable
+  extend ActiveSupport::Concern
+
+  module Base
+    def acts_as_responsable(options = nil)
+      include ::ActsAsResponsable
+    end
+  end
+
+  module ClassMethods
+    def acts_as_responsable?; true; end
+  end
+
+  included do
+    has_many :responses, class_name: 'Effective::Response', as: :responsable, dependent: :destroy
+    accepts_nested_attributes_for :responses, allow_destroy: true
+
+    validates :responses, associated: true
+  end
+
+  # Find or build
+  def response(question:)
+    response = responses.find { |r| r.question_id == question.id }
+    response ||= responses.build(questionable: question.questionable, question: question)
+  end
+
+end

data/app/models/effective/question.rb

@@ -0,0 +1,124 @@
+module Effective
+  class Question < ActiveRecord::Base
+    belongs_to :questionable, polymorphic: true
+
+    belongs_to :question, optional: true # Present when I'm a follow up question
+    belongs_to :question_option, optional: true # Might be present when I'm a follow up question
+
+    has_many :question_options, -> { order(:position) }, inverse_of: :question, dependent: :delete_all
+    accepts_nested_attributes_for :question_options, reject_if: :all_blank, allow_destroy: true
+
+    has_many :follow_up_questions, -> { order(:position) }, class_name: 'Effective::Question', foreign_key: :question_id, dependent: :destroy
+
+    has_rich_text :body
+    log_changes(to: :questionable) if respond_to?(:log_changes)
+
+    has_many :responses
+
+    CATEGORIES = [
+      'Choose one',   # Radios
+      'Select all that apply', # Checks
+      'Select up to 1',
+      'Select up to 2',
+      'Select up to 3',
+      'Select up to 4',
+      'Select up to 5',
+      'Date',         # Date Field
+      'Email',        # Email Field
+      'Number',       # Numeric Field
+      'Long Answer',  # Text Area
+      'Short Answer', # Text Field
+      'Upload File'   # File field
+    ]
+
+    WITH_OPTIONS_CATEGORIES = [
+      'Choose one',   # Radios
+      'Select all that apply', # Checks
+      'Select up to 1',
+      'Select up to 2',
+      'Select up to 3',
+      'Select up to 4',
+      'Select up to 5'
+    ]
+
+    UNSUPPORTED_FOLLOW_UP_QUESTION_CATEGORIES = ['Upload File']
+
+    effective_resource do
+      title         :string
+      category      :string
+      required      :boolean
+
+      position      :integer
+
+      follow_up        :boolean
+      follow_up_value  :string
+
+      timestamps
+    end
+
+    before_validation(if: -> { question.present? }) do
+      assign_attributes(questionable: question.questionable)
+    end
+
+    # Set position
+    before_validation do
+      source = question_option.try(:follow_up_questions) || questionable.try(:questions) || []
+      self.position ||= (source.map { |obj| obj.position }.compact.max || -1) + 1
+    end
+
+    scope :deep, -> { with_rich_text_body_and_embeds.includes(:question_options) }
+    scope :sorted, -> { order(:position) }
+
+    scope :top_level, -> { where(follow_up: false) }
+    scope :follow_up, -> { where(follow_up: true) }
+
+    validates :title, presence: true
+    validates :category, presence: true, inclusion: { in: CATEGORIES }
+    validates :position, presence: true
+    validates :question_options, presence: true, if: -> { question_option? }
+
+    validates :question, presence: true, if: -> { follow_up? }
+    validates :question_option, presence: true, if: -> { follow_up? && question.try(:question_option?) }
+    validates :follow_up_value, presence: true, if: -> { follow_up? && !question.try(:question_option?) }
+
+    # Create choose_one? and select_all_that_apply? methods for each category
+    CATEGORIES.each do |category|
+      define_method(category.parameterize.underscore + '?') { self.category == category }
+    end
+
+    def to_s
+      title.presence || model_name.human
+    end
+
+    def show_if_attribute
+      return :question_option_ids if question_option?
+
+      case category
+      when 'Date' then :date
+      when 'Email' then :email
+      when 'Number' then :number
+      when 'Long Answer' then :long_answer
+      when 'Short Answer' then :short_answer
+      when 'Upload File' then :upload_file
+      else :unknown
+      end
+    end
+
+    def show_if_value
+      question.try(:question_option?) ? question_option_id : follow_up_value
+    end
+
+    def show_if_value_to_s
+      (question.try(:question_option?) ? question_option : follow_up_value).to_s
+    end
+
+    def question_option?
+      WITH_OPTIONS_CATEGORIES.include?(category)
+    end
+
+    def category_partial
+      category.to_s.parameterize.underscore
+    end
+
+  end
+end

data/app/models/effective/question_option.rb

@@ -0,0 +1,26 @@
+module Effective
+  class QuestionOption < ActiveRecord::Base
+    belongs_to :question
+
+    effective_resource do
+      title         :text
+      position      :integer
+
+      timestamps
+    end
+
+    before_validation(if: -> { question.present? }) do
+      self.position ||= (question.question_options.map { |obj| obj.position }.compact.max || -1) + 1
+    end
+
+    scope :sorted, -> { order(:position) }
+
+    validates :title, presence: true
+    validates :position, presence: true
+
+    def to_s
+      title.presence || model_name.human
+    end
+
+  end
+end

data/app/models/effective/response.rb

@@ -0,0 +1,87 @@
+module Effective
+  class Response < ActiveRecord::Base
+    belongs_to :responsable, polymorphic: true
+    belongs_to :questionable, polymorphic: true
+    belongs_to :question
+
+    has_many :response_options, dependent: :delete_all
+    has_many :question_options, through: :response_options
+
+    has_one_attached :upload_file
+
+    effective_resource do
+      # The response
+      date            :date
+      email           :string
+      number          :integer
+      long_answer     :text
+      short_answer    :text
+
+      timestamps
+    end
+
+    scope :deep, -> { includes(:question, :question_options) }
+
+    validate(if: -> { questionable.present? && question.present? }) do
+      errors.add(:question, 'must match questionable') unless question.questionable == questionable
+    end
+
+    validates :date, presence: true, if: -> { question&.required? && question.date? }
+    validates :email, presence: true, email: true, if: -> { question&.required? && question.email? }
+    validates :number, presence: true, if: -> { question&.required? && question.number? }
+    validates :long_answer, presence: true, if: -> { question&.required? && question.long_answer? }
+    validates :short_answer, presence: true, if: -> { question&.required? && question.short_answer? }
+    validates :upload_file, presence: true, if: -> { question&.required? && question.upload_file? }
+    validates :question_option_ids, presence: true, if: -> { question&.required? && question.question_option? }
+
+    validates :question_option_ids, if: -> { question&.choose_one? },
+      length: { maximum: 1, message: 'please choose 1 option only' }
+
+    validates :question_option_ids, if: -> { question&.select_up_to_1? },
+      length: { maximum: 1, message: 'please select 1 option or fewer' }
+
+    validates :question_option_ids, if: -> { question&.select_up_to_2? },
+      length: { maximum: 2, message: 'please select 2 options or fewer' }
+
+    validates :question_option_ids, if: -> { question&.select_up_to_3? },
+      length: { maximum: 3, message: 'please select 3 options or fewer' }
+
+    validates :question_option_ids, if: -> { question&.select_up_to_4? },
+      length: { maximum: 4, message: 'please select 4 options or fewer' }
+
+    validates :question_option_ids, if: -> { question&.select_up_to_5? },
+      length: { maximum: 5, message: 'please select 5 options or fewer' }
+
+    def to_s
+      #model_name.human
+      response.to_s
+    end
+
+    def response
+      return nil unless question.present?
+
+      return date if question.date?
+      return email if question.email?
+      return number if question.number?
+      return long_answer if question.long_answer?
+      return short_answer if question.short_answer?
+      return upload_file if question.upload_file?
+
+      return question_options.first if question.choose_one?
+      return question_options.first if question.select_up_to_1?
+      return question_options if question.question_option?
+
+      raise('unknown response for unexpected question category')
+    end
+
+    def category_partial
+      question&.category_partial
+    end
+
+    def completed?
+      return false if responsable.blank?
+      responsable.completed?
+    end
+
+  end
+end

data/app/models/effective/response_option.rb

@@ -0,0 +1,6 @@
+module Effective
+  class ResponseOption < ActiveRecord::Base
+    belongs_to :response
+    belongs_to :question_option
+  end
+end