voluntary 0.0.1

data/lib/voluntary/helpers/collection.rb

@@ -0,0 +1,35 @@
+module Voluntary
+  module Helpers
+    module Collection
+      def table_cell column, resource, alternative_value = nil
+        value = '-'
+        
+        if column == 'name'
+          value = resource.send(column)
+          
+          if alternative_value.is_a?(Proc)
+            return alternative_value.call(resource)
+          elsif value.blank? && alternative_value.present? 
+            value = eval("resource.#{alternative_value}")
+          elsif value.blank?
+            value = '-'
+          end
+          
+          link_to value, eval("#{root_model_class_name(resource).tableize.singularize}_path(resource)")
+        elsif column.match('_id')
+          association = nil
+          
+          begin
+            association = resource.send(column.gsub('_id', '')) 
+          rescue 
+            association = eval("resource.#{alternative_value}") if alternative_value.present?
+          end
+          
+          association ? link_to(association.name, association) : value
+        else
+          resource.send(column) 
+        end
+      end
+    end
+  end
+end

data/lib/voluntary/helpers/comments.rb

@@ -0,0 +1,15 @@
+module Voluntary
+  module Helpers
+    module Comments
+      def nested_comments(comments)
+        comments.map do |comment, sub_comments|
+          next if comment.id.blank?
+          
+          content = render(partial: 'comments/resource', locals: { resource: comment }) 
+          content += content_tag(:div, nested_comments(sub_comments), class: 'nested_comments')
+          content
+        end.join.html_safe
+      end
+    end
+  end
+end

data/lib/voluntary/helpers/form.rb

@@ -0,0 +1,43 @@
+module Voluntary
+  module Helpers
+    module Form
+      def link_to_add_fields(name, f, association, options = {})
+        attributes = { 
+          "#{root_model_class_name(f.object).tableize.singularize}_id".to_sym => f.object.id
+        }
+        
+        new_object = if f.object.respond_to? "#{association.to_s.singularize}_class"
+          f.object.tasks.new(attributes)
+        else
+          f.object.send(association).new(attributes)
+        end
+        
+        id = new_object.object_id
+    
+        fields = f.fields_for(association, new_object, child_index: id) do |builder|
+          render_product_specific_partial_if_available(
+            new_object, "#{controller_name}/#{association.to_s.singularize}_fields",
+            f: builder
+          )
+        end
+        
+        data = {id: id, fields: fields.gsub("\n", '')}
+        data[:target] = options[:target] if options.has_key?(:target)
+            
+        link_to(name, '#', class: 'add_fields', data: data)
+      end
+      
+      def remove_fields(f)
+        if f.object.try(:new_record?)
+          link_to t('general.remove'), '#', class: 'remove_fields'
+        else
+          f.check_box(:_destroy) + f.label(:_destroy, t('general.destroy'))
+        end
+      end
+        
+      def autocomplete_input(f, field)
+        f.input "#{field}_name", input_html: { data: {autocomplete: eval("autocomplete_#{field.to_s.tableize}_path")} }
+      end
+    end
+  end
+end

data/lib/voluntary/helpers/language.rb

@@ -0,0 +1,19 @@
+module Voluntary
+  module Helpers
+    module Language
+      def available_language_options
+        options = []
+        
+        AVAILABLE_LANGUAGES.each do |locale, language|
+          options << [language, locale]
+        end
+        
+        options.sort_by { |o| o[0] }
+      end
+      
+      def all_language_options
+        User.languages.sort_by { |o| o[0] }
+      end
+    end
+  end
+end

data/lib/voluntary/helpers/layout.rb

