voluntary 0.0.1

data/lib/applicat/mvc/controller/error_handling.rb

@@ -0,0 +1,40 @@
+module Applicat
+  module Mvc
+    module Controller
+      module ErrorHandling
+        #include Applicat::Errors
+        
+        def self.included(base)
+          if Rails.env != 'development'
+            base.class_eval do          
+              rescue_from Applicat::Mvc::Controller::ErrorHandling::NoPermissionError do |e|
+                response_for_error 403
+              end
+                 
+              rescue_from ActiveRecord::RecordNotFound do |e|
+                response_for_error 404
+              end
+              
+              private
+              
+              def response_for_error(status)
+                respond_to do |f|
+                  # Show a neat html page inside the app's layout for web users
+                  f.html { render :template => "errors/#{status}", :status => status }
+            
+                  # Everything else (JSON, XML, YAML, Whatnot) gets a blank page with status
+                  # which can then be understood and processed by the API client, 
+                  # JavaScript library (on Ajax) etc.
+                  f.all { render :nothing => true, :status => status }
+                end
+              end
+            end
+          end
+        end
+        
+        class NoPermissionError < StandardError
+        end
+      end
+    end
+  end
+end

data/lib/applicat/mvc/controller/resource.rb

@@ -0,0 +1,19 @@
+module Applicat::Mvc::Controller::Resource
+  def self.included(base)
+    base.class_eval do
+      helper_method :parent, :resource
+      
+      include InstanceMethods
+    end
+  end
+  
+  module InstanceMethods
+    def autocomplete
+      render json: (
+        controller_name.classify.constantize.
+        select(:name).order(:name).where("name LIKE ?", "%#{params[:term]}%").
+        map(&:name)
+      )
+    end
+  end
+end

data/lib/applicat/mvc/controller/transition_actions.rb

@@ -0,0 +1,43 @@
+module Applicat::Mvc::Controller::TransitionActions
+  extend ActiveSupport::Concern
+
+  private
+  
+  def fire_event(event, pass_event_to_assignment = false)
+    authorize! event, resource
+    
+    #if params[resource.class.name.underscore.to_sym]
+    #  resource.trigger = params[resource.class.name.underscore.to_sym][:trigger]
+    #end
+    
+    resource.send(event)
+    
+    if resource.errors.full_messages.any?
+      redirect_to :back, alert: resource.errors.full_messages.join(',')
+    else
+      redirect_to :back, notice: I18n.t('general.form.successfully_updated')  
+    end
+  end
+  
+  module ClassMethods
+    private
+    
+    def transition_actions(*actions)
+      actions = actions.first.is_a?(Symbol) ? actions : actions.first
+      
+      actions.each do |action|  
+        define_method action do
+          alternative_transition = nil
+         
+          alternative_transition = send "before_#{action}" if self.respond_to?("before_#{action}")
+          
+          alternative_transition = alternative_transition.is_a?(Symbol) ? alternative_transition : nil
+          
+          fire_event(alternative_transition || action) and return
+          
+          send "after_#{action}" if self.respond_to?("after_#{action}")
+        end
+      end
+    end
+  end
+end

data/lib/applicat/mvc/model/resource/base.rb

@@ -0,0 +1,56 @@
+module Applicat
+  module Mvc
+    module Model
+      module Resource
+        module Base
+          def self.included(base)
+            base.class_eval do
+              #has_many :role_assignments, :class_name => 'Role', :as => :authorizable
+              
+              cattr_reader :per_page
+              @@per_page = 20
+  
+              attr_accessor :current_user
+              
+              if self.table_exists?
+                #reflections.values.select{|r| [:has_one, :has_many].include?(r.macro)}.map(&:name)
+                
+                columns.map(&:name).select{|c| c.match('_id')}.each do |column|
+                  association = column.split('_id').first.classify
+                  
+                  define_method "#{association.underscore}_name" do
+                    self.send("#{association.underscore}").try(:name)
+                  end
+                  
+                  accessible_attributes << "#{association.underscore}_name"
+                  
+                  define_method "#{association.underscore}_name=" do |name|
+                    return if name.blank?
+                    
+                    association_type = association
+                    
+                    if self.class.columns.map(&:name).include?("#{association.underscore}_type")
+                      association_type = self.send("#{association.underscore}_type")
+                    end
+                    
+                    self.send("#{association.underscore}=", association_type.constantize.find_or_initialize_by_name(name))
+                  end
+                end
+              end
+              
+              #def role_for?(role_name, user)
+              #  return true if new_record?
+              # 
+              #  role_assignments.joins(:users).where('roles.name = ? AND users.id = ?', role_name, user.id).any?
+              #end
+      
+              def to_s
+                self.name rescue self.class.name.humanize
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/applicat/mvc/model/tokenable.rb

