spyro 0.0.2

data/lib/spyro/collections/parsers/array.rb

@@ -0,0 +1,38 @@
+require_relative "active_record_relation"
+
+module Spyro
+  module ActionViewExtension
+
+    module CollectionForHelper
+      module Parser
+        class Array < Parser::ActiveRecordRelation
+          @@types[::Array] = self
+
+          def initialize model, helper, options
+            super
+            @array = @collection
+          end
+
+          def parse
+            if @array.first.try(:is_a?, ActiveRecord::Base)
+              super
+              return
+            end
+            if @unicollection.rows.empty?
+              @array.each do |row|
+                @unicollection.row do |r|
+                  [*row].each do |elem|
+                    r.add_elem UniData::Element.new(value: elem, name: "header", type: elem.class)
+                  end
+                end
+              end
+            end
+
+            @unicollection.add_meta :header, @unicollection.meta[:data]
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/spyro/collections/parsers/base.rb

@@ -0,0 +1,60 @@
+
+module Spyro
+  module ActionViewExtension
+
+    module CollectionForHelper
+      module Parser
+        class Base
+
+          mattr_accessor :types
+          attr_accessor :unicollection
+
+          delegate :polymorphic_path, :edit_polymorphic_path, to: :@h
+
+          @@types = {}
+
+          def initialize collection, helper, options
+            @h = helper
+            @collection = collection
+            @options = options
+
+            @unicollection = UniData::Collection.new
+            options.each do |key, value|
+              @unicollection.add_meta key, value
+            end
+          end
+
+          def link model_belong
+            final_link = polymorphic_path([@options[:parents].first, model_belong]) rescue nil
+            final_link = polymorphic_path([*@options[:parents], model_belong]) rescue nil if final_link.nil?
+            final_link
+          end
+
+          def hash_for_name model, name
+            #value = model[name] # en vrai
+            value = model.send(name) # intra
+
+            if name =~ /(.+)_id$/
+              model_belong = model.send($1) rescue nil
+              if model_belong
+                link = link(model_belong) rescue nil
+                return {value: model_belong.try(:to_desc) || model_belong.try(:name) || model_belong.id,
+                        type: String, name: name, db_type: String, link: link}
+              end
+            end
+            {value: value, type: value.class, name: name, db_type: (model.has_attribute?(name) ? model.type_for_attribute(name) : nil)}
+          end
+
+          def method_missing method, args
+            @unicollection.add_meta method, args
+          end
+
+          def parse_default
+          end
+
+        end
+      end
+    end
+
+  end
+end

data/lib/spyro/collections/parsers/kaminari_array.rb

@@ -0,0 +1,38 @@
+# require_relative "array"
+
+# require "rubygems"
+# require "kaminari/models/array_extension"
+
+# module Spyro
+#   module ActionViewExtension
+
+#     module CollectionForHelper
+#       module Parser
+#         class KaminariArray < Array
+#           @@types[::Kaminari::PaginatableArray] = self
+
+#           def initialize *args
+#             super
+
+#             header [:id, :login, :email], :actions => true
+#           end
+
+#           def parse
+#             @array.each do |model|
+#               @unicollection.row do |r|
+#                 @unicollection.meta[:data].each do |name|
+#                   hash = hash_for_name model, name
+#                   hash[:link] = link model if name == :name
+#                   r.add_elem UniData::Element.new(hash)
+#                 end
+#                 r.add_elem_meta :actions, populate_actions(model, r, @options, [:show, :edit, :destroy])
+#                 r.add_elem_meta :id, model.id
+#               end
+#             end
+#           end
+
+#         end
+#       end
+#     end
+#   end
+# end

data/lib/spyro/collections/parsers/model.rb

@@ -0,0 +1,31 @@
+require_relative "base"
+
+module Spyro
+  module ActionViewExtension
+    module CollectionForHelper
+      module Parser
+        class Model < Parser::Base
+          @@types[::ActiveRecord::Base] = self
+
+          def initialize model, helper, options
+            super
+            @model = @collection
+            @unicollection.add_meta :model_class, model.class
+            @unicollection.add_meta :show, polymorphic_path([*options[:parents], model]) rescue nil
+          end
+
+          def parse
+            (@unicollection.meta[:data] || @model.attributes).each do |name, val|
+              @unicollection.row do |r|
+                hash = hash_for_name(@model, name)
+                r.add_elem UniData::Element.new(value: name, name: "header", type: String, translate: true)
+                r.add_elem UniData::Element.new(hash)
+              end
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/spyro/controllers/strong_parameted.rb