@@ -0,0 +1,28 @@
+module Voluntary
+  module Helpers
+    module Layout
+      def breadcrumbs
+        result = render_navigation context: :main, renderer: :breadcrumbs_without_method_links, join_with: ' > '
+        result && result.split('<a').length > 2 ? result : ''
+      end
+      
+      def sidenav
+        result = render_navigation context: :main, renderer: :twitter_sidenav, level: @twitter_sidenav_level
+        result && result.split('<a').length > 2 ? result : ''
+      end
+      
+      def footer_navigation
+        links = []
+        
+        ['privacy-policy', 'terms-of-use', 'about-us'].each do |page_name|
+          text = t("pages.#{page_name.gsub('-', '_')}.title")
+          path = "#{controller_name}/#{params[:id]}"
+          active = path == "#{controller_name}/#{page_name}"
+          links << (active ? text : link_to(text, page_path(page_name)))
+        end
+        
+        raw links.join(' | ')
+      end
+    end
+  end
+end

data/lib/voluntary/helpers/product.rb

@@ -0,0 +1,36 @@
+module Voluntary
+  module Helpers
+    module Product
+      def render_product_specific_presenter_if_available(resource, partial_path, method, options = {})
+        if @presenter.respond_to?(method)
+          @step_presenter = @presenter.send(method) 
+        else
+          @step_presenter = nil
+        end
+        
+        render_product_specific_partial_if_available(resource, "#{partial_path}/#{method}", options)
+      end
+      
+      def render_product_specific_partial_if_available(resource, partial_path, options = {})
+        path = nil
+        partial_path = partial_path.split('/')
+        file_name = partial_path.pop
+        partial_path = partial_path.join('/')
+        
+        if resource && resource.respond_to?(:product) && resource.product
+          path = "products/types/#{directory_for_resource(resource.product)}/#{partial_path}"
+          
+          if File.exist?("#{Rails.root.to_s}/app/views/#{path}/_#{file_name}.html.erb")
+            path = [path, file_name].join('/')
+          else
+            path = nil
+          end
+        end
+    
+        path = [partial_path, file_name].join('/') if path.blank?
+    
+        render path, options 
+      end
+    end
+  end
+end

data/lib/voluntary/helpers/show.rb

@@ -0,0 +1,69 @@
+module Voluntary
+  module Helpers
+    module Show
+      def show_attributes(*attributes)
+        result = ''
+        
+        attributes.each {|attribute| result += show_attribute attribute}
+        
+        raw result
+      end
+      
+      def show_attribute(attribute, options = {})
+        title = options[:title] || attribute_translation(attribute)
+        value = options[:value] || resource.send(attribute)
+        
+        value.blank? ? '' : content_tag(:dt, title) + content_tag(:dd, value)
+      end
+      
+      def show_associations(*associations)
+        result = ''
+        
+        associations.each {|association| result += show_association association}
+        
+        raw result
+      end
+      
+      def show_association(association)
+        if association.to_s == association.to_s.pluralize
+          return show_attribute(
+            association,
+            title: t("#{association}.index.title"), 
+            value: raw(resource.send(association).map{|a| link_to a.name, a}.join(', '))
+          )
+        end
+        
+        title = if general_attribute?(:parent)
+          t("activerecord.attributes.general.#{association}")
+        else
+          if resource.send(association) 
+            t("activerecord.models.#{root_model_class_name(resource.send(association)).underscore}")
+          else 
+            t("activerecord.models.#{association}")
+          end
+        end
+        
+        if resource.send(association)
+          show_attribute(
+            association,
+            title: title, 
+            value: link_to(resource.send(association).try(:name), resource.send(association))
+          )  
+        else
+          ''
+        end
+      end
+      
+      def show_actions
+        result  = content_tag :dt, raw('&nbsp')
+        result += content_tag :dd, render(
+          partial: 'shared/resource/actions', locals: { 
+            type: root_model_class_name(resource).tableize, resource: resource 
+          }
+        )
+         
+        raw result
+      end
+    end
+  end
+end

data/lib/voluntary/helpers/wizard.rb

