voluntary 0.0.1

data/lib/generators/voluntary/install/templates/config/mongoid.yml

@@ -0,0 +1,78 @@
+development:
+  # Configure available database sessions. (required)
+  sessions:
+    # Defines the default session. (required)
+    default:
+      # Defines the name of the default database that Mongoid can connect to.
+      # (required).
+      database: volontariat_development
+      # Provides the hosts the default session can connect to. Must be an array
+      # of host:port pairs. (required)
+      hosts:
+        - localhost:27017
+      options:
+        # Change whether the session persists in safe mode by default.
+        # (default: false)
+        # safe: false
+
+        # Change the default consistency model to :eventual or :strong.
+        # :eventual will send reads to secondaries, :strong sends everything
+        # to master. (default: :eventual)
+        consistency: :strong
+  # Configure Mongoid specific options. (optional)
+  options:
+    # Configuration for whether or not to allow access to fields that do
+    # not have a field definition on the model. (default: true)
+    # allow_dynamic_fields: true
+
+    # Enable the identity map, needed for eager loading. (default: false)
+    # identity_map_enabled: false
+
+    # Includes the root model name in json serialization. (default: false)
+    # include_root_in_json: false
+
+    # Include the _type field in serializaion. (default: false)
+    # include_type_for_serialization: false
+
+    # Preload all models in development, needed when models use
+    # inheritance. (default: false)
+    # preload_models: false
+
+    # Protect id and type from mass assignment. (default: true)
+    # protect_sensitive_fields: true
+
+    # Raise an error when performing a #find and the document is not found.
+    # (default: true)
+    # raise_not_found_error: true
+
+    # Raise an error when defining a scope with the same name as an
+    # existing method. (default: false)
+    # scope_overwrite_exception: false
+
+    # Skip the database version check, used when connecting to a db without
+    # admin access. (default: false)
+    # skip_version_check: false
+
+    # User Active Support's time zone in conversions. (default: true)
+    # use_activesupport_time_zone: true
+
+    # Ensure all times are UTC in the app side. (default: false)
+    # use_utc: false
+test:
+  sessions:
+    default:
+      database: volontariat_test
+      hosts:
+        - localhost:27017
+      options:
+        consistency: :strong
+        
+production:
+  sessions:
+    default:
+      database: volontariat_production
+      hosts:
+        - localhost:27017
+      options:
+        consistency: :strong
+        

data/lib/generators/voluntary/install/templates/config/nginx.conf

@@ -0,0 +1,27 @@
+upstream unicorn {
+  server unix:/tmp/unicorn.volontariat.sock fail_timeout=0;
+}
+
+server {
+  listen 80 default deferred;
+  server_name volontari.at;
+  root /home/deployer/apps/volontariat/current/public;
+
+  location ^~ /assets/ {
+    gzip_static on;
+    expires max;
+    add_header Cache-Control public;
+  }
+
+  try_files $uri/index.html $uri @unicorn;
+  location @unicorn {
+    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+    proxy_set_header Host $http_host;
+    proxy_redirect off;
+    proxy_pass http://unicorn;
+  }
+
+  error_page 500 502 503 504 /500.html;
+  client_max_body_size 4G;
+  keepalive_timeout 10;
+}

data/lib/generators/voluntary/install/templates/config/unicorn.rb

@@ -0,0 +1,9 @@
+root = "/home/deployer/apps/volontariat/current"
+working_directory root
+pid "#{root}/tmp/pids/unicorn.pid"
+stderr_path "#{root}/log/unicorn.log"
+stdout_path "#{root}/log/unicorn.log"
+
+listen "/tmp/unicorn.volontariat.sock"
+worker_processes 2
+timeout 30

data/lib/generators/voluntary/install/templates/config/unicorn_init.sh

