turkee_rails4 2.0.3

data/lib/generators/turkee/turkee_generator.rb

@@ -0,0 +1,51 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+
+class TurkeeGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+  
+  # Implement the required interface for Rails::Generators::Migration.
+  # taken from http://github.com/rails/rails/blob/master/activerecord/lib/generators/active_record.rb
+  def self.next_migration_number(dirname)
+    Time.now.utc.strftime("%Y%m%d%H%M%S")
+  end
+
+  source_root File.expand_path("../templates", __FILE__)
+
+  desc "Creates initializer and migrations."
+  
+  def create_migrations
+    migration_template "turkee_migration.rb.erb", "db/migrate/create_turkee_tasks.rb"
+
+    # Need this sleep so that we don't get the same migration timestamp for both migrations
+    sleep 1
+    
+    migration_template "turkee_imported_assignments.rb.erb", "db/migrate/create_turkee_imported_assignments.rb"
+
+    sleep 1
+
+    migration_template "add_completed_tasks.rb.erb", "db/migrate/add_completed_tasks.rb"
+    
+    sleep 1
+
+    migration_template "add_imported_assignment_details.rb.erb", "db/migrate/add_imported_assignment_details.rb"
+
+    sleep 1
+
+    migration_template "add_hit_duration.rb.erb", "db/migrate/add_hit_duration.rb"
+
+    sleep 1
+
+    migration_template "add_expired.rb.erb", "db/migrate/add_expired.rb"
+
+    sleep 1
+
+    migration_template "create_turkee_study.rb.erb", "db/migrate/create_turkee_study.rb"
+
+  end
+
+  def create_initializer
+    template "turkee.rb", "config/initializers/turkee.rb"
+  end
+
+end

data/lib/helpers/turkee_forms_helper.rb

@@ -0,0 +1,69 @@
+module Turkee
+
+  module TurkeeFormHelper
+    def turkee_form_for(record, params, options = {}, &proc)
+      raise ArgumentError, "turkee_form_for now requires that you pass in the entire params hash, instead of just the assignmentId value. " unless params.is_a?(Hash)
+
+      options.merge!({:url => mturk_url})
+
+      capture do
+        form_for record, options do |f|
+          params.each do |k,v|
+            unless ['action','controller'].include?(k) || !v.is_a?(String)
+              concat hidden_field_tag(k, v)
+              cookies[k] = v
+            end
+          end
+
+          ['assignmentId', 'workerId', 'hitId'].each do |k|
+            concat hidden_field_tag(k, cookies[k]) if !params.has_key?(k) && cookies.has_key?(k)
+          end
+
+          concat(capture(f, &proc))
+        end
+      end
+    end
+
+    def turkee_study(id = nil)
+      task     = id.nil? ? Turkee::TurkeeTask.last : Turkee::TurkeeTask.find(id)
+      study    = Turkee::TurkeeStudy.new
+      disabled = Turkee::TurkeeFormHelper::disable_form_fields?(params[:assignmentId])
+
+      if task.present?
+        style =  "position: fixed; top: 120px; right: 30px; color: #FFF;"
+        style << "width: 400px; height: 375px; z-index: 100; padding: 10px;"
+        style << "background-color: rgba(0,0,0, 0.5); border: 1px solid #000;"
+
+        div_for(task, :style => style) do
+          capture do
+            concat content_tag(:h3, "DIRECTIONS", :style => 'text-align: right; color:#FF0000;')
+            concat task.hit_description.html_safe
+            concat '<hr/>'.html_safe
+            concat(turkee_form_for(study, params) do |f|
+              concat f.label(:feedback, "Feedback?:")
+              concat f.text_area(:feedback, :rows => 3, :disabled => disabled)
+              concat f.label(:gold_response, "Enter the fourth word from your above feedback :")
+              concat f.text_field(:gold_response, :disabled => disabled)
+              concat f.hidden_field(:turkee_task_id, :value => task.id)
+              concat '<br/>'.html_safe
+              concat f.submit('Submit', :disabled => disabled)
+            end)
+          end
+        end
+      end
+    end
+
+    # Returns the external Mechanical Turk url used to post form data based on whether RTurk is cofigured
+    #   for sandbox use or not.
+    def mturk_url
+      RTurk.sandbox? ? "https://workersandbox.mturk.com/mturk/externalSubmit" : "https://www.mturk.com/mturk/externalSubmit"
+    end
+
+    # Returns whether the form fields should be disabled or not (based on the assignment_id)
+    def self.disable_form_fields?(assignment)
+      assignment_id = assignment.is_a?(Hash) ? assignment[:assignmentId] : assignment
+      (assignment_id.nil? || assignment_id == 'ASSIGNMENT_ID_NOT_AVAILABLE')
+    end
+  end
+
+end