@@ -0,0 +1,31 @@
+module Voluntary
+  module Helpers
+    module Wizard
+      def section_header(wizard_step)
+        wizard_step_index = wizard_steps.index(wizard_step) + 1
+        
+        content = ["#{wizard_step_index} / #{wizard_steps.length}"] 
+        content << t("stories.steps.#{wizard_step}.title")
+        content << (future_step?(wizard_step) ? t('general.not_available') : '')
+        
+        content.join(' ')
+      end
+      
+      def step_pane(wizard_step)
+        return if future_step?(wizard_step)  
+        
+        partial_path = wizard_step == :initialization ? 'form' : "steps/#{wizard_step}"
+        
+        if @presenter.respond_to?(wizard_step)
+          @step_presenter = @presenter.send(wizard_step) 
+        else
+          @step_presenter = nil
+        end
+        
+        render_product_specific_partial_if_available(
+          resource, "#{controller_name}/#{partial_path}"
+        )
+      end
+    end
+  end
+end

data/lib/voluntary/version.rb

@@ -0,0 +1,3 @@
+module Voluntary
+  VERSION = "0.0.1"
+end

data/lib/wizard.rb

@@ -0,0 +1,58 @@
+module Wizard
+  module Controller
+    extend ActiveSupport::Concern 
+    
+    include Concerns::Steps
+    include Concerns::Paths
+    
+    included do
+      # Set step variables
+      before_filter :setup_wizard, only: [:new, :create, :edit, :update]
+    end
+    
+    private
+    
+    def setup_wizard
+      @step  = action_name.try(:to_sym)
+      
+      unless wizard_steps.include? @step
+        @step = nil
+        
+        step_from_event unless step_from_state
+        
+        @step = wizard_steps.first unless @step
+      end
+      
+      
+      
+      @previous_step = previous_step(@step)
+      @next_step = action_name.try(:to_sym) == @step ? @step : next_step(@step)
+    end
+    
+    def step_from_state
+      return false unless wizard_step_per_state.is_a?(Hash)
+       
+      state = resource.try(:state).try(:to_sym)
+      
+      return false unless state
+      
+      wizard_step_per_state.each do |step,states|
+        if states.include?(state)
+          @step = step
+          break
+        end
+      end
+      
+      return @step ? true : false    
+    end
+    
+    # TODO: just for backward compatibility purposes 
+    def step_from_event
+      @step = resource.try(:event).try(:to_sym)
+      
+      if @step && (!self.respond_to?(:current_step_is_next_step_after_event) || current_step_is_next_step_after_event) 
+        @step = next_step(@step)
+      end
+    end
+  end
+end

data/lib/wizard/controller/concerns/paths.rb

@@ -0,0 +1,31 @@
+module Wizard
+  module Controller
+    module Concerns
+      module Paths
+        extend ActiveSupport::Concern
+      
+        included do
+          # Give our Views helper methods!
+          helper_method :wizard_path, :next_wizard_path, :previous_wizard_path
+        end
+      
+        def next_wizard_path(options = {})
+          wizard_path(@next_step, options)
+        end
+      
+        def previous_wizard_path(options = {})
+          wizard_path(@previous_step, options)
+        end
+      
+        def wizard_path(goto_step = nil, options = {})
+          url_for(
+            { 
+              controller: controller_name, action: goto_step,
+              id: params[:id], only_path: true
+            }.merge options
+          )
+        end
+      end
+    end
+  end
+end

data/lib/wizard/controller/concerns/steps.rb

