ask_it 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1a3bc70a98811e199af9ece6bd847d80c8c2ee0d7c6f28b52b76f4633a782158
+  data.tar.gz: 0360a7f42de9cea7e72e36491377fa81168da1b6032f1f4f51acf9788f07d588
+SHA512:
+  metadata.gz: 9859e6a7b84f31286137b4c1e40ef3768b8f84e7fdd5e3d50a3658a2fd3dce7fdff89b2792924834f314843af8d4627b5b04be6aae81f803347e489ef5c4fd69
+  data.tar.gz: 234ef09f60f5ce8dfe04e07acde93a3e1862b07094a2fee9a3de988cbcc642814b1ec486c6a0b084ebd6053723f75dda358f1a22289d4188329320d88528186a

data/Gemfile

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+ruby '>=2.7.8'
+
+gemspec
+
+gem 'rdoc'
+
+gem 'sqlite3', '~> 1.7.3'

data/LICENSE.md

@@ -0,0 +1,21 @@
+# MIT LICENSE
+
+Copyright (c) 2024 Build It 
+
+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,287 @@
+# Ask It
+
+[![Maintainability](https://api.codeclimate.com/v1/badges/74596429080573c6b707/maintainability)](https://codeclimate.com/github/growth-constant/ask_it/maintainability)
+[![Test Coverage](https://api.codeclimate.com/v1/badges/74596429080573c6b707/test_coverage)](https://codeclimate.com/github/growth-constant/ask_it/test_coverage)
+
+Ask It is a Rails Engine that brings multi types of quizzes, surveys and contests into your Rails
+application. Ask It models were designed to be flexible enough in order to be extended and
+integrated with your own models. Ask It was initially extracted from a real application that handles contests and quizzes.
+
+## Table of Contents
+
+- [Documentation](#documentation)
+- [Main Features](#main-features)
+- [Installation](#installation)
+- [Getting Started](#getting-started)
+- [Adding Survey Participants](#adding-survey-participants)
+- [Survey Associations](#survey-associations)
+- [Survey in Views](#survey-in-views)
+- [Scaffolds and CRUD Frameworks](#scaffolds-and-crud-frameworks)
+- [How to Use It](#how-to-use-it)
+- [Compatibility](#compatibility)
+- [License](#license)
+
+## Documentation
+
+You can view the Ask It documentation in RDoc format here:
+
+http://rubydoc.info/github/dr-click/questionnaire/master/frames
+
+## Main Features:
+ - Ask It can limit the number of attempts for each participant, can have multiple sections
+ - Sections can have multiple questions
+ - Questions can have multiple answers
+ - Answers can have different weights and types (multi choices, single choice, number, text)
+ - Can use 2 languages (Main language field, Localized field) for Surveys, Sections, Questions and Answers attributes
+ - Base Scaffold Support for Active Admin, Rails Admin and default Rails Controllers
+ - Base calculation for scores
+ - Easy integration with your project
+
+## Installation
+
+Add Ask It to your Gemfile for Rails 6 and 7:
+
+```ruby
+gem 'ask_it'
+```
+or
+```ruby
+gem 'ask_it'
+
+```
+
+Now generate and run migrations:
+```sh
+rails generate ask_it:install
+
+bundle exec rake db:migrate
+```
+
+## Getting started with Ask It
+
+## Survey inside your models
+To make a model aware of you just need to add `has_surveys` on it:
+```ruby
+class User < ActiveRecord::Base
+  has_surveys
+
+  #... (your code) ...
+end
+```
+There is the concept of participant, in our example we choose the User Model.
+Every participant can respond to surveys and every response is registered as a attempt.
+By default, survey logic assumes an infinite number of attempts per participant
+but if your surveys need to have a maximum number of attempts
+you can pass the attribute `attempts_number` when creating them.
+
+```ruby
+# Each Participant can respond 4 times this survey
+AskIt::Survey.new(:name => "Star Wars Quiz", :attempts_number => 4)
+```
+## Ask It used in your controllers
+
+In this example we are using the current_user helper
+but you can do it in the way you want.
+
+```ruby
+class ContestsController < ApplicationController
+
+  helper_method :survey, :participant
+
+  # create a new attempt to this survey
+  def new
+    @survey =  AskIt::Survey.active.last
+    @attempt = @survey.attempts.new
+    @attempt.answers.build
+    @participant = current_user # you have to decide what to do here
+  end
+
+  # create a new attempt in this survey
+  # an attempt needs to have a participant assigned
+  def create
+    @survey = AskIt::Survey.active.last
+    @attempt = @survey.attempts.new(attempt_params)
+    @attempt.participant = current_user
+    if @attempt.valid? and @attempt.save
+      redirect_to view_context.new_attempt_path, alert: I18n.t("attempts_controller.#{action_name}")
+    else
+      flash.now[:error] = @attempt.errors.full_messages.join(', ')
+      render :action => :new
+    end
+  end
+  
+  #######
+  private
+  #######
+
+  # Rails 4 Strong Params
+  def attempt_params
+    if Rails::VERSION::MAJOR < 4
+      params[:survey_attempt]
+    else
+      params.require(:survey_attempt).permit(answers_attributes: [:id, :question_id, :option_id, :option_text, :option_number, :predefined_value_id, :_destroy, :finished])
+    end
+  end
+  
+end
+```
+
+## Survey Associations
+To add a survey to a particular model (model has_many :surveys), use the `has_many_surveys` helper
+```ruby
+class Lesson < ActiveRecord::Base
+  has_many_surveys
+
+  #... (your code) ...
+end
+```
+Then, create a module mixin that adds `belongs_to` to the survey model based on your class name
+```ruby
+# app/models/survey/belongs_to_lesson.rb
+module Survey
+  module BelongsToLesson
+    extend ActiveSupport::Concern
+    included do
+      belongs_to :lesson
+    end
+  end
+end
+```
+This will dynamically add the association to the survey model. However, you will need to generate a migration in order to add the foreign key to the `survey_surveys` table like so:
+```ruby
+class AddLessonIdToSurveySurveys < ActiveRecord::Migration
+  def change
+    add_column :survey_surveys, :lesson_id, :integer
+  end
+end
+```
+
+
+## Survey inside your Views
+
+### Controlling Survey avaliability per participant
+To control which page participants see you can use method `avaliable_for_participant?`
+that checks if the participant already spent his attempts.
+```erb
+<h3><%= flash[:alert]%></h3>
+<h3><%= flash[:error]%></h3>
+
+<% if @survey.avaliable_for_participant?(@participant) %>
+  <%= render 'form' %>
+<% else %>
+  <p>
+    <%= @participant.name %> spent all the possible attempts to answer this Survey
+  </p>
+<% end -%>
+
+<% # in _form.html.erb %>
+<h1><%= @survey.name %></h1>
+<p><%= @survey.description %></p>
+<%= form_for(@attempt, :url => attempt_scope(@attempt)) do |f| %>
+  <%= f.fields_for :answers do |builder| %>
+    <ul>
+      <% seq = 0 %>
+      <% @survey.sections.each do |section| %>
+        <p><span><%= "#{section.head_number} : " if section.head_number %></span><%= section.name%></p>
+        <p><%= section.description if section.description %></p>
+        <% section.questions.each do |question| %>
+          <% seq += 1 %>
+          <li>
+            <p><span><%= "#{question.head_number} : " if question.head_number %></span><%= question.text %></p>
+            <p><%= question.description if question.description %></p>
+            <% question.options.each do |option| %>
+              
+              
+              <% if option.options_type_id == AskIt::OptionsType.multi_choices %>
+                <%= hidden_field_tag "survey_attempt[answers_attributes][#{seq}][question_id]", question.id %>
+                <%= check_box_tag "survey_attempt[answers_attributes][#{seq}][option_id]", option.id %>
+                <% seq += 1 %>
+              <% elsif option.options_type_id == AskIt::OptionsType.single_choice %>
+                <%= hidden_field_tag "survey_attempt[answers_attributes][#{seq}][question_id]", question.id %>
+                <%= radio_button_tag "survey_attempt[answers_attributes][#{seq}][option_id]", option.id %>
+              <% elsif option.options_type_id == AskIt::OptionsType.number %>
+                <%= hidden_field_tag "survey_attempt[answers_attributes][#{seq}][question_id]", question.id %>
+                <%= hidden_field_tag "survey_attempt[answers_attributes][#{seq}][option_id]", option.id %>
+                <%= number_field_tag "survey_attempt[answers_attributes][#{seq}][option_number]", "", :style => "width: 40px;" %>
+                <% seq += 1 %>
+              <% elsif option.options_type_id == AskIt::OptionsType.text %>
+                <%= hidden_field_tag "survey_attempt[answers_attributes][#{seq}][question_id]", question.id %>
+                <%= hidden_field_tag "survey_attempt[answers_attributes][#{seq}][option_id]", option.id %>
+                <%= text_field_tag "survey_attempt[answers_attributes][#{seq}][option_text]", "" %>
+                <% seq += 1 %>
+              <% end %>
+              
+              <%= option.text %> <br/>
+            <% end -%>
+          </li>
+        <% end -%>
+      <% end -%>
+    </ul>
+  <% end -%>
+  <%= f.submit "Submit" %>
+<% end -%>
+```
+
+### Scaffolds and CRUD frameworks
+If you are using Rails Admin or Active Admin, you can generate base CRUD screens for Survey with:
+```sh
+rails generate survey active_admin
+
+rails generate survey rails_admin
+```
+If you want a simple way to get started you can use the `plain` option which is a simple Rails scaffold to generate the controller and views related with survey logic.
+By default when you type `rails g survey plain` it generates a controller in the `admin` namespace but you can choose your own namespace as well:
+```sh
+rails generate survey plain namespace:contests
+```
+
+By default when you generates your controllers using the `plain` command the task
+generates the associated routes as well.
+Afterwards if you want to generate more routes, you can using the command:
+
+```sh
+rails generate survey routes namespace:admin
+```
+
+
+## How to use it
+Every user has a collection of attempts for each survey that he respond to. Is up to you to
+make averages and collect reports based on that information.
+What makes Survey useful is that all the logic behind surveys is now abstracted and well integrated,
+making your job easier.
+
+## Hacking with Survey through your Models:
+
+```ruby
+# select the first active Survey
+survey = AskIt::Survey.active.first
+
+# select all the attempts from this survey
+survey_answers = survey.attempts
+
+# check the highest score for current user
+user_highest_score  = survey_answers.for_participant(@user).high_score
+
+#check the highest score made for this survey
+global_highest_score = survey_answers.high_score
+```
+# Compability 
+
+### Rails
+Survey supports Rails 3 and 4. For use in Rails 4 without using protected_attributes gem.
+Rails 4 support is recent, so some minor issues may still be present, please report them.
+
+### Active Admin
+Only support versions of Active Admin higher than 0.3.1.
+
+# License
+- Modified by [Dr-Click](http://github.com/dr-click)
+- Copyright © 2013 [Runtime Revolution](http://www.runtime-revolution.com), released under the MIT license.
+- This repository was forked from the original one : https://github.com/clearfunction/questionnaire
+
+# Thanks to Gems
+- [Appraisal](https://github.com/thoughtbot/appraisal)
+- [Code Climate](https://codeclimate.com/)
+- [Simplecov](https://github.com/colszowka/simplecov)
+- [Rspec](https://github.com/rspec/rspec)
+- [Rails](https://github.com/rails/rails)

data/Rakefile

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rake'
+require 'rdoc/task'
+require 'rspec/core/rake_task'
+load 'tasks/changelog.rake'
+
+desc 'Run all specs across all appraisals'
+task :spec do
+  sh 'bundle exec appraisal rspec'
+end
+
+task default: :spec
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Ask It'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.rdoc_files.include('app/**/*.rb')
+end

data/app/controllers/ask_it/attempts_controller.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module AskIt
+  # Handles creation and management of survey attempts
+  class AttemptsController < ActionController::Base
+    # Handles creation and management of survey attempts
+    # helper 'ask_it/surveys'
+    # include AskIt::SurveysHelper
+
+    def new
+      @survey = Survey.active.last
+      @attempt = @survey.attempts.new
+      @attempt.answers.build
+      @participant = current_user # Adjust as needed
+    end
+
+    def create
+      @survey = Survey.active.last
+      @attempt = @survey.attempts.new(attempt_params)
+      @attempt.participant = current_user # Adjust as needed
+
+      if @attempt.save
+        redirect_to new_ask_it_attempt_path, notice: t('.success')
+      else
+        flash.now[:error] = @attempt.errors.full_messages.join(', ')
+        render :new
+      end
+    end
+
+    private
+
+    def attempt_params
+      params.require(:attempt).permit(answers_attributes: %i[question_id option_id option_text option_number predefined_value_id])
+    end
+  end
+end

data/app/controllers/ask_it/surveys_controller.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module AskIt
+  # Handles creation and management of surveys
+  class SurveysController < ActionController::Base
+    before_action :load_survey, only: %i[show edit update]
+
+    def index
+      @surveys = AskIt::Survey.all
+    end
+
+    def new
+      @survey = AskIt::Survey.new
+    end
+
+    def create
+      @survey = AskIt::Survey.new(survey_params)
+      if @survey.valid? && @survey.save
+        redirect_to surveys_path, notice: I18n.t('surveys_controller.create')
+      else
+        render :new
+      end
+    end
+
+    def edit
+      # @survey is already loaded by before_action
+    end
+
+    def show
+      # @survey is already loaded by before_action
+    end
+
+    def update
+      if @survey.update(survey_params)
+        redirect_to surveys_path, notice: I18n.t('surveys_controller.update')
+      else
+        render :edit
+      end
+    end
+
+    private
+
+    def load_survey
+      @survey = AskIt::Survey.find(params[:id])
+    rescue ActiveRecord::RecordNotFound
+      redirect_to surveys_path, alert: 'Survey not found'
+    end
+
+    def survey_params
+      params.require(:survey).permit(
+        :name, :description, :active,
+        sections_attributes: [:id, :name, :_destroy,
+                              { questions_attributes: [:id, :text, :question_type, :_destroy,
+                                                       { options_attributes: %i[id text _destroy] }] }]
+      )
+    end
+  end
+end

data/app/models/ask_it/answer.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module AskIt
+  class Answer < ActiveRecord::Base
+    self.table_name = 'survey_answers'
+    belongs_to :attempt
+    belongs_to :option
+    belongs_to :predefined_value
+    belongs_to :question
+
+    validates :option_id, :question_id, presence: true
+    validates :predefined_value_id, presence: true, if: :requires_predefined_value?
+    validates :option_text, presence: true, if: :requires_text_input?
+    validates :option_number, presence: true, if: :requires_number_input?
+
+    # rails 3 attr_accessible support
+    if Rails::VERSION::MAJOR < 4
+      attr_accessible :option, :attempt, :question, :question_id, :option_id, :predefined_value_id, :attempt_id,
+                      :option_text, :option_number
+    end
+
+    before_create :characterize_answer
+    before_save :check_single_choice_with_field_case
+
+    def value
+      if option.nil?
+        AskIt::Option.find(option_id).weight
+      else
+        option.weight
+      end
+    end
+
+    def correct?
+      correct || option.correct?
+    end
+
+    #######
+
+    private
+
+    #######
+
+    def characterize_answer
+      self.correct = true if option.correct?
+    end
+
+    def check_single_choice_with_field_case
+      return unless [AskIt::OptionsType.multi_choices,
+                     AskIt::OptionsType.single_choice].include?(option.options_type_id)
+
+      self.option_text = nil
+      self.option_number = nil
+    end
+
+    # Validations
+
+    def requires_predefined_value?
+      question&.mandatory? &&
+        question.predefined_values.count.positive? &&
+        !text_based_option?
+    end
+
+    def requires_text_input?
+      option &&
+        question &&
+        question.mandatory? &&
+        question.predefined_values.count.zero? &&
+        text_input_option?
+    end
+
+    def requires_number_input?
+      option &&
+        question &&
+        question.mandatory? &&
+        number_input_option?
+    end
+
+    def text_based_option?
+      [AskIt::OptionsType.text, AskIt::OptionsType.large_text].include?(option.options_type_id)
+    end
+
+    def text_input_option?
+      [
+        AskIt::OptionsType.text,
+        AskIt::OptionsType.multi_choices_with_text,
+        AskIt::OptionsType.single_choice_with_text,
+        AskIt::OptionsType.large_text
+      ].include?(option.options_type_id)
+    end
+
+    def number_input_option?
+      [
+        AskIt::OptionsType.number,
+        AskIt::OptionsType.multi_choices_with_number,
+        AskIt::OptionsType.single_choice_with_number
+      ].include?(option.options_type_id)
+    end
+  end
+end

data/app/models/ask_it/attempt.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module AskIt
+  class Attempt < ActiveRecord::Base
+    self.table_name = 'survey_attempts'
+
+    # relations
+
+    has_many :answers, dependent: :destroy
+    belongs_to :survey
+    belongs_to :participant, polymorphic: true
+
+    # rails 3 attr_accessible support
+    if Rails::VERSION::MAJOR < 4
+      attr_accessible :participant_id, :survey_id, :answers_attributes, :survey, :winner, :participant
+    end
+
+    # validations
+    validates :participant_id, :participant_type,
+              presence: true
+
+    accepts_nested_attributes_for :answers,
+                                  reject_if: ->(q) { q[:question_id].blank? && q[:option_id].blank? },
+                                  allow_destroy: true
+
+    # scopes
+
+    scope :for_survey, lambda { |survey|
+      where(survey_id: survey.try(:id))
+    }
+
+    scope :exclude_survey, lambda { |survey|
+      where("NOT survey_id = #{survey.try(:id)}")
+    }
+
+    scope :for_participant, lambda { |participant|
+      where(participant_id: participant.try(:id),
+            participant_type: participant.class.to_s)
+    }
+
+    scope :wins, -> { where(winner: true) }
+    scope :looses, -> { where(winner: false) }
+    scope :scores, -> { order('score DESC') }
+
+    # callbacks
+
+    validate :check_number_of_attempts_by_survey, on: :create
+    after_create :collect_scores
+
+    def correct_answers
+      answers.where(correct: true)
+    end
+
+    def incorrect_answers
+      answers.where(correct: false)
+    end
+
+    def collect_scores!
+      collect_scores
+      save
+    end
+
+    def self.high_score
+      scores.first.score
+    end
+
+    private
+
+    def check_number_of_attempts_by_survey
+      attempts = self.class.for_survey(survey).for_participant(participant)
+      upper_bound = survey.attempts_number
+      return unless attempts.size >= upper_bound && upper_bound.nonzero?
+
+      errors.add(:questionnaire_id,
+                 'Number of attempts exceeded')
+    end
+
+    def collect_scores
+      multi_select_questions = AskIt::Question.joins(:section)
+                                              .where(survey_sections: { survey_id: survey.id },
+                                                     survey_questions: {
+                                                       questions_type_id: AskIt::QuestionType.multi_select
+                                                     })
+      if multi_select_questions.empty? # No multi-select questions
+        raw_score = answers.map(&:value).reduce(:+)
+        self.score = raw_score
+      else
+        # Initial score without multi-select questions
+        raw_score = answers.where.not(question_id: multi_select_questions.ids).map(&:value).reduce(:+) || 0
+        multi_select_questions.each do |question|
+          options = question.options
+          correct_question_answers = answers.where(question_id: question.id, correct: true)
+          break if correct_question_answers.empty? # If they didn't select any correct answers, then skip this step
+
+          correct_options_sum = options.correct.map(&:weight).reduce(:+)
+          correct_percentage = correct_question_answers.map(&:value).reduce(:+).fdiv(correct_options_sum)
+          raw_score += correct_percentage
+          if correct_percentage == 1
+            option_value = 1 / options.count.to_f
+            raw_score -= (option_value * answers.where(question_id: question.id, correct: false).count)
+          end
+        end
+        self.score = raw_score || 0
+        save
+      end
+    end
+  end
+end