census 0.1.0

data/generators/census/templates/migrations/without_users.rb

@@ -0,0 +1,54 @@
+class CreateCensusTables < ActiveRecord::Migration
+  def self.up
+    create_table :data_groups do |t|
+      t.string  :name
+      t.integer :position
+      t.timestamps
+    end
+
+    create_table :questions do |t|
+      t.integer :data_group_id
+      t.string  :data_type
+      t.string  :prompt
+      t.boolean :multiple
+      t.boolean :other
+      t.integer :position
+      t.timestamps
+    end
+    
+    add_index :questions, :data_group_id
+    
+    create_table :choices do |t|
+      t.integer :question_id
+      t.string  :value
+      t.integer :position
+      t.timestamps
+    end
+    
+    add_index :choices, :question_id
+    
+    create_table :answers do |t|
+      t.integer :question_id
+      t.integer :user_id
+      t.string  :data
+    end
+    
+    add_index :answers, :question_id
+    add_index :answers, :user_id
+    
+  end
+
+  def self.down
+    remove_index :answers, :question_id
+    remove_index :answers, :user_id
+    drop_table :answers
+    
+    remove_index :choices, :question_id
+    drop_table :choices
+    
+    remove_index :questions, :data_group_id
+    drop_table :questions
+    
+    drop_table :data_groups
+  end
+end

data/generators/census/templates/user.rb

@@ -0,0 +1,3 @@
+class User < ActiveRecord::Base
+  include Census::User
+end

data/lib/census/data_type.rb

@@ -0,0 +1,33 @@
+module Census
+  class DataType
+    attr_accessor :name
+    attr_accessor :sql_transform
+    attr_accessor :format_data
+    attr_accessor :validate_data
+
+    @@data_types = []
+
+    def self.all
+      @@data_types
+    end
+    
+    def self.define(name, options = {})
+      @@data_types << DataType.new(name, options)
+    end
+    
+    def self.find(name)
+      @@data_types.select {|dt| dt.name == name}.try(:first)
+    end
+    
+    def initialize(name, options)
+      @name = name
+      @sql_transform  = options[:sql_transform] || lambda {|column_name| "#{column_name}"}
+      @format_data    = options[:format_data]   || lambda {|data| data}
+      @validate_data  = options[:validate_data] || lambda {|data| nil}
+    end
+    
+    def to_s
+      @name
+    end
+  end
+end

data/lib/census/user.rb

@@ -0,0 +1,85 @@
+module Census
+  module User
+    
+    # Hook for all Census::User modules.
+    #
+    # If you need to override parts of Census::User,
+    # extend and include à la carte.
+    #
+    # @example
+    #   extend ClassMethods
+    #   include InstanceMethods
+    #   include Callbacks
+    #
+    # @see ClassMethods
+    # @see InstanceMethods
+    # @see Callbacks
+    def self.included(model)
+      model.extend(ClassMethods)
+
+      model.send(:include, InstanceMethods)
+      model.send(:include, Associations)
+      model.send(:include, Callbacks)
+    end
+
+    module Associations
+      # Hook for defining associations.
+      def self.included(model)
+        model.class_eval do
+          has_many                      :answers, :dependent => :destroy
+          accepts_nested_attributes_for :answers, :reject_if => lambda { |a| a[:data].blank? }
+        end
+      end
+    end
+
+    module Callbacks
+      # Hook for callbacks.
+      #
+      # empty answers are removed after_save.
+      def self.included(model)
+        model.class_eval do
+          after_save :remove_empty_answers
+        end
+      end
+    end
+
+    module InstanceMethods
+      #
+      # Returns this user's first answer for the given question, or a new empty
+      # answer if the user has not answered the question.
+      #
+      def first_answer_for(question)
+        answers.select {|a| a.question == question}.first || answers.build(:question => question, :data => '')
+      end
+
+      #
+      # Returns an array of this user's answers for the given question. The returned
+      # array will be empty if the user has not answered this question.
+      #
+      def all_answers_for(question)
+        answers.select {|a| a.question == question}
+      end
+
+      #
+      # Returns this user's answer for a specific choice under a multiple-choice
+      # question, or a new empty answer if the user did not select the given choice.
+      #
+      def answer_for_choice(choice)
+        answers.select {|a| a.question == choice.question && a.data == choice.value}.first || answers.build(:question => choice.question, :data => '')
+      end
+
+      private
+
+      #
+      # After save callback, used to remove blank answers
+      #
+      def remove_empty_answers
+        answers.each {|answer| answer.destroy if answer.data.blank? }
+      end      
+    end
+
+    module ClassMethods
+    end
+
+  end
+end

data/lib/census.rb

@@ -0,0 +1 @@
+require 'census/user'