@@ -0,0 +1,84 @@
+#!/bin/sh
+### BEGIN INIT INFO
+# Provides:          unicorn
+# Required-Start:    $remote_fs $syslog
+# Required-Stop:     $remote_fs $syslog
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: Manage unicorn server
+# Description:       Start, stop, restart unicorn server for a specific application.
+### END INIT INFO
+set -e
+
+# Feel free to change any of the following variables for your app:
+TIMEOUT=${TIMEOUT-60}
+APP_ROOT=/home/deployer/apps/volontariat/current
+PID=$APP_ROOT/tmp/pids/unicorn.pid
+CMD="cd $APP_ROOT; bundle exec unicorn -D -c $APP_ROOT/config/unicorn.rb -E production"
+AS_USER=deployer
+set -u
+
+OLD_PIN="$PID.oldbin"
+
+sig () {
+  test -s "$PID" && kill -$1 `cat $PID`
+}
+
+oldsig () {
+  test -s $OLD_PIN && kill -$1 `cat $OLD_PIN`
+}
+
+run () {
+  if [ "$(id -un)" = "$AS_USER" ]; then
+    eval $1
+  else
+    su -c "$1" - $AS_USER
+  fi
+}
+
+case "$1" in
+start)
+  sig 0 && echo >&2 "Already running" && exit 0
+  run "$CMD"
+  ;;
+stop)
+  sig QUIT && exit 0
+  echo >&2 "Not running"
+  ;;
+force-stop)
+  sig TERM && exit 0
+  echo >&2 "Not running"
+  ;;
+restart|reload)
+  sig HUP && echo reloaded OK && exit 0
+  echo >&2 "Couldn't reload, starting '$CMD' instead"
+  run "$CMD"
+  ;;
+upgrade)
+  if sig USR2 && sleep 2 && sig 0 && oldsig QUIT
+  then
+    n=$TIMEOUT
+    while test -s $OLD_PIN && test $n -ge 0
+    do
+      printf '.' && sleep 1 && n=$(( $n - 1 ))
+    done
+    echo
+
+    if test $n -lt 0 && test -s $OLD_PIN
+    then
+      echo >&2 "$OLD_PIN still exists after $TIMEOUT seconds"
+      exit 1
+    fi
+    exit 0
+  fi
+  echo >&2 "Couldn't upgrade, starting '$CMD' instead"
+  run "$CMD"
+  ;;
+reopen-logs)
+  sig USR1
+  ;;
+*)
+  echo >&2 "Usage: $0 <start|stop|restart|upgrade|force-stop|reopen-logs>"
+  exit 1
+  ;;
+esac

data/lib/generators/voluntary/install/templates/db/seeds.rb

@@ -0,0 +1,14 @@
+# This file should contain all the record creation needed to seed the database with its default values.
+# The data can then be loaded with the rake db:seed (or created alongside the db with db:setup).
+#
+# Examples:
+#
+#   cities = City.create([{ name: 'Chicago' }, { name: 'Copenhagen' }])
+#   Mayor.create(name: 'Emanuel', city: cities.first)
+delivery_method_was = ActionMailer::Base.delivery_method
+ActionMailer::Base.delivery_method = :test
+
+db_seed = VolontariatSeed.new
+db_seed.create_fixtures
+
+ActionMailer::Base.delivery_method = delivery_method_was

data/lib/generators/voluntary/install/templates/features/step_definitions/email_steps.rb