@@ -0,0 +1,24 @@
+module Applicat::Mvc::Model::Tokenable
+  extend ActiveSupport::Concern 
+  
+  included do
+    
+  end
+  
+  module ClassMethods
+    def tokens(query)
+      collection = where("name like ?", "%#{query}%")
+      
+      if collection.empty?
+        [{id: "<<<#{query}>>>", name: "#{I18n.t('general.new')}: \"#{query}\""}]
+      else
+        collection
+      end
+    end
+  
+    def ids_from_tokens(tokens)
+      tokens.gsub!(/<<<(.+?)>>>/) { create!(name: $1).id }
+      tokens.split(',')
+    end
+  end
+end

data/lib/applicat/mvc/model/tree.rb

@@ -0,0 +1,82 @@
+module Applicat
+  module Mvc
+    module Model
+      module Tree
+        def self.included(base)
+          base.class_eval do
+            has_ancestry :cache_depth => true, :orphan_strategy => :rootify
+
+            acts_as_list
+
+            default_scope :order => 'position'
+            
+            def add_child(element,position=nil)
+              #need to add errors to @element.errors and return something
+              temp = element.children
+              element.ancestry = self.child_ancestry
+              element.position = position || siblings.to_i + 1
+              element.save
+              return element.update_children(temp)
+            end
+            
+            # Accepts the typical array of ids from a scriptaculous sortable. It is called on the instance being moved
+            def sort(array_of_ids)
+              if array_of_ids.first == id.to_s
+                move_to_left_of siblings.find(array_of_ids.second)
+              else
+                move_to_right_of siblings.find(array_of_ids[array_of_ids.index(id.to_s) - 1])
+              end
+            end
+            
+            def move_to_child_of(reference_instance)
+              transaction do
+                remove_from_list
+                self.update_attributes!(:parent => reference_instance)
+                add_to_list_bottom
+                save!
+              end
+            end
+            
+            def move_to_left_of(reference_instance)
+              transaction do
+                remove_from_list
+                reference_instance.reload # Things have possibly changed in this list
+                self.update_attributes!(:parent_id => reference_instance.parent_id)
+                reference_item_position = reference_instance.position
+                increment_positions_on_lower_items(reference_item_position)
+                self.update_attribute(:position, reference_item_position)
+              end
+            end
+            
+            def move_to_right_of(reference_instance)
+              transaction do
+                remove_from_list
+                reference_instance.reload # Things have possibly changed in this list
+                self.update_attributes!(:parent_id => reference_instance.parent_id)
+                if reference_instance.lower_item
+                  lower_item_position = reference_instance.lower_item.position
+                  increment_positions_on_lower_items(lower_item_position)
+                  self.update_attribute(:position, lower_item_position)
+                else
+                  add_to_list_bottom
+                  save!
+                end
+              end   
+            end
+            
+            protected
+            
+            def update_children(children)
+              children.each do |child|
+                temp = child.children
+                child.ancestry = self.child_ancestry
+                child.save!
+                return child.update_children(temp)
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/db_seed.rb