data/rails/init.rb

@@ -0,0 +1,7 @@
+require 'acts_as_list'
+require 'inverse_of'
+require 'census'
+
+config.to_prepare do
+  ApplicationController.helper(CensusHelper)
+end

data/shoulda_macros/census.rb

@@ -0,0 +1,35 @@
+module Census
+  module Shoulda
+
+    def should_accept_nested_attributes_for(*attr_names)
+      klass = self.name.gsub(/Test$/, '').constantize
+
+      context "#{klass}" do
+        attr_names.each do |association_name|
+          should "accept nested attrs for #{association_name}" do
+            meth = "#{association_name}_attributes="
+            assert  ([meth,meth.to_sym].any?{ |m| klass.instance_methods.include?(m) }),
+                    "#{klass} does not accept nested attributes for #{association_name}"
+          end
+        end
+      end
+    end
+    
+    def should_act_as_list
+      klass = self.name.gsub(/Test$/, '').constantize
+
+      context "To support acts_as_list" do
+        should_have_db_column('position', :type => :integer)
+      end
+
+      should "include ActsAsList methods" do
+        assert klass.include?(ActsAsList::InstanceMethods)
+      end
+
+      should_have_instance_methods :acts_as_list_class, :position_column, :scope_condition
+    end
+
+  end
+end
+
+Test::Unit::TestCase.extend(Census::Shoulda)

data/test/controllers/data_groups_controller_test.rb

@@ -0,0 +1,165 @@
+require 'test_helper'
+
+class DataGroupsControllerTest < ActionController::TestCase
+
+  tests Census::DataGroupsController
+  
+  should_route :get, '/census/admin',
+    :controller => 'census/data_groups', :action  => 'index'
+
+  should_route :get, '/census/data_groups/new',
+    :controller => 'census/data_groups', :action  => 'new'
+
+  should_route :post, '/census/data_groups',
+    :controller => 'census/data_groups', :action  => 'create'
+  
+  should_route :get, '/census/data_groups/1/edit',
+    :controller => 'census/data_groups', :action  => 'edit', :id => '1'
+
+  should_route :put, '/census/data_groups/1',
+    :controller => 'census/data_groups', :action  => 'update', :id => '1'
+
+  should_route :delete, '/census/data_groups/1',
+    :controller => 'census/data_groups', :action  => 'destroy', :id => '1'
+
+  context 'The Census::DataGroupsController' do
+    
+    context 'using GET to index' do
+    
+      setup do
+        @group = Factory(:data_group)
+        get :index
+      end
+    
+      should_respond_with               :success
+      should_respond_with_content_type  :html
+      should_render_template            :index
+      should_assign_to                  :data_groups
+    
+    end
+    
+    context 'using GET to new' do
+    
+      setup do
+        get :new
+      end
+    
+      should_respond_with               :success
+      should_respond_with_content_type  :html
+      should_render_template            :new
+      should_assign_to                  :data_group
+    
+      should 'have a new data group record' do
+        assert assigns(:data_group).new_record?
+      end
+    
+    end
+  
+    context 'using POST to create' do
+    
+      context 'with invalid attributes' do
+      
+        setup do
+          DataGroup.any_instance.stubs(:valid?).returns(false)
+          post :create, :data_group => Factory.attributes_for(:data_group)
+        end
+      
+        should_respond_with               :unprocessable_entity
+        should_respond_with_content_type  :html
+        should_render_template            :new
+        should_assign_to                  :data_group
+      
+        should 'not create the data group' do
+          assert assigns(:data_group).new_record?
+        end
+      
+      end
+    
+      context 'with valid attributes' do
+      
+        setup do
+          post :create, :data_group => Factory.attributes_for(:data_group)
+        end
+      
+        should_respond_with       :redirect
+        should_assign_to          :data_group
+        should_redirect_to('census admin page') { census_admin_url }
+      
+        should 'create the data group' do
+          assert !assigns(:data_group).new_record?
+        end
+      
+      end
+    
+    end
+  
+    context 'using GET to edit' do
+    
+      setup do
+        @group = Factory(:data_group)
+        get :edit, :id => @group.to_param
+      end
+    
+      should_respond_with               :success
+      should_respond_with_content_type  :html
+      should_render_template            :edit
+      should_assign_to(:data_group) { @group }
+    
+    end
+  
+    context 'using PUT to update' do
+    
+      context 'with valid attributes' do
+      
+        setup do
+          @group = Factory(:data_group)
+          put :update, :id => @group.to_param, :data_group => {:name => 'CHANGED'}
+        end
+      
+        should_respond_with           :redirect
+        should_assign_to(:data_group) { @group }
+        should_redirect_to('census admin page') { census_admin_url }
+      
+        should 'update the data group' do
+          assert_equal('CHANGED', @group.reload.name)
+        end
+      
+      end
+    
+      context 'with invalid attributes' do
+      
+        setup do
+          @group = Factory(:data_group)
+          DataGroup.any_instance.stubs(:valid? => false)
+          put :update, :id => @group.to_param, :data_group => {:name => 'CHANGED'}
+        end
+      
+        should_respond_with               :unprocessable_entity
+        should_respond_with_content_type  :html
+        should_assign_to(:data_group)     { @group }
+        should_render_template            :edit
+      
+      end
+    
+    end
+  
+    context 'using DELETE to destroy' do
+    
+      setup do
+        @group = Factory(:data_group)
+        delete :destroy, :id => @group.to_param
+      end
+    
+      should_respond_with             :redirect
+      should_assign_to(:data_group)   { @group }
+      should_redirect_to('census admin page') { census_admin_url }
+    
+      should 'destroy the data group' do
+        assert_nil(DataGroup.find_by_id(@group.id))
+      end
+    
+    end
+    
+  end
+  
+end