@@ -0,0 +1,89 @@
+Before do
+  ActionMailer::Base.deliveries.clear
+end
+
+Given /^I have an empty inbox$/ do
+ ActionMailer::Base.deliveries.clear
+end
+
+Then /^(an|no) email should have been sent((?: |and|with|from "[^"]+"|to "[^"]+"|the subject "[^"]+"|the body "[^"]+"|the attachments "[^"]+")+)$/ do |mode, query|
+  conditions = {}
+  conditions[:to] = $1 if query =~ /to "([^"]+)"/
+  conditions[:from] = $1 if query =~ /from "([^"]+)"/
+  conditions[:subject] = $1 if query =~ /the subject "([^"]+)"/
+  conditions[:body] = $1 if query =~ /the body "([^"]+)"/
+  conditions[:attachments] = $1 if query =~ /the attachments "([^"]+)"/
+  
+  @mail = TestMails.find(conditions)
+  expectation = mode == 'no' ? 'should_not' : 'should'
+  @mail.send(expectation, be_present)
+end
+
+When /^I follow the (first|second|third)? ?link in the email$/ do |index_in_words|
+  # Caveat: will not only take a-href but also img-src and other http-values
+  mail = @mail || ActionMailer::Base.deliveries.last
+  # index = { nil => 0, 'first' => 0, 'second' => 1, 'third' => 2 }[index_in_words]
+  # visit mail.body.scan(Patterns::URL)[index][2]
+  visit mail.body.to_s.scan(/http(?:s?):\/\/[^"\s]+/).send(index_in_words).split(':3000').last
+end
+
+Then /^no email should have been sent$/ do
+  ActionMailer::Base.deliveries.should be_empty
+end
+ 
+Then /^show me the emails$/ do
+  #raise ActionMailer::Base.deliveries.length.inspect
+  puts "emails count:" + ActionMailer::Base.deliveries.length.inspect
+  
+  ActionMailer::Base.deliveries.each do |mail|
+    p [mail.from, mail.to, mail.subject, mail.body]
+  end
+end
+
+Then /^that mail should have "([^"]*)" in the body$/ do |word|
+  @mail.body.include?(word).should be_true
+end
+# 
+# 
+class TestMails
+  class << self
+
+    attr_accessor :user_identity
+
+    def find(conditions)
+      ActionMailer::Base.deliveries.detect do |mail|
+        [ conditions[:to].nil? || mail.to.include?(resolve_email conditions[:to]),
+          conditions[:from].nil? || mail.from.include?(resolve_email conditions[:from]),
+          conditions[:subject].nil? || mail.subject.include?(conditions[:subject]),
+          conditions[:body].nil? || mail.body.include?(conditions[:body]),
+          conditions[:attachments].nil? || conditions[:attachments].split(/\s*,\s*/).sort == Array(mail.attachments).collect(&:original_filename).sort
+        ].all?
+      end.tap do |mail|
+        puts "Die Mail: #{mail}" 
+        log(mail)
+      end
+    end
+
+    def resolve_email(identity)
+      if identity =~ /^.+\@.+$/
+        identity
+      else
+        User.send("find_by_#{user_identity || 'email'}!", identity).email
+      end
+    end
+
+    def log(mail)
+      puts "Aufruf: #{mail}" 
+      if mail.present?
+        File.open("log/test_mails.log", "a") do |file|
+          file << "From: #{mail.from}\n"
+          file << "To: #{mail.to.join(', ')}\n"
+          file << "Subject: #{mail.subject}\n\n"
+          file << mail.body
+          file << "\n-------------------------\n\n"
+        end
+      end
+    end
+
+  end
+end

data/lib/generators/voluntary/install/templates/features/step_definitions/factory_steps.rb