@@ -0,0 +1,142 @@
+module Wizard
+  module Controller
+    module Concerns
+      module Steps
+        extend ActiveSupport::Concern
+        
+        included do
+          # Give our Views helper methods!
+          helper_method :step,   :next_step,          :wizard_steps,     :current_step?,
+                        :past_step?,      :future_step?,     :previous_step?,
+                        :next_step?, :last_step?
+        end
+        
+        module ClassMethods
+          private
+          
+          def wizard_steps(*wizard_steps)
+            const_set 'WIZARD_STEPS', wizard_steps
+            
+            # TODO: clarify if we still need to generate actions when we have an update action and next_step trigger
+            "::#{self.to_s}::WIZARD_STEPS".constantize.each do |wizard_step|  
+              next if wizard_step == :initialization
+              
+              define_method wizard_step do
+                setup_wizard
+                
+                send("before_#{wizard_step}") if self.respond_to?("before_#{wizard_step}")
+                
+                wizard_resource = wizard_resource_class_name.constantize.find(params[:id])
+                resource_name = wizard_resource_class_name.underscore
+                resource.attributes = params[resource_name.to_sym] if params[resource_name.to_sym]
+                
+                if @story.send(next_step)
+                  redirect_to eval("#{next_step}_#{resource_name}_path(resource)")
+                else
+                  send("after_#{wizard_step}") if self.respond_to?("after_#{wizard_step}")
+                end
+              end
+            end
+          end
+          
+          def wizard_step_per_state(hash)
+            const_set 'WIZARD_STEP_PER_STATE', hash
+          end
+        end
+      
+        def wizard_steps
+          "#{controller_class_name}::WIZARD_STEPS".constantize
+        end
+        
+        def wizard_step_per_state
+          "#{controller_class_name}::WIZARD_STEP_PER_STATE".constantize rescue {}
+        end
+        
+        def wizard_resource_class_name
+          controller_name.classify
+        end
+      
+        def jump_to(goto_step)
+          @skip_to = goto_step
+        end
+      
+        def skip_step
+          @skip_to = @next_step
+        end
+      
+        def step
+          @step
+        end
+      
+        # will return true if step passed in is the currently rendered step
+        def current_step?(step_name)
+          return false if step_name.nil? || step.nil?
+          
+          step == step_name
+        end
+      
+        # will return true if the step passed in has already been executed by the wizard
+        def past_step?(step_name)
+          return false if wizard_steps.index(step).nil? || wizard_steps.index(step_name).nil?
+          
+          wizard_steps.index(step) > wizard_steps.index(step_name)
+        end
+      
+        # will return true if the step passed in has already been executed by the wizard
+        def future_step?(step_name)
+          return false if wizard_steps.index(step).nil? || wizard_steps.index(step_name).nil?
+          
+          wizard_steps.index(step) < wizard_steps.index(step_name)
+        end
+      
+        # will return true if the last step is the step passed in
+        def previous_step?(step_name)
+          return false if wizard_steps.index(step).nil? || wizard_steps.index(step_name).nil?
+          
+          wizard_steps.index(step) - 1  == wizard_steps.index(step_name)
+        end
+      
+        # will return true if the next step is the step passed in
+        def next_step?(step_name)
+          return false if wizard_steps.index(step).nil? || wizard_steps.index(step_name).nil?
+          
+          wizard_steps.index(step) + 1  == wizard_steps.index(step_name)
+        end
+       
+        def previous_step(current_step = nil)
+          return @previous_step if current_step == nil
+          
+          index =  wizard_steps.index(current_step)
+          step  =  wizard_steps.at(index - 1) if index.present? && index != 0
+          step ||= wizard_steps.first
+          
+          step
+        end
+      
+        def next_step(current_step = nil)
+          return @next_step if current_step == nil
+          
+          index = wizard_steps.index(current_step)
+          step  = wizard_steps.at(index + 1) if index.present?
+          step  ||= :finish
+          
+          step
+        end
+        
+        def last_step?(current_step = nil)
+          current_step = current_step || step
+          
+          current_step == wizard_steps.last
+        end
+        
+        private
+        
+        def controller_class_name
+          name = self.to_s.gsub(/#|<|>|#/, '').split(':').select{|e| !e.blank? }
+          name.pop
+          name.join('::')
+        end
+      end
+    end
+  end
+end