data/test/models/answer_test.rb

@@ -0,0 +1,44 @@
+require 'test_helper'
+
+class AnswerTest < ActiveSupport::TestCase
+
+  context "An Answer" do
+    
+    setup do
+      @answer = Factory(:answer)
+    end
+    
+    subject { @answer }
+
+    should_belong_to                :question
+    should_belong_to                :user
+  
+    should_validate_presence_of     :question,
+                                    :user
+  
+    should_allow_mass_assignment_of :data
+    
+    context "getting formatted data" do
+      
+      should "format strings" do
+        a = Factory(:answer, :question => Factory(:question, :data_type => 'String'), :data => 'abc123')
+        assert_equal 'abc123', a.formatted_data
+      end
+      
+      should "format numbers" do
+        a = Factory(:answer, :question => Factory(:question, :data_type => 'Number'), :data => '5389')
+        assert_equal 5389, a.formatted_data
+      end
+
+      should "format booleans" do
+        a = Factory(:answer, :question => Factory(:question, :data_type => 'Yes/No'), :data => '0')
+        assert_equal false, a.formatted_data
+        a.data = '1'
+        assert_equal true, a.formatted_data
+      end
+      
+    end
+    
+  end
+
+end

data/test/models/choice_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+class ChoiceTest < ActiveSupport::TestCase
+
+  context "A Choice" do
+    
+    setup do
+      @choice = Factory(:choice)
+    end
+    
+    subject { @choice }
+
+    should_belong_to                :question
+    
+    should_act_as_list
+
+    should_validate_presence_of     :value,
+                                    :question
+
+    should_allow_mass_assignment_of :value
+    
+  end
+  
+end

data/test/models/data_group_test.rb

@@ -0,0 +1,12 @@
+require 'test_helper'
+
+class DataGroupTest < ActiveSupport::TestCase
+
+  should_have_many                    :questions, :dependent => :destroy
+  should_accept_nested_attributes_for :questions
+
+  should_validate_presence_of         :name
+
+  should_act_as_list
+
+end

data/test/models/question_test.rb