@@ -0,0 +1,120 @@
+module FactoryMethods
+  def create_from_table(model_name, table, extra = {})
+    factory_name = model_name.gsub(/\W+/, '_').downcase.singularize.to_sym
+    is_singular = model_name.to_s.singularize == model_name.to_s
+    
+    hashes = if is_singular
+       if table.kind_of?(Hash)
+         [table]
+       else
+         [table.rows_hash]
+       end
+     elsif table.is_a?(Array)
+       table
+     else
+       table.hashes
+     end
+            
+    @klass = factory_name.to_s.classify.constantize
+    @they = hashes.map do |hash|
+      hash = hash.merge(extra).inject({}) do |h,(k,v)|
+        k = k.gsub(/\W+/,'_')
+        
+        # mongo db model classes are not responding to serialized attributes
+        # TODO: take care of serialized attributes in future mongo db model implementations here
+        if @klass.respond_to?(:serialized_attributes) && @klass.serialized_attributes[k] == Array
+          v = v.split(/\s*,\s*/)
+        end
+        
+        h.update(k.to_sym => v)
+      end
+      
+      hash.keys.each do |attribute|
+        set_value(hash, attribute)
+      end
+      
+      eval("set_#{factory_name}_defaults(hash)") if "#{factory_name.to_s.classify}FactoryMethods".constantize rescue nil
+      
+      object = nil
+      
+      object = @klass.where(name: hash[:name]).first if hash.has_key? :name
+      object = object ? object : Factory.build(factory_name, hash)
+      
+      yield object if block_given?
+      
+      object.save!
+      
+      object
+    end
+    
+    if is_singular
+      @it = @they.last
+      instance_variable_set("@#{factory_name}", @it)
+    end
+  end
+  
+  private
+  
+  def set_value(hash, attribute)
+    value = hash[attribute]
+    
+    if value.match '@' 
+      if eval(value)
+        hash[attribute] = eval(value) 
+      else
+        hash.delete attribute
+      end
+    elsif @klass.reflections.values.select{|v| v.macro == :belongs_to }.map(&:name).include? attribute
+      reflection_value = @klass.reflections.values.select{|v| v.name == attribute }.first
+      
+      if reflection_value.options[:polymorphic]
+        polymorphic_type = "#{@klass.name}::#{attribute.to_s.upcase}_TYPES".constantize.first
+        resource = polymorphic_type.classify.constantize.find_by_name(value)
+        hash[attribute] = resource || create_from_table(polymorphic_type.tableize, [{ 'name' => value }])
+      else
+        resource = attribute.to_s.classify.constantize.find_by_name(value)
+        hash[attribute] = resource || create_from_table(attribute.to_s.tableize, [{ 'name' => value }])
+      end
+    end
+  end
+end
+
+World(FactoryMethods)
+
+Given %r{^I have a (.+)$} do |model_name|
+  create_from_table(model_name, {}, 'user' => @me)
+end
+
+Given %r{^I have the following (.+):$} do |child, table|
+  step "that me has the following #{child}:", table
+end
+
+Given %r{^the following (.+):$} do |model_name, table|
+  create_from_table(model_name, table)
+end
+
+Given %r{^that (.+) has the following (.+):$} do |parent, child, table|
+  child= child.gsub(/\W+/,'_')
+  parent = parent.gsub(/\W+/,'_').downcase.sub(/^_/, '')
+  parent_instance = instance_variable_get("@#{parent}")
+  parent_class = parent_instance.class
+  
+  if assoc = parent_class.reflect_on_association(child.to_sym) || parent_class.reflect_on_association(child.pluralize.to_sym)
+    parent = (assoc.options[:as] || parent).to_s
+    child = (assoc.options[:class_name] || child).to_s
+  end
+  
+  if child.classify.constantize.method_defined?(parent.pluralize)
+    create_from_table(child, table, parent.pluralize => [parent_instance])
+  elsif child.classify.constantize.method_defined?(parent)
+    create_from_table(child, table, parent => parent_instance)
+  else
+    create_from_table(child, table)
+    
+    if assoc.macro == :has_many
+      parent_instance.send("#{assoc.name}=", @they)
+    else
+      parent_instance.send("#{assoc.name}=", @they.first)
+    end
+  end
+end

data/lib/generators/voluntary/install/templates/features/step_definitions/javascript_steps.rb

@@ -0,0 +1,15 @@
+When /^I confirm all future JS confirm dialogs on this page$/ do
+  page.evaluate_script('window.confirm = function() { return true; }')
+end
+
+When /^I cancel all future JS confirm dialogs on this page$/ do
+  page.evaluate_script('window.confirm = function() { return false; }')
+end
+
+When /^I confirm popup$/ do
+  page.driver.browser.switch_to.alert.accept    
+end
+
+When /^I dismiss popup$/ do
+  page.driver.browser.switch_to.alert.dismiss
+end