data/lib/models/turkee_imported_assignment.rb

@@ -0,0 +1,15 @@
+require 'active_record'
+
+module Turkee
+  class TurkeeImportedAssignment < ActiveRecord::Base
+    attr_accessible :assignment_id, :turkee_task_id, :worker_id, :result_id if ActiveRecord::VERSION::MAJOR < 4
+
+    def self.record_imported_assignment(assignment, result, turk)
+      TurkeeImportedAssignment.create!(:assignment_id => assignment.id,
+                                       :turkee_task_id => turk.id,
+                                       :worker_id => assignment.worker_id,
+                                       :result_id => result.id)
+    end
+
+  end
+end

data/lib/models/turkee_study.rb

@@ -0,0 +1,11 @@
+module Turkee
+  class TurkeeStudy < ActiveRecord::Base
+    GOLD_RESPONSE_INDEX = 3
+    attr_accessible :turkee_task_id, :feedback, :gold_response if ActiveRecord::VERSION::MAJOR < 4
+
+    def approve?
+      words = feedback.split(/\W+/)
+      gold_response.present? ? (gold_response == words[GOLD_RESPONSE_INDEX]) : true
+    end
+  end
+end

data/lib/models/turkee_task.rb

@@ -0,0 +1,259 @@
+require 'rubygems'
+require 'socket'
+require 'rturk'
+require 'lockfile'
+require 'active_record'
+require "active_support/core_ext/object/to_query"
+require 'action_controller'
+
+module Turkee
+
+  class TurkeeTask < ActiveRecord::Base
+    attr_accessible :sandbox, :hit_title, :hit_description, :hit_reward, :hit_num_assignments, :hit_lifetime, :hit_duration,
+                    :form_url, :hit_url, :hit_id, :task_type, :complete if ActiveRecord::VERSION::MAJOR < 4
+
+    HIT_FRAMEHEIGHT = 1000
+
+    scope :unprocessed_hits, lambda { where('complete = ? AND sandbox = ?', false, RTurk.sandbox?) }
+
+    # Use this method to go out and retrieve the data for all of the posted Turk Tasks.
+    #  Each specific TurkeeTask object (determined by task_type field) is in charge of
+    #  accepting/rejecting the assignment and importing the data into their respective tables.
+    def self.process_hits(turkee_task = nil)
+
+      begin
+        # Using a lockfile to prevent multiple calls to Amazon.
+        Lockfile.new('/tmp/turk_processor.lock', :max_age => 3600, :retries => 10) do
+
+          turks = task_items(turkee_task)
+
+          turks.each do |turk|
+            hit = RTurk::Hit.new(turk.hit_id)
+
+            callback_models = Set.new
+            hit.assignments.each do |assignment|
+              next unless submitted?(assignment.status)
+              next if assignment_exists?(assignment)
+
+              model, param_hash = map_imported_values(assignment, turk.task_type)
+              next if model.nil?
+
+              callback_models << model
+
+              result = save_imported_values(model, param_hash)
+
+              # If there's a custom approve? method, see if we should approve the submitted assignment
+              #  otherwise just approve it by default
+              turk.process_result(assignment, result)
+
+              TurkeeImportedAssignment.record_imported_assignment(assignment, result, turk)
+            end
+
+            turk.set_expired?(callback_models) if !turk.set_complete?(hit, callback_models)
+          end
+        end
+      rescue Lockfile::MaxTriesLockError => e
+        logger.info "TurkTask.process_hits is already running or the lockfile /tmp/turk_processor.lock exists from an improperly shutdown previous process. Exiting method call."
+      end
+
+    end
+
+    def self.save_imported_values(model, param_hash)
+      key = model.to_s.underscore.gsub('/','_') # Namespaced model will come across as turkee/turkee_study,
+                                                #  we must translate to turkee_turkee_study"
+      model.create(param_hash[key])
+    end
+
+    # Creates a new Mechanical Turk task on AMZN with the given title, desc, etc
+    def self.create_hit(host, hit_title, hit_description, typ, num_assignments, reward, lifetime,
+                        duration = nil, qualifications = {}, params = {}, opts = {})
+      model = typ.to_s.constantize
+      f_url = build_url(host, model, params, opts)
+
+      h = RTurk::Hit.create(:title => hit_title) do |hit|
+        hit.max_assignments = num_assignments if hit.respond_to?(:max_assignments)
+        hit.assignments = num_assignments if hit.respond_to?(:assignments)
+
+        hit.description = hit_description
+        hit.reward = reward
+        hit.lifetime = lifetime.to_i.days.seconds.to_i
+        hit.duration = duration.to_i.hours.seconds.to_i if duration
+        hit.question(f_url, :frame_height => HIT_FRAMEHEIGHT)
+        unless qualifications.empty?
+          qualifications.each do |key, value|
+            hit.qualifications.add key, value
+          end
+        end
+      end
+
+      TurkeeTask.create(:sandbox => RTurk.sandbox?,
+                        :hit_title => hit_title, :hit_description => hit_description,
+                        :hit_reward => reward.to_f, :hit_num_assignments => num_assignments.to_i,
+                        :hit_lifetime => lifetime, :hit_duration => duration,
+                        :form_url => f_url, :hit_url => h.url,
+                        :hit_id => h.id, :task_type => typ,
+                        :complete => false)
+
+    end
+
+    ##########################################################################################################
+    # DON'T PUSH THIS BUTTON UNLESS YOU MEAN IT. :)
+    def self.clear_all_turks(force = false)
+      # Do NOT execute this function if we're in production mode
+      raise "You can only clear turks in the sandbox/development environment unless you pass 'true' for the force flag." if Rails.env == 'production' && !force
+
+      hits = RTurk::Hit.all
+
+      logger.info "#{hits.size} reviewable hits. \n"
+
+      unless hits.empty?
+        logger.info "Approving all assignments and disposing of each hit."
+
+        hits.each do |hit|
+          begin
+            hit.expire!
+            hit.assignments.each do |assignment|
+              logger.info "Assignment status : #{assignment.status}"
+              assignment.approve!('__clear_all_turks__approved__') if assignment.status == 'Submitted'
+            end
+
+            turkee_task = TurkeeTask.where(hit_id: hit.id).first
+            turkee_task.complete_task if turkee_task.present?
+
+            hit.dispose!
+          rescue Exception => e
+            # Probably a service unavailable
+            logger.error "Exception : #{e.to_s}"
+          end
+        end
+      end
+
+    end
+
+    def complete_task
+      self.complete = true
+      save!
+    end
+
+    def set_complete?(hit, models)
+      if completed_assignments?
+        hit.dispose!
+        complete_task
+        initiate_callback(:hit_complete, models)
+        return true
+      end
+
+      false
+    end
+
+    def set_expired?(models)
+      if expired?
+        self.expired = true
+        save!
+        initiate_callback(:hit_expired, models)
+      end
+    end
+
+    def initiate_callback(method, models)
+      models.each { |model| model.send(method, self) if model.respond_to?(method) }
+    end
+
+    def process_result(assignment, result)
+      if result.errors.size > 0
+        logger.info "Errors : #{result.inspect}"
+        assignment.reject!('Failed to enter proper data.')
+      elsif result.respond_to?(:approve?)
+        logger.debug "Approving : #{result.inspect}"
+        self.increment_complete_assignments
+        result.approve? ? assignment.approve!('') : assignment.reject!('Rejected criteria.')
+      else
+        self.increment_complete_assignments
+        assignment.approve!('')
+      end
+    end
+
+    def increment_complete_assignments
+      raise "Missing :completed_assignments attribute. Please upgrade Turkee to the most recent version." unless respond_to?(:completed_assignments)
+
+      self.completed_assignments += 1
+      save
+    end
+
+    private
+
+    def logger
+      @logger ||= Logger.new($stderr)
+    end
+
+    def self.map_imported_values(assignment, default_type)
+      params     = assignment_params(assignment.answers)
+      param_hash = Rack::Utils.parse_nested_query(params)
+
+      model      = find_model(param_hash)
+      model      = default_type.constantize if model.nil?
+
+      return model, param_hash
+    end
+
+    def self.assignment_exists?(assignment)
+      TurkeeImportedAssignment.find_by_assignment_id(assignment.id).present?
+    end
+
+    def completed_assignments?
+      completed_assignments == hit_num_assignments
+    end
+
+    def expired?
+      Time.now >= (created_at + hit_lifetime.days)
+    end
+
+    def self.task_items(turkee_task)
+      turkee_task.nil? ? TurkeeTask.unprocessed_hits : Array.new << turkee_task
+    end
+
+    def self.submitted?(status)
+      (status == 'Submitted')
+    end
+
+    def self.assignment_params(answers)
+      answers.to_query
+    end
+
+    # Method looks at the parameter and attempts to find an ActiveRecord model
+    #  in the current app that would match the properties of one of the nested hashes
+    #  x = {:submit = 'Create', :iteration_vote => {:iteration_id => 1}}
+    #  The above _should_ return an IterationVote model
+    def self.find_model(param_hash)
+      param_hash.each do |k, v|
+        if v.is_a?(Hash)
+          model = k.to_s.camelize.constantize rescue next
+          return model if model.descends_from_active_record? rescue next
+        end
+      end
+      nil
+    end
+
+    # Returns custom URL if opts[:form_url] is specified.  Otherwise, builds the default url from the model's :new route
+    def self.build_url(host, model, params, opts)
+      if opts[:form_url]
+        full_url(opts[:form_url], params)
+      else
+        form_url(host, model, params)
+      end
+    end
+
+    # Returns the default url of the model's :new route
+    def self.form_url(host, typ, params = {})
+      @app ||= ActionDispatch::Integration::Session.new(Rails.application)
+      url = (host + @app.send("new_#{typ.to_s.underscore}_path"))
+      full_url(url, params)
+    end
+
+    # Appends params to the url as a query string
+    def self.full_url(u, params)
+      url = u
+      url = "#{u}?#{params.to_query}" unless params.empty?
+      url
+    end
+  end
+end