@@ -0,0 +1,213 @@
+require 'test_helper'
+
+class QuestionTest < ActiveSupport::TestCase
+
+  context "A Question" do
+    
+    setup do
+      @question = Factory(:question)
+    end
+    
+    subject { @question }
+
+    should_belong_to                :data_group
+    should_have_many                :choices, :dependent => :destroy
+    should_have_many                :answers, :dependent => :destroy
+
+    should_act_as_list
+
+    should_validate_presence_of     :prompt,
+                                    :data_group
+    
+    should_allow_mass_assignment_of :data_type,
+                                    :prompt,
+                                    :multiple,
+                                    :other
+                                    
+    should_accept_nested_attributes_for :choices
+
+    should "return a default sql transform" do
+      assert '"?"', @question.sql_transform
+    end
+    
+    context "with choices" do
+      
+      setup do
+        @choice1 = Factory(:choice, :value => 'Choice 1', :question => @question)
+        @choice2 = Factory(:choice, :value => 'Choice 2', :question => @question)
+        @choice3 = Factory(:choice, :value => 'Choice 3', :question => @question)
+      end
+      
+      should "allow answers that match the choices" do
+        assert Factory.build(:answer, :question => @question, :data => 'Choice 1').valid?
+        assert Factory.build(:answer, :question => @question, :data => 'Choice 3').valid?
+      end
+      
+      should "not allow answers that don't match the choices" do
+        assert !Factory.build(:answer, :question => @question, :data => 'Blah').valid?
+      end
+
+      context "that allows user-supplied 'other' answer" do
+        
+        setup do
+          @question.update_attribute(:other, true)
+        end
+        
+        should "allow answers that don't match the choices" do
+          assert Factory.build(:answer, :question => @question, :data => 'Blah').valid?
+        end
+        
+      end
+      
+    end
+    
+    context "that can't have multiple answers" do
+      
+      setup do
+        @question.update_attribute(:multiple, false)
+        @user = Factory(:user)
+      end
+      
+      should "not be able to create multiple answers" do
+        assert @question.answers.create(:data => 'Answer 1', :user => @user)
+        assert !Factory.build(:answer, :question => @question, :data => 'Answer 2', :user => @user).valid?
+      end
+      
+    end
+    
+    context "that can have multiple answers" do
+      
+      setup do
+        @question.update_attribute(:multiple, true)
+      end
+      
+      should "be able to create multiple answers" do
+        assert @question.answers.create(:data => 'Answer 1')
+        assert @question.answers.create(:data => 'Answer 2')
+      end
+      
+    end
+    
+    context "with String data type" do
+
+      setup do
+        @question.data_type = 'String'
+      end
+      
+      should "return a default sql transform" do
+        assert_equal "?", @question.sql_transform
+      end
+
+      context "with answers" do
+
+        setup do
+          @answer1 = Factory(:answer, :question => @question, :data => 'findme')
+          @answer2 = Factory(:answer, :question => @question, :data => 'dont_findme')
+          @answer3 = Factory(:answer, :question => @question, :data => 'findme_too')        
+        end
+
+        should "find answers matching a given string" do
+          assert @question.find_answers_matching('findme').include?(@answer1)
+        end
+
+        should "not find answers not matching the given string" do
+          assert !@question.find_answers_matching('findme').include?(@answer2)
+        end
+
+        should "find answers matching an array of strings" do
+          result = @question.find_answers_matching(['findme', 'findme_too'])
+          assert result.include?(@answer1)
+          assert result.include?(@answer3)
+          assert !result.include?(@answer2)
+        end
+
+      end
+
+    end
+
+    context "with Number data type" do
+
+      setup do
+        @question.data_type = 'Number'
+      end
+
+      should "return an integer sql transform" do
+        assert_equal "CAST(? AS SIGNED INTEGER)", @question.sql_transform
+      end
+      
+      context "with answers" do
+
+        setup do
+          @answer1 = Factory(:answer, :question => @question, :data => '123')
+          @answer2 = Factory(:answer, :question => @question, :data => '125')
+          @answer3 = Factory(:answer, :question => @question, :data => '127')
+        end
+
+        should "find answers matching a given string" do
+          assert @question.find_answers_matching('123').include?(@answer1)
+        end
+
+        should "not find answers not matching the given string" do
+          assert !@question.find_answers_matching('123').include?(@answer2)
+        end
+
+        should "find answers matching a given number" do
+          assert @question.find_answers_matching(123).include?(@answer1)
+        end
+
+        should "not find answers not matching the given number" do
+          assert !@question.find_answers_matching(123).include?(@answer2)
+        end
+
+        should "find answers in a given range" do
+          result = @question.find_answers_matching(123..126)
+          assert result.include?(@answer1)
+          assert result.include?(@answer2)
+          assert !result.include?(@answer3)
+        end
+
+      end
+
+    end
+
+    context "with Yes/No data type" do
+
+      setup do
+        @question.data_type = 'Yes/No'
+      end
+
+      should "return a boolean sql transform" do
+        assert_equal "CAST(? AS CHAR)", @question.sql_transform
+      end
+
+      context "with answers" do
+
+        setup do
+          @answer1 = Factory(:answer, :question => @question)
+          @answer1.update_attribute(:data, false)
+          @answer2 = Factory(:answer, :question => @question, :data => true)
+        end
+
+        should "find answers matching true" do
+          assert @question.find_answers_matching(true).include?(@answer2)
+        end
+
+        should "not find answers not matching true" do
+          assert !@question.find_answers_matching(true).include?(@answer1)
+        end
+
+        should "find answers matching false" do
+          assert @question.find_answers_matching(false).include?(@answer1)
+        end
+
+        should "not find answers not matching false" do
+          assert !@question.find_answers_matching(false).include?(@answer2)
+        end
+
+      end
+
+    end
+
+  end
+      
+end

data/test/models/user_test.rb

@@ -0,0 +1,9 @@
+require 'test_helper'
+
+class UserTest < ActiveSupport::TestCase
+  
+  should_have_many                    :answers, :dependent => :destroy
+  should_accept_nested_attributes_for :answers
+  should_allow_mass_assignment_of     :answers_attributes
+
+end