questionnaire_engine 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 16dbdcc59cfde5bcfa9e8745dda6c10b06b489f5
+  data.tar.gz: 67abc2d738cffa82dd8e64e720b896b42da834dc
+SHA512:
+  metadata.gz: 08343605d7259b82442a5e7d6d30843043564d74e4006dc4685b7ba020eea7482f897e6caca96c0eb35b9c4bfd83a121e7e65a24e42259a4724e44edbb9ef81b
+  data.tar.gz: 870fec89ff9946f4b5227f87d99a6fdc6a47bf9d2005ab707a2a1214616d362af7483295cbd8186a9b9571864e6ef978527dcb03f63799cd943cc1676fa4210e

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rdoc"
+
+group :test do
+  gem 'sqlite3'
+end

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2013 Runtime Revolution
+
+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,234 @@
+# Questionnaire
+
+[![Code Climate](https://codeclimate.com/github/dr-click/survey.png)](https://codeclimate.com/github/dr-click/questionnaire)
+### Questionnaire on Rails...
+
+Questionnaire is a Rails Engine that brings multi types of quizzes, surveys and contests into your Rails
+application. Questionnaire models were designed to be flexible enough in order to be extended and
+integrated with your own models. Questionnaire was initially extracted from a real application that handles contests and quizzes.
+
+## Documentation
+
+You can view the Questionnaire documentation in RDoc format here:
+
+http://rubydoc.info/github/dr-click/questionnaire/master/frames
+
+## Main Features:
+ - Questionnaire 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 survey to your Gemfile:
+```ruby
+gem 'questionnaire_engine', '0.1', :require=>"survey"
+
+```
+or
+```ruby
+gem 'questionnaire', github: 'dr-click/questionnaire', branch: 'master', :require=>"survey"
+
+```
+Then run bundle to install the Gem:
+```sh
+bundle install
+```
+Now generate and run migrations:
+```sh
+rails generate survey:install
+
+bundle exec rake db:migrate
+```
+
+## Getting started with Survey
+
+## 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
+Survey::Survey.new(:name => "Star Wars Quiz", :attempts_number => 4)
+```
+## Questionnaire 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 =  Survey::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 = Survey::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 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 == Survey::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 == Survey::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 == Survey::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 == Survey::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 = Survey::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/runtimerevolution/survey

data/Rakefile

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+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 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+task :default => :test
+
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Survey'
+  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/models/survey/answer.rb

@@ -0,0 +1,50 @@
+class Survey::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 => Proc.new{|a| a.question && a.question.mandatory? && a.question.predefined_values.count > 0 && !([Survey::OptionsType.text, Survey::OptionsType.large_text].include?(a.option.options_type_id))  }
+  validates :option_text, :presence => true , :if => Proc.new{|a| a.option && ( a.question && a.question.mandatory? && a.question.predefined_values.count == 0 && [Survey::OptionsType.text, Survey::OptionsType.multi_choices_with_text, Survey::OptionsType.single_choice_with_text, Survey::OptionsType.large_text].include?(a.option.options_type_id)) }
+  validates :option_number, :presence => true , :if => Proc.new{|a| a.option && ( a.question && a.question.mandatory? && [Survey::OptionsType.number, Survey::OptionsType.multi_choices_with_number, Survey::OptionsType.single_choice_with_number].include?(a.option.options_type_id)) }
+    
+  #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
+    unless self.option == nil
+      self.option.weight
+    else
+      Survey::Option.find(option_id).weight
+    end
+  end
+
+  def correct?
+    self.correct or self.option.correct?
+  end
+
+  #######
+  private
+  #######
+  
+  def characterize_answer
+    if option.correct?
+      self.correct = true
+    end
+  end
+
+  def check_single_choice_with_field_case
+    if [Survey::OptionsType.multi_choices, Survey::OptionsType.single_choice].include?(self.option.options_type_id)
+      self.option_text = nil 
+      self.option_number = nil
+    end
+  end
+end

data/app/models/survey/attempt.rb

@@ -0,0 +1,74 @@
+class Survey::Attempt < ActiveRecord::Base
+
+  self.table_name = "survey_attempts"
+
+  # relations
+
+  has_many :answers
+  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, ->(survey) {
+  where(:survey_id => survey.try(:id))
+  }
+
+  scope :exclude_survey, ->(survey) {
+  where("NOT survey_id = #{survey.try(:id)}")
+  }
+
+  scope :for_participant, ->(participant) {
+  where(:participant_id => participant.try(:id),
+    :participant_type => participant.class)
+  }
+
+  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
+  before_create :collect_scores
+
+  def correct_answers
+    self.answers.where(:correct => true)
+  end
+
+  def incorrect_answers
+    self.answers.where(:correct => false)
+  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 = self.survey.attempts_number
+    if attempts.size >= upper_bound and upper_bound != 0
+      errors.add(:questionnaire_id, "Number of attempts exceeded")
+    end
+  end
+
+  def collect_scores
+    self.score = self.answers.map(&:value).reduce(:+)
+  end
+end

data/app/models/survey/option.rb

@@ -0,0 +1,44 @@
+class Survey::Option < ActiveRecord::Base
+
+  self.table_name = "survey_options"
+  #relations
+  belongs_to :question
+  
+  #rails 3 attr_accessible support
+  if Rails::VERSION::MAJOR < 4
+    attr_accessible :text, :correct, :weight, :question_id, :locale_text, :options_type_id
+  end
+  
+  # validations
+  validates :text, :presence => true, :allow_blank => false, :if => Proc.new{|o| [Survey::OptionsType.multi_choices, Survey::OptionsType.single_choice, Survey::OptionsType.single_choice_with_text, Survey::OptionsType.single_choice_with_number, Survey::OptionsType.multi_choices_with_text, Survey::OptionsType.multi_choices_with_number, Survey::OptionsType.large_text].include?(o.options_type_id) }
+  validates :options_type_id, :presence => true
+  validates_inclusion_of :options_type_id, :in => Survey::OptionsType.options_type_ids, :unless => Proc.new{|o| o.options_type_id.blank?}
+  
+  scope :correct, -> {where(:correct => true) }
+  scope :incorrect, -> {where(:correct => false) }
+
+  before_create :default_option_weigth
+
+  def to_s
+    self.text
+  end
+
+  def correct?
+    self.correct == true
+  end
+  
+  def text
+    I18n.locale == I18n.default_locale ? super : locale_text.blank? ? super : locale_text
+  end
+  
+  #######
+  private
+  #######
+  
+  def default_option_weigth
+    if self.correct and self.weight == 0
+      self.weight =  1
+    end
+  end
+
+end