data/lib/tasks/turkee.rb

@@ -0,0 +1,29 @@
+require 'rake'
+require 'turkee'
+
+namespace :turkee do
+  desc "Post your form to Mechanical Turk (HIT). Task takes the application's host URL, HIT title, HIT description, model name, number of responses, reward for each response, number of days the HIT should be valid, and number of hours a worker has to complete the HIT."
+  task :post_hit, [:host, :title, :description, :model, :num_assignments, :reward, :lifetime] => :environment do |t, args|
+    hit = Turkee::TurkeeTask.create_hit(args[:host],args[:title], args[:description], args[:model],
+                                        args[:num_assignments], args[:reward], args[:lifetime])
+    puts "Hit created : #{hit.hit_url}"
+  end
+
+  desc "Retrieve all results from Mechanical Turk for all open HITs."
+  task :get_all_results => :environment do
+    Turkee::TurkeeTask.process_hits
+  end
+
+  desc "Create a usability study. Task takes the application's full url, HIT title, HIT description, model name, number of responses, reward for each response, number of days the HIT should be valid, and number of hours a worker has to complete the HIT."
+  task :create_study, [:url, :title, :description, :num_assignments, :reward, :lifetime] => :environment do |t, args|
+    qualifications = {:approval_rate => {:gt => 70}, :country => {:eql => 'US'}}
+
+    hit = Turkee::TurkeeTask.create_hit(args[:url], args[:title], args[:description], "Turkee::TurkeeStudy",
+                                        args[:num_assignments], args[:reward], args[:lifetime],
+                                        nil, qualifications, {}, {:form_url => args[:url]})
+    puts
+    puts "Study created : #{hit.hit_url}"
+  end
+
+
+end