@@ -0,0 +1,150 @@
+require 'faker'
+
+class DbSeed
+  USER_ROLES = {}
+  
+  attr_accessor :logger, :user_roles
+  
+  def initialize(options = {logger: nil})
+    self.logger = options[:logger]
+  end
+  
+  def create_fixtures
+    create_roles
+    create_users
+    create_user_roles
+  end
+  
+  protected
+  
+  def users
+    return @users if @users
+    
+    @users = {}
+    
+    self.class::USER_ROLES.each do |role,attributes|
+      @users[role] = attributes
+      @users[role][:id] = User.find_by_name(role.to_s.humanize).id
+    end
+    
+    @users
+  end
+  
+  # roles 
+  # TODO: define methods through USER_ROLES
+  def user
+    @user ||= User.find(user_id)
+  end
+  
+  def user_id
+    @user_id ||= users[:user][:id]
+  end
+  
+  def tenant
+    @tenant ||= User.find(tenant_id)
+  end
+  
+  def tenant_id
+    @tenant_id ||= users[:tenant][:id]
+  end
+  
+  def log(message, type = :info)
+    if logger 
+      logger.send(type, message)
+    else
+      puts message
+    end
+  end
+  
+  def create_roles
+    Role.import([:name], self.class::USER_ROLES.keys.map{|role| [role.to_s.humanize]})
+    
+    self.class::USER_ROLES.keys.each do |role|
+      attributes = { name: role.to_s.humanize, public: [:project_owner, :user].include?(role) }
+      
+      "Role::#{role.to_s.classify}".constantize.create(attributes)
+    end
+  end
+  
+  def create_users
+    self.class::USER_ROLES.each do |role, settings|
+      attributes = {
+        name: role.to_s.humanize, first_name: 'Mister', last_name: role.to_s.humanize, email: "#{role}@volontari.at",
+        password: "#{role}2012", language: 'en', country: 'Germany', interface_language: 'en'
+      }
+      attributes[:password_confirmation] = attributes[:password]
+      create_record(User, attributes, events: ['skip_confirmation!'])
+    end
+  end
+  
+  def create_user_roles
+    UserRole.import(
+      [:role_id, :user_id], users.keys.map{|r| [Role.find_by_name(r.to_s.humanize).id, users[r][:id]]}
+    )
+  end
+  
+  private
+  
+  def create_record(klass, attributes, options = {})
+    options.assert_valid_keys(:events)
+    
+    klass = klass.constantize if klass.is_a?(String)
+    events = options[:events] || []
+    
+    record = klass.new
+    
+    (attributes || {}).each {|attribute,value| record.send("#{attribute}=", value) }
+    
+    send_events(record, events) if events.any?
+    
+    record.save! if record.new_record?
+    
+    record
+  end
+  
+  def send_events(object, events = [])
+    events.each {|event| send_event(object, event) }
+  end
+  
+  def send_event(object, event)
+    object_was = object
+    event_condition_class = "::DbSeed::EventConditions::#{object.class.table_name.classify}".constantize rescue nil
+    arguments = nil
+      
+    if event.is_a?(Array)
+      arguments = event
+      event = arguments.shift
+      
+      if event == 'assignment'
+        # TODO: YAGNI?
+        object_was = object
+        object = object.send(event)
+        event = arguments.shift
+        arguments = nil if arguments.none?
+      end
+    elsif event.is_a?(Proc)
+      event.call(object)
+      
+      return
+    end
+    
+    if event_condition_class && event_condition_class.respond_to?("before_#{event.gsub('!', '')}")
+      conditions_arguments = arguments.is_a?(Array) ? [object] + arguments : [object]
+      event_condition_class.send("before_#{event.gsub('!', '')}", *conditions_arguments)
+    end
+
+    if event_condition_class && event_condition_class.respond_to?(event.gsub('!', ''))
+      # override event method through event condition class
+      event_condition_class.send(event.gsub('!', ''), object)      
+    else
+      arguments ? object.send(event, *arguments) : object.send(event)
+    end
+    
+    if event_condition_class && event_condition_class.respond_to?("after_#{event.gsub('!', '')}")
+      conditions_arguments = arguments.is_a?(Array) ? [object] + arguments : [object]
+      event_condition_class.send("after_#{event.gsub('!', '')}", *conditions_arguments)
+    end
+    
+    object = object_was
+  end
+end

data/lib/environment_configuration.rb

@@ -0,0 +1,54 @@
+# Copyright (c) 2010-2011, Diaspora Inc.  This file is
+# licensed under the Affero General Public License version 3 or later.  See
+# the COPYRIGHT file.
+
+module EnvironmentConfiguration
+
+  def self.heroku?
+    ENV['HEROKU']
+  end
+
+  def self.secret_token_initializer_is_not_present?
+    !File.exists?( Rails.root.join('config', 'initializers', 'secret_token.rb'))
+  end
+
+  def self.prevent_fetching_community_spotlight?
+    return true if heroku?
+    !ActiveRecord::Base.connection.table_exists?('projects') || Rails.env == 'test'
+  end
+
+  def self.cache_git_version?
+    !self.heroku?
+  end
+
+  def self.ensure_secret_token!
+    if heroku?
+      puts 'heroku app detected; using session secret from config vars...'
+      Rails.application.config.secret_token = ENV['SECRET_TOKEN'] 
+    elsif secret_token_initializer_is_not_present?
+      `rake generate:secret_token`
+      require  Rails.root.join('config', 'initializers', 'secret_token.rb')
+    else
+      #do nothing
+    end
+  end
+
+  def self.enforce_ssl?
+    return false unless Rails.env == 'production'
+    return false if ENV['NO_SSL'] 
+    return false if AppConfig[:circumvent_ssl_requirement].present?
+    true
+  end
+
+  def self.ca_cert_file_location
+    if self.heroku?
+      "/usr/lib/ssl/certs/ca-certificates.crt"
+    else
+      AppConfig[:ca_file]
+    end
+  end
+
+  def self.using_new_relic?
+    defined?(NewRelic) && AppConfig['NEW_RELIC_LICENSE_KEY'].present?
+  end
+end