@@ -0,0 +1,33 @@
+
+module StrongParametedAddOn
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+
+    # Strong parameted
+    def strong_parameted attrs = nil
+      cattr_accessor :strong_attributes
+
+      model = self.name.to_s[0..-11].split('::').last.singularize
+      model_sym = model.underscore.to_sym
+      if attrs
+        attrs.map! {|elem| (elem == :all ? (model.constantize.column_names - ['id', 'updated_at', 'created_at']).map!(&:to_sym) : elem) }
+      else
+        attrs = (model.constantize.column_names - ['id', 'updated_at', 'created_at']).map!(&:to_sym)
+      end
+
+      self.strong_attributes = attrs
+
+      define_method :resource_params do
+        return [] if request.get?
+        model_hash = params.require(model_sym)
+        return (model_hash.respond_to?(:permit) ? [model_hash.permit(attrs)] : [])
+      end
+    end
+
+  end
+end
+
+class ActionController::Base
+  include StrongParametedAddOn
+end

data/lib/spyro/engine.rb

@@ -0,0 +1,6 @@
+module Spyro
+  class Engine < ::Rails::Engine
+    p "Spyro 🐉"
+    isolate_namespace Spyro
+  end
+end

data/lib/spyro/filters_controller_add_on.rb

@@ -0,0 +1,161 @@
+
+module FiltersControllerAddOn
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    {paginated: :page, ordered: :order}.each do |method, value|
+      define_method "is_#{method}?" do
+        !!scopes_configuration[value]
+      end
+    end
+
+    def paginate
+      has_scope :page, :default => 1, :only => [:index], :if => lambda {|c| (c.params[:format].try(:to_sym) || :html).in? [:html, :js] }
+    end
+
+    def paginated
+      paginate
+    end
+
+    # in:name CPP in:campus a
+    def searched *args # recode moi avec `or` avec Rails 5 :'(
+      cattr_accessor :searched_keys
+      cattr_accessor :searched_args
+
+      self.searched_keys = args.map {|arg| (arg.is_a?(Hash) ? arg.to_a[0].first : arg)}
+      self.searched_args = args
+
+      has_scope :search, :only => [:index] do |controller, scope, values|
+        sql = values.reverse.split(/\s+(?!\S+:\S+)/).map(&:reverse).reverse.map do |value| # feinte du variable-length look behind
+          in_search, value = value.match(/(in:(?<filter>\S+)\s+)?(?<search>.+)/).values_at 1, 2
+
+          sql = args.map do |arg|
+            key = (arg.is_a?(Hash) ? arg.to_a[0].first : arg)
+            next if !in_search.nil? and in_search != key.to_s
+
+            if arg.is_a? Hash
+              scope.instance_exec(value, &(arg.to_a[0].last)).to_sql
+            else
+              scope.where("#{resource_class.table_name}.#{arg} ilike ?", "%#{value}%").to_sql
+            end
+          end.reject(&:blank?)
+
+          sql = (sql.any? ? sql.join(' UNION ') : scope.where("1=0").to_sql)
+          resource_class.from("(#{sql}) #{resource_class.table_name}").to_sql
+        end
+
+        sql = (sql.any? ? sql.join(' INTERSECT ') : scope.where("1=0").to_sql)
+
+        resource_class.from("(#{sql}) #{resource_class.table_name}")
+      end
+    end
+
+    def ranged *args
+      cattr_accessor :ranged_keys
+      cattr_accessor :ranged_values
+      cattr_accessor :ranged_args
+
+      args = args.map {|arg| arg.is_a?(Hash) ? arg.to_a[0] : [arg, nil]}.to_h
+      self.ranged_keys = args.keys
+      self.ranged_values = self.ranged_keys.map {|k| [k, (args[k] ? args[k][2].call : resource_class.min_max(k))] }.to_h
+      self.ranged_args = args
+
+      has_scope :range, :only => [:index] do |controller, scope, values| #http://localhost:3000/exams?range=created_at:2015-06-03%2000:00%3bmax_people:50,100&sort=name
+        values.split(";").each do |value|
+          name, min, max = *value.match(/(\w+):([^,]+)?,?([^,]+)?/).values_at(1, 2, 3)
+          if name.to_sym.in? args.keys
+            scopes = args[name.to_sym]
+            if scopes
+              scope = scope.instance_exec(min, &(scopes[0])) if min
+              scope = scope.instance_exec(max, &(scopes[1])) if max
+            else
+              scope = scope.where("#{resource_class.table_name}.#{name} >= ?", min) if min
+              scope = scope.where("#{resource_class.table_name}.#{name} <= ?", max) if max
+            end
+          end
+        end
+
+        scope
+      end
+    end
+
+    def filtered *args #filter=campus:Cluj;
+      cattr_accessor :filtered_keys
+      cattr_accessor :filtered_values
+      cattr_accessor :filtered_args
+
+      args = args.map {|arg| arg.is_a?(Hash) ? arg.to_a[0] : [arg, nil]}.to_h
+      self.filtered_keys = args.keys
+      self.filtered_values = self.filtered_keys.map {|k| [k, (args[k] ? args[k][1].call : resource_class.pluck(k).uniq)] }.to_h
+      self.filtered_args = args
+
+      has_scope :filter, :only => [:index] do |controller, scope, values|
+        values.split(";").each do |value|
+          name, filter = *value.split(':', 2)
+          if name.to_sym.in? args.keys
+            scopes = args[name.to_sym]
+            if scopes
+              scope = scope.instance_exec(filter.split(','), &(scopes[0]))
+            else
+              scope = scope.where(name => filter.split(','))
+            end
+          end
+        end
+
+        scope
+      end
+    end
+
+
+    def ordered *args
+      cattr_accessor :ordered_keys
+      cattr_accessor :ordered_options
+
+      self.ordered_options = (args.count > 1 ? args.extract_options! : {})
+      def self.execute_order value, scope, keys, args, desc
+        value = keys.first unless keys.include? value.to_sym
+
+        my_scope = args.find {|arg| arg.is_a?(Hash) and arg[value.to_sym]}
+        scope = if my_scope
+          scope.instance_exec &(my_scope[value.to_sym])
+        else
+          scope.order(value.to_sym)
+        end
+
+        if desc
+          scope = (scope.respond_to?(:desc) ? scope.desc : scope.reverse_order)
+        end
+        scope = execute_order(keys.first, scope, keys, args, ordered_options[:default] == :desc) unless value.to_sym == keys.first.to_sym
+
+        return scope
+      end
+
+      args = [*args].flatten
+      keys = args.flat_map {|arg| arg.is_a?(Hash) ? arg.map(&:first) : arg}.map(&:to_sym)
+      self.ordered_keys = keys
+
+      raise "Missing params" if keys.empty? or (keys.length == 1 and keys.first.to_sym == :default)
+      raise "Bad value for default" if self.ordered_options and !self.ordered_options[:default].in? [nil, :desc]
+
+      has_scope :order, :default => keys.first.to_s, :only => [:index], as: :sort do |controller, scope, value|
+        if !controller.params[:sort].blank? or controller.params[:rev_sort].blank?
+          execute_order(value, scope, keys, args, false).send((controller.params[:sort].nil? and self.ordered_options[:default] == :desc) ? :desc : :all)
+        else
+          scope.all
+        end
+      end
+
+      has_scope :rev_order, :default => keys.first.to_s, :only => [:index], as: :rev_sort do |controller, scope, value|
+        if !controller.params[:rev_sort].blank? and controller.params[:sort].blank?
+          execute_order(value, scope, keys, args, true)
+        else
+          scope.all
+        end
+      end
+    end
+  end
+end
+
+class ActionController::Base
+  include FiltersControllerAddOn
+end