data/lib/turkee.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'action_view'
+require 'helpers/turkee_forms_helper'
+require 'models/turkee_imported_assignment'
+require 'models/turkee_task'
+require 'models/turkee_study'
+
+ActionView::Base.send :include, Turkee::TurkeeFormHelper

data/spec/dummy/Rakefile

@@ -0,0 +1,7 @@
+#!/usr/bin/env rake
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/spec/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,5 @@
+// This is a manifest file that'll be compiled into including all the files listed below.
+// Add new JavaScript/Coffee code in separate files in this directory and they'll automatically
+// be included in the compiled file accessible from http://example.com/assets/application.js
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// the compiled file.

data/spec/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,7 @@
+/*
+ * This is a manifest file that'll automatically include all the stylesheets available in this directory
+ * and any sub-directories. You're free to add application-wide styles to this file and they'll appear at
+ * the top of the compiled file, but it's generally better to create a new file per style scope.
+ *= require_self
+ *= require_tree . 
+*/

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+end

data/spec/dummy/app/controllers/surveys_controller.rb

@@ -0,0 +1,7 @@
+class SurveysController < ApplicationController
+
+  def new
+
+  end
+
+end

data/spec/dummy/app/helpers/application_helper.rb

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

data/spec/dummy/app/models/survey.rb

@@ -0,0 +1,3 @@
+class Survey < ActiveRecord::Base
+  attr_accessible :answer
+end