data/lib/spyro/helpers/action_view_extension.rb

@@ -0,0 +1,726 @@
+
+
+module Spyro
+  module ActionViewExtension
+
+    def default_destroy_link_attributes
+      {:data => {:confirm => "Are you sure?", :method => "delete", :'confirm-title' => "Confirmation"}}
+    end
+
+    module BasicWidgetsHelper
+      def mini_button name, link, options = {}
+        options[:class] = (options[:class] || []) + ['btn-xs', 'btn', 'btn-default']
+        button name, link, options
+      end
+
+      [:danger, :success, :warning, :primary, :info, :inverse].each do |klass|
+        define_method "mini_button_#{klass}" do |name, link, options = {}|
+          options[:class] = ([*options[:class]] || []) + ['btn-xs', 'btn', "btn-#{klass}"]
+          button name, link, options
+        end
+      end
+
+      alias_method :mini_button_error, :mini_button_danger
+
+      def button name, link, options = {}
+        @has_button = true
+        options[:class] ||= ['btn btn-default']
+        text = ""
+        text = I18n.t("#{params[:controller].gsub('/', '.')}.#{params[:action]}.button.#{name.downcase}", :default => I18n.t("scaffold.buttons.#{name.downcase}", :default => name.to_s.humanize)) unless name.blank?
+        text = "<span class='glyphicon glyphicon-#{options[:icon]}'></span>#{text}".html_safe if options[:icon]
+        link_to text, link, options
+      end
+
+      [:danger, :success, :warning, :primary, :info, :inverse].each do |klass|
+        define_method "button_#{klass}" do |name, link, options = {}|
+          options[:class] = [*options[:class]]
+          options[:class] << "btn btn-#{klass}"
+          button name, link, options
+        end
+      end
+
+      alias_method :button_error, :button_danger
+
+      def group &block
+        @has_group = true
+        capture_haml do
+          haml_tag :div, :class => ['btn-group'] do
+            haml_concat capture(&block)
+          end
+        end
+      end
+
+      def alert text, options = {}
+        @has_alert = true
+        options[:class] ||= ['alert']
+        capture_haml do
+          haml_tag :div, options do
+            haml_concat text
+          end
+        end
+      end
+
+      [:danger, :success, :warning, :action, :info, :inverse].each do |klass|
+        define_method "alert_#{klass}" do |text, options = {}|
+          options[:class] ||= ['alert', "alert-#{klass}"]
+          alert text, options
+        end
+      end
+
+      alias_method :alert_error, :alert_danger
+
+    end
+
+    module HeadersHelper
+      def header name = "", &block
+        if @inside_box
+          box_header name, &block
+        else
+          page_header name, &block
+        end
+      end
+
+      def page_header name, &block
+        @has_group = false
+
+        content_for :title do
+          name
+        end
+
+        capture_haml do
+          haml_tag :h1, :class => ['page-header'] do
+            haml_concat name
+            if block_given?
+              haml_tag :div, :class => ['pull-right'] do
+                content = capture(&block)
+                haml_concat (@has_group ? content : group { content })
+              end
+              haml_tag :div, :class => ['clear']
+            end
+          end
+        end
+      end
+
+      def box_header name, &block
+        @has_group = false
+
+        capture_haml do
+          haml_tag :div, :class => ["panel-heading"] do
+            haml_tag :div, :class => "row" do
+              haml_tag :div, :class => "col-lg-12" do
+                haml_tag :h2, :class => ["panel-title", 'col-sm-8'], :style => "padding: 8px 0px;" do
+                  haml_concat name
+                end
+                if block_given?
+                  haml_tag :div, :class => ['controls', 'col-sm-4', 'text-right'] do
+                    content = capture(&block)
+                    haml_concat (@has_group ? content : group { content })
+                  end
+                  haml_tag :div, :class => ['clear']
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    module ContainerHelper
+      def box opts = {}, &block
+        @inside_box = true
+        opts[:html] ||= {}
+        opts[:html][:class] = [*opts[:html][:class], "panel", "panel-default"]
+        content = capture_haml do
+          haml_tag :div, opts[:html] do
+            #        haml_tag :div, :class => "caption" do
+            content = capture(&block)
+            haml_concat content
+            #       end
+          end
+        end
+        @inside_box = false
+        content
+      end
+    end
+
+
+    module TabsHelper
+      def tabs
+        @tabs = {}
+
+        def tab name, options = {}, &block
+          @tabs[name] = options.merge :content => capture(&block)
+        end
+
+        yield
+
+        capture_haml do
+          haml_tag :ul, :class => "nav nav-tabs nav-justified", role: "tablist" do
+            @tabs.keys.each_with_index do |name, index|
+              haml_tag :li, :class => (index == 0 ? "active" : "") do
+                haml_concat link_to(name, "##{name}", "data-toggle" => "tab")
+              end
+            end
+          end
+
+          haml_tag :div, :class => "tab-content" do
+            @tabs.each_with_index do |(name, values), index|
+              haml_tag :div, :id => name, :class => ["tab-pane", (index == 0 ? "active" : "")] do
+                haml_concat values[:content]
+              end
+            end
+          end
+        end
+      end
+    end
+
+    module BreadCrumbHelper
+      def breadcrumb opts = {}
+        def format_class arg
+          arg.to_s.parameterize.underscore.downcase
+        end
+
+        elems = []
+        part_parents = []
+
+        elems << {:link => opts[:root], :label => "Root", :class => "root"} if opts[:root]
+
+
+        parents.compact.each do |elem|
+          part_parents << elem
+          elems << {:link => polymorphic_path([opts[:namespace], *part_parents]), :label => elem.to_desc, :class => "action_show #{format_class elem.class}"}
+        end
+
+
+        if params[:id]
+          elems << {:link => polymorphic_path([opts[:namespace], *part_parents, resource_class]), :label => resource_class.to_s.pluralize.titleize, :class => "action_index #{format_class resource_class}"}
+          elems << {:label => resource.to_desc, :active => true, :class => "action_#{params[:action]} #{format_class resource_class}"}
+        else
+          elems << {:label => resource_class.to_s.humanize.pluralize.titleize, :active => true, :class => "action_#{params[:action]} #{format_class resource_class}"}
+        end
+
+        "<ol class='breadcrumb'>#{elems.map { |elem|
+          html_class = elem[:class] || format_class(elem[:label])
+          elem[:active] ? "<li class='active #{html_class}'>#{elem[:label]}</li>" : "<li class='#{html_class}'>#{link_to elem[:label], elem[:link]}</li>"
+        }.join("")}</ol>".html_safe
+      end
+    end
+
+
+    module ProgressBarHelper
+      def progress prct
+        <<EOP
+        <div class="progress">
+          <div class="progress-bar" role="progressbar" aria-valuenow="#{prct}"
+                                    aria-valuemin="0" aria-valuemax="100"
+                                    style="width: #{prct}%;">
+          </div>
+        </div>
+EOP
+      end
+    end
+
+
+    module WidgetsHelper
+      include BreadCrumbHelper
+      include BasicWidgetsHelper
+      include TabsHelper
+      include HeadersHelper
+      include ContainerHelper
+      include ProgressBarHelper
+    end
+
+    module ApplicationHelper
+      include WidgetsHelper
+
+      def parents
+        [*(respond_to?(:association_chain) ? (association_chain) : ([]))]
+      end
+
+      def basic_params
+        params.dup.keep_if {|k, _| [:action, :controller, /_id$/].any? {|elem| elem === k }}
+      end
+
+      def menu
+        params_dup = Hash[*params.keys.keep_if { |key| key.ends_with? "_id" }.map { |elem| [elem, nil] }.flatten]
+        (ActiveRecord::Base.connection.tables - ["schema_migrations"]).sort.map do |name|
+          url_for(params_dup.merge(:controller => name.pluralize, :action => :index)) rescue nil if can? :index, name.classify.constantize rescue nil
+        end.compact.map { |name| content_tag :li, (link_to (name.split('/').last || "Root").humanize, name) }.join.html_safe
+      end
+
+      def mime_types controller
+        mimes = []
+        (controller || "#{params[:controller].pluralize}_controller".classify.constantize).mimes_for_respond_to.each do |key, values|
+          mimes << key if (values[:only] == nil or values[:only].include? params[:action]) and (values[:expect] == nil or !values[:expect].include? params[:action])
+        end
+        mimes
+      end
+
+      def download_mime_type_btns controller = nil, &block
+        if download_mime_types(controller).size == 1
+          if block_given?
+            link = block.call(download_mime_types(controller).first) rescue nil
+          else
+            link = collection_url(format: download_mime_types(controller).first) rescue nil
+          end
+
+          button "Download as #{download_mime_types(controller).first}", link if link
+        elsif download_mime_types(controller).size > 1
+          res = link_to "#", :class => 'btn btn-default dropdown-toggle', :'data-toggle' => 'dropdown' do
+            ("Download " + content_tag(:span, "", :class => "caret")).html_safe
+          end
+          res + content_tag(:ul, :class => "dropdown-menu") do
+            download_mime_types(controller).map do |mime|
+              if block_given?
+                link = block.call(mime) rescue nil
+              else
+                link = collection_url(format: mime) rescue nil
+              end
+              content_tag :li, (link_to "as #{mime}", link) if link
+            end.join('').html_safe
+          end
+        end
+      end
+
+      def download_mime_types(controller)
+        @mimes = {}
+        @mimes[controller] ||= mime_types(controller)
+        @mimes[controller] & [:csv, :xls]
+      end
+
+      def sorted_header table, args = [], options = {}
+        table.header args, options do |header, text|
+          if @order_attributes and header.to_s.in? @order_attributes
+            params_dup = params.dup
+            params_dup[:order] = header
+            if params_dup[:desc]
+              params_dup.delete :desc
+            else
+              params_dup[:desc] = true if params[:order] == header.to_s
+            end
+            link_to text, url_for(params_dup)
+          else
+            text
+          end
+        end
+      end
+
+      def vertical_form_for(record, options={}, &block)
+        backup = SimpleForm.form_class
+        SimpleForm.form_class = options[:form_class]
+        result = simple_form_for(record, options, &block)
+        SimpleForm.form_class = backup
+        result
+      end
+
+      def associations klass, macro
+        klass = klass.to_s.classify.constantize if Symbol === klass
+
+        klass.reflections.select { |s, r| s and r.macro == macro }
+      end
+
+    end
+
+
+    module CollectionForHelper
+      module UniData
+        class Collection
+          attr_reader :rows, :meta
+
+          def initialize
+            @rows = []
+            @meta = {}
+          end
+
+          def add_meta key, meta
+            @meta[key] = meta
+          end
+
+          def try_add_meta key, meta
+            @meta[key] ||= meta
+          end
+
+          def has_meta? key
+            !@meta[key].nil?
+          end
+
+          def row &block
+            @rows << {:data => [], :meta => {}}
+
+            def add_elem elem
+              @rows.last[:data] << elem
+            end
+
+            def add_elem_meta key, value
+              @rows.last[:meta][key] = value
+            end
+
+            block.call self
+          end
+
+          def to_s
+            "rows: #{@rows} ; meta: #{@meta}"
+          end
+        end
+
+        class Element
+          @@vars = [:value, :name, :type, :link, :as, :translate, :db_type, :html]
+          attr_accessor *@@vars
+
+          def initialize opts = {}
+            @@vars.each do |var|
+              self.send("#{var}=", opts[var]) if opts[var]
+            end
+          end
+
+          def to_s
+            s = @@vars.map do |var|
+              "#{var}: #{self.send(var)}"
+            end.join(" ; ")
+
+            "(#{s})"
+          end
+        end
+      end
+
+      def collection_for collection, options = {}, &block
+        parser = nil
+
+        Parser::Base.types.each do |klass_collection, klass_parser|
+          parser = klass_parser.new collection, self, options if collection.is_a? klass_collection
+        end
+
+        return if parser.nil?
+
+        output = "Spyro::ActionViewExtension::CollectionForHelper::Output::#{(options[:output] || :table).to_s.classify}".constantize
+
+        if block_given?
+          block.call parser
+        end
+
+        parser.parse
+#        p parser.unicollection
+
+        output.new(parser.unicollection, self, parser.class).render
+      end
+    end
+
+    module CollectionForHelper
+      def sortable_header header
+        if controller.ordered_keys.include? header
+          params_dup = params.dup
+          default_sort = controller.ordered_keys.first
+          sort = params_dup.delete :sort
+          rev_sort = params_dup.delete :rev_sort
+          css_class = ''
+
+          if sort
+            css_class = "sort" if sort.to_sym == header.to_sym
+          elsif rev_sort
+            css_class = "sort rev" if rev_sort.to_sym == header.to_sym
+          elsif default_sort.to_sym == header.to_sym
+            css_class = "sort#{controller.ordered_options[:default] == :desc ? ' rev' : ''}"
+          end
+
+          params_dup[:rev_sort] = params_dup[:sort] = nil
+          if css_class == "sort"
+            params_dup[:rev_sort] = header
+          else
+            params_dup[:sort] = header
+          end
+
+          link_to header.to_s.humanize, url_for(params_dup), class: css_class
+        else
+          header.to_s.humanize
+        end
+      end
+
+      include CollectionForHelper::Parser
+      include CollectionForHelper::Output
+    end
+
+    module ApplicationHelper
+      include CollectionForHelper
+    end
+
+    module D3Helper
+      def d3pie data
+        data.map { |label, value| {label: label, value: value} }.to_json
+      end
+
+      def d3bar data, opts = {}
+        default_values = opts[:range].to_a.map { |i| {label: i, value: 0} } if opts[:range]
+
+        data.map do |key, values|
+          values = (values.map { |key, value| {label: key, value: value} } + (default_values || [])).uniq { |a| a[:label] }.sort { |a, b| a[:label] <=> b[:label] }
+          {key: key, values: values}
+        end.to_json
+      end
+
+      def d3line data, opts = {}
+        opts = {:field => :created_at, :interval => 3.hours}.merge opts
+        data.map do |key, values|
+          values = values.order(opts[:field]).pluck(opts[:field])
+          break {} if values.empty?
+          start, res, count = values.first, [[(values.first - opts[:interval]).to_i * 1000, 0]], 0
+          values.each do |vote|
+            if vote.between?(start, start + opts[:interval])
+              count += 1
+            else
+              res.push [start.to_i * 1000, count]
+              start, count = start + opts[:interval], 0
+            end
+          end
+          res.push [start.to_i * 1000, count], [(start + opts[:interval]).to_i * 1000, 0]
+          {key: key, values: res}
+        end.to_json
+      end
+    end
+
+    module ApplicationHelper
+      include D3Helper
+
+      def app_name
+        @cache_app_name ||= Rails.application.class.parent_name.underscore
+      end
+    end
+
+    module ProjectsHelper
+
+      def get_project_status_icon project, user = current_user, opts = {}
+        # @TODO mettre des vraies icons, fuck pour l'instant
+        ""
+      end
+
+      def get_project_status_text project, user = current_user, opts = {class: ""}
+        s = get_project_status(project, user, opts)
+        get_uncached_project_status_text(s, project)
+      end
+
+      def get_uncached_project_status_text status, project, opts = {class: ""}
+        case status
+        when :not_registered
+          "<span class='#{opts[:class]} #{opts[:class]}-default'>Not registered</span>"
+        when :searching_a_group
+          "<span class='#{opts[:class]} #{opts[:class]}-default'>searching a group</span>"
+        when :finished
+          "<span class='#{opts[:class]} #{opts[:class]}-success'>finished</span>"
+        when :in_progress
+          "<span class='#{opts[:class]} #{opts[:class]}-warning'>in progress</span>"
+        when :waiting_for_correction
+          "<span class='#{opts[:class]} #{opts[:class]}-success'>waiting for correction</span>"
+        when :waiting_to_start
+           "<span class='#{opts[:class]} #{opts[:class]}-default'>waiting to start (<span data-long-date='#{project.begin_at}'></span>)</span>"
+        when :in_progress
+          "<span class='#{opts[:class]} #{opts[:class]}-warning'>in progress</span>"
+        when :creating_group
+          "<span class='#{opts[:class]} #{opts[:class]}-default'>creating group</span>"
+        when :parent
+          "<span class='project-status-icon project-status-parent'></span>"
+        else
+          "<span class='project-status-icon project-status-no-idea'></span>"
+        end
+      end
+
+
+      # Va renvoyer juste le texte, avec du cache
+      def get_project_status project, user = current_user, opts = {}
+        cache [project, user.id, (!project.begin_at.nil? and project.begin_at.future?), opts] do
+          get_uncached_project_status project, current_user, opts
+        end
+      end
+
+
+      # Va renvoyer juste le texte
+      def get_uncached_project_status project, user = current_user, opts = {}
+        raise "The hash need has_children, team and pu keys" unless (opts.has_key?(:has_children) and opts.has_key?(:team) and opts.has_key?(:pu))
+        if opts[:pu].nil?
+          :not_registered
+        elsif opts[:team].nil? and not opts[:has_children]# and user.teams.where(:project_id => project.id).empty?
+          :searching_a_group
+        elsif opts[:team]
+          if opts[:team].closed?
+            if opts[:team].final_mark
+              :finished
+            elsif opts[:has_children]
+              :in_progress
+            else
+              :waiting_for_correction
+            end
+          elsif opts[:team].locked?
+            if project.begin_at and project.begin_at.future?
+              :waiting_to_start
+            else
+              :in_progress
+            end
+          else
+            :creating_group
+          end
+
+        elsif opts[:has_children]
+          :parent
+        else
+          :unknown
+        end
+      end
+
+      # View Helper.......
+      def project_progress_percentage project, user = User.current_user
+        progr = {:recommended_pct => 0, :warning_pct => 0, :success_pct => 0}
+
+        has_estimations = (project.estimate_time)
+        has_begin_at = !project.begin_at.nil?
+        has_project_user = project.ar_projects_user(user).any?
+
+        return progr unless (has_estimations or project.begin_at) and has_project_user
+
+        if project.begin_at
+          start = Time.zone.now.to_i - project.begin_at.to_i
+          progr[:recommended_pct] = ((start * 100) / (project.end_at.to_i - project.begin_at.to_i))
+          progr[:recommended_pct] = 100 if progr[:recommended_pct] > 100
+        else
+          start = Time.zone.now - project.ar_projects_user(user).first.created_at
+          progr[:recommended_pct] = (start * 100) / project.estimate_time
+
+          if progr[:recommended_pct] > 100
+            progr[:recommended_pct] = ((project.estimate_time * 100) / project.estimate_time)
+            progr[:warning_pct] = ((start * 100) / project.estimate_time) - progr[:recommended_pct]
+            progr[:warning_pct] = 100 - progr[:recommended_pct] if progr[:warning_pct] > (100 - progr[:recommended_pct])
+          end
+
+          if project.finished?
+            progr[:success_pct] = 100 - (progr[:recommended_pct] + progr[:warning_pct])
+          end
+
+        end
+
+        return progr
+      end
+
+    end
+
+
+    module ReleaseHelper
+
+      # Helper de l'enfer
+      def release_at date, &block
+        if date.past? or not Rails.env.production? or User.current_user.try(:has_role?, :intrateam)
+          block.call
+        end
+      end
+    end
+
+    module ForumHelper
+      def url_for_message m
+        base = "#{Rails.application.config.module_url['forum']}/topics/#{m.messageable_id}/messages"
+        page, ref = m.get_coordinates(can?(:read_deleted, Message))
+        return "#{base}?page=#{page}##{ref}"
+      end
+    end
+
+    module FeatureHelper
+      def feature name, &block
+        if User.current_user.has_feature? name
+          capture(&block)
+        else
+          ""
+        end
+      end
+    end
+
+    module EtecHelper
+      def user_eta user
+        user_experiences = Experience.joins(:skill).where(user_id: user.id).where(cursus_id: 1).order(:created_at)
+
+        # TROLOLO
+        return Time.zone.now + 150.years if user_experiences.empty?
+
+        xp = user_experiences.sum(:experience) # nb d'XP total aujourd'hui pour l'étudiant
+        first_xp = user_experiences.first.experience # la premiere entree d'XP pour un etudiant (la plus ancienne donc)
+        date_first_xp = user_experiences.first.created_at # la date de cette premiere entree
+
+        estimated_end_date_from_xp(xp, first_xp, date_first_xp)
+      end
+
+      def estimated_end_date_from_xp xp, first_xp, date_first_xp
+        return Time.zone.now + 150.years if date_first_xp.nil?
+
+        current_weekly_xp = Math.log(1 + xp.to_f / 50 / 180) * 235
+        first_weekly_xp = Math.log(1 + first_xp.to_f / 50 / 180) * 235
+
+        weeks = (Time.zone.now - date_first_xp).to_i / 1.week
+        weeks = 1 if weeks == 0
+        ratio = (current_weekly_xp - first_weekly_xp) / weeks
+        if ratio > 0
+          ((182 - current_weekly_xp) / ratio).weeks.from_now
+        else
+          Time.zone.now + 150.years
+        end
+      end
+
+      def user_accel_eta user
+        user_experiences = Experience.where(user_id: user.id).where(cursus_id: 1).order(:created_at)
+        xp = user_experiences.sum(:experience) # nb d'XP total aujourd'hui pour l'étudiant
+        earlier_xp = user_experiences.where("created_at < ?", 5.weeks.ago).sum(:experience) # nb d'XP qu'avait l'etudiant il y a 5 semaines
+        first_xp = user_experiences.first.experience # la premiere entree d'XP pour un etudiant (la plus ancienne donc)
+        date_first_xp = user_experiences.first.created_at # la date de cette premiere entree
+
+        estimated_accel_from_xp(xp, earlier_xp, first_xp, date_first_xp)
+      end
+
+      def estimated_accel_from_xp xp, earlier_xp, first_xp, date_first_xp
+        current_weekly_xp = Math.log(1 + xp.to_f / 50 / 180) * 235
+        earlier_weekly_xp = Math.log(1 + earlier_xp.to_f / 50 / 180) * 235
+        first_weekly_xp = Math.log(1 + first_xp.to_f / 50 / 180) * 235
+
+        ratio = (current_weekly_xp - earlier_weekly_xp) / 5
+        if ratio > 0
+          date1 = ((182 - current_weekly_xp) / ratio).weeks.from_now
+        else
+          date1 = nil
+        end
+
+        date2 = estimated_end_date_from_xp(xp, first_xp, date_first_xp)
+
+        if (date2 - date1).weeks > 4
+          1
+        elsif (date2 - date1).weeks < -4
+          -1
+        else
+          0
+        end
+      end
+    end
+
+    module PageTitle
+      def page_title key, options
+        prefix = I18n.t('page_title.prefix', :raise => true) rescue []
+        suffix = I18n.t('page_title.suffix', :raise => true) rescue []
+
+        key = [*key]
+        title = ""
+        while key.any? and title.blank?
+          title = I18n.t(['page_title', *key].join('.'), :raise => true) rescue nil
+          key.pop if key.last == "default"
+          key[-1] = "default" if key.any?
+        end
+
+        title = (title.blank? ? options[:default] : [prefix, title, suffix].flatten.compact.join(options[:separator] || ' - '))
+        title.gsub(/\{\{([^\}]+)\}\}/) { $1.split('.').inject(self) { |base, method| base.send(method) } }
+      rescue
+        options[:default].gsub(/\{\{([^\}]+)\}\}/) { $1.split('.').inject(self) { |base, method| base.send(method) } }
+      end
+    end
+
+    module ApplicationHelper
+      include ProjectsHelper
+      include ReleaseHelper
+      include ForumHelper
+      include FeatureHelper
+      include EtecHelper
+      include PageTitle
+    end
+
+    include ApplicationHelper
+  end
+end