data/spec/dummy/app/views/layouts/application.html.erb

@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Dummy</title>
+
+  <% if params[:type] == 'prototype' %>
+    <%= javascript_include_tag 'prototype', 'prototype_nested_form', 'prototype_events_test' %>
+  <% else %>
+    <%= javascript_include_tag 'jquery', 'jquery_nested_form', 'jquery_events_test' %>
+  <% end %>
+</head>
+<body>
+
+<%= yield %>
+
+<div id="console"></div>
+
+</body>
+</html>

data/spec/dummy/config/application.rb

@@ -0,0 +1,41 @@
+require File.expand_path('../boot', __FILE__)
+
+require 'rails/all'
+
+Bundler.require
+
+module Dummy
+  class Application < Rails::Application
+    # Settings in config/environments/* take precedence over those specified here.
+    # Application configuration should go into files in config/initializers
+    # -- all .rb files in that directory are automatically loaded.
+
+    # Custom directories with classes and modules you want to be autoloadable.
+    # config.autoload_paths += %W(#{config.root}/extras)
+
+    # Only load the plugins named here, in the order given (default is alphabetical).
+    # :all can be used as a placeholder for all plugins not explicitly named.
+    # config.plugins = [ :exception_notification, :ssl_requirement, :all ]
+
+    # Activate observers that should always be running.
+    # config.active_record.observers = :cacher, :garbage_collector, :forum_observer
+
+    # Set Time.zone default to the specified zone and make Active Record auto-convert to this zone.
+    # Run "rake -D time" for a list of tasks for finding time zone names. Default is UTC.
+    # config.time_zone = 'Central Time (US & Canada)'
+
+    # The default locale is :en and all translations from config/locales/*.rb,yml are auto loaded.
+    # config.i18n.load_path += Dir[Rails.root.join('my', 'locales', '*.{rb,yml}').to_s]
+    # config.i18n.default_locale = :de
+
+    # Configure the default encoding used in templates for Ruby 1.9.
+    config.encoding = "utf-8"
+
+    # Configure sensitive parameters which will be filtered from the log file.
+    config.filter_parameters += [:password]
+
+    # Enable the asset pipeline
+    config.assets.enabled = true if config.respond_to?(:assets)
+  end
+end
+

data/spec/dummy/config/boot.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+
+gemfile = ENV['BUNDLE_GEMFILE'] || File.expand_path('../../../../Gemfile', __FILE__)
+if File.exist?(gemfile)
+  ENV['BUNDLE_GEMFILE'] = gemfile
+  require 'bundler'
+  Bundler.setup
+end
+
+$:.unshift File.expand_path('../../../../lib', __FILE__)

data/spec/dummy/config/database.yml

@@ -0,0 +1,25 @@
+# SQLite version 3.x
+#   gem install sqlite3
+#
+#   Ensure the SQLite 3 gem is defined in your Gemfile
+#   gem 'sqlite3'
+development:
+  adapter: sqlite3
+  database: ":memory:"
+  pool: 5
+  timeout: 5000
+
+# Warning: The database defined as "test" will be erased and
+# re-generated from your development database when you run "rake".
+# Do not set this db to the same as development or production.
+test:
+  adapter: sqlite3
+  database: ":memory:"
+  pool: 5
+  timeout: 5000
+
+production:
+  adapter: sqlite3
+  database: ":memory:"
+  pool: 5
+  timeout: 5000

data/spec/dummy/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the rails application
+require File.expand_path('../application', __FILE__)
+
+# Initialize the rails application
+Dummy::Application.initialize!

data/spec/dummy/config/environments/development.rb

@@ -0,0 +1,26 @@
+Dummy::Application.configure do
+  # Settings specified here will take precedence over those in config/application.rb
+
+  # In the development environment your application's code is reloaded on
+  # every request.  This slows down response time but is perfect for development
+  # since you don't have to restart the web server when you make code changes.
+  config.cache_classes = false
+
+  config.eager_load = false if Rails::VERSION::MAJOR >= 4
+
+  # Show full error reports and disable caching
+  config.consider_all_requests_local       = true
+  config.action_controller.perform_caching = false
+
+  # Don't care if the mailer can't send
+  config.action_mailer.raise_delivery_errors = false
+
+  # Print deprecation notices to the Rails logger
+  config.active_support.deprecation = :log
+
+  # Only use best-standards-support built into browsers
+  config.action_dispatch.best_standards_support = :builtin
+
+  # Do not compress assets
+  config.assets.compress = false if config.respond_to?(:assets)
+end