kono_utils 1.0.1 → 1.1.0

data/app/assets/stylesheets/kono_utils/{_kono_styles.css.scss → core.css.scss}

@@ -1,3 +1,4 @@
+
 .kono_delete_button, .kono_edit_button {
   margin: 1px;
   &.align-right {
@@ -8,22 +9,6 @@
   }
 }
 
-.search_panel {
-  .panel-title {
-    .icon-search {
-      cursor: pointer;
-    }
-  }
-}
-
-.bs_file_download {
-  .form-wrapper {
-    display: block;
-    .input-group{
-      width:100%;
-    }
-  }
-}
 
 //classi per una spaziatura verticale , utilizzare
 // passando la classe generale v-space e poi il valore scelto: space-x1

data/app/policies/kono_utils/base_editing_policy_concern.rb

@@ -5,10 +5,59 @@ module KonoUtils
     extend ActiveSupport::Concern
 
     included do
+
+      ##
+      # elenco degli attributi filtrati alla ricezione nel controller
+      # @return [Array<Symbol>]
       def permitted_attributes
-        # [:descrizione]
+        cleard_columns+virtual_appended_attributes
+      end
+
+      ##
+      # elenco attributi editabili nella form
+      # @return [Array<Symbol>]
+      def editable_attributes
+        cleard_columns
+      end
+
+      ##
+      # elenco attributi visualizzabili nella show
+      # @return [Array<Symbol>]
+      def displayable_attributes
+        editable_attributes
+      end
+
+      ##
+      # Elenco attributi da visualizzare, utilizzati nella vista della index
+      # @return [Array<Symbol>]
+      def show_attributes
+        cleard_columns
+      end
+
+      private
+
+      def cleard_columns
         record.class.column_names.collect { |s| s.to_sym } - [:id, :created_at, :updated_at]
       end
+
+      ##
+      # Elenco di attributi generati dinamicamente da KonoUtils.
+      # Come ad esempio l'attributo per la cancellazione del file allegato
+      # @return [Array<Symbol>]
+      def virtual_appended_attributes
+        out = []
+        if record.class.respond_to?(:attribute_purger_name)
+          record.class.instance_methods.each do |c|
+            next if c.match(/=$/) #skippiamo per i writers
+            if record.respond_to?(record.class.attribute_purger_name(c))
+              Rails.logger.debug c.inspect
+              out << record.class.attribute_purger_name(c)
+            end
+          end
+        end
+        out
+      end
+
     end
 
     if defined? ::Application::Scope
@@ -19,9 +68,9 @@ module KonoUtils
       end
     end
 
-#  module ClassMethods
+    #  module ClassMethods
 
-#  end
+    #  end
   end
 end
 

data/app/policies/kono_utils/base_search_form_policy_concern.rb

@@ -0,0 +1,25 @@
+require 'active_support/concern'
+module KonoUtils
+
+  module BaseSearchFormPolicyConcern
+    extend ActiveSupport::Concern
+
+    included do
+
+      ##
+      # elenco degli attributi filtrati alla ricezione nel controller
+      def permitted_attributes
+        record.search_attributes.collect(&:field)
+      end
+
+      alias_method :editable_attributes, :permitted_attributes
+
+    end
+
+
+#  module ClassMethods
+
+#  end
+  end
+end
+

data/config/locales/it.yml

@@ -15,4 +15,6 @@ it:
       messages:
         created: "%{model} creato correttamente."
         updated: "%{model} aggiornato correttamente."
-        destroyed: "%{model} è stato correttamente cancellato."
+        destroyed: "%{model} è stato correttamente cancellato."
+  kono_utils:
+    user_not_authorized: Utente non autorizzato a modificare %{model}

data/lib/generators/kono_utils/install/install_generator.rb

@@ -19,12 +19,49 @@ module KonoUtils
       copy_file 'initializer.rb', 'config/initializers/kono_utils.rb'
     end
 
+    def install_pundit
+      run "rails g pundit:install"
+    end
+
+    def install_helper_on_application_helper
+      inject_into_file 'app/helpers/application_helper.rb', "\n  include KonoUtils::ApplicationHelper", after: "module ApplicationHelper"
+    end
+
+    def install_active_record_traslation_on_application_record
+      inject_into_file 'app/models/application_record.rb', "\n  include KonoUtils::Concerns::ActiveRecordTranslation\n", after: "ActiveRecord::Base"
+      inject_into_file 'app/models/application_record.rb', "\n  include KonoUtils::Concerns::ActiveStorageRemoverHelper\n", after: "ActiveRecord::Base"
+    rescue Exception => e
+      puts "Attenzione, includere a mano:
+               - KonoUtils::Concerns::ActiveRecordTranslation
+               - KonoUtils::Concerns::ActiveStorageRemoverHelper
+            nel modello da cui darivano i modelli del base editing - #{e.message}"
+    end
+
+    def append_gem_dependency
+      append_to_file 'Gemfile', "# gem 'codice_fiscale'"
+    rescue Exception => e
+      puts e.message
+    end
+
+
+
     def install_node_dependency
-      run "yarn add patternfly-bootstrap-treeview"
+      pacchetti_yarn = ["underscore"]#"wolfy87-eventemitter",
+
+      run "yarn add #{pacchetti_yarn.join(" ")}"
     end
 
-    def append_js_dependecy_to_assets
-      inject_into_file 'app/assets/javascripts/application.js',"//= require kono_utils/utilities\n", before: "//= require_tree ."
+    def base_editing_install
+      resp = ask "Vuoi che installi la struttura base del controller e base editing? y/n"
+      if resp=='y'
+        @controller_da_cui_derivare = ask("Controller da cui derivare il BaseEditingController?[RestrictedAreaController]")
+        @controller_da_cui_derivare = "RestrictedAreaController" if @controller_da_cui_derivare.blank?
+        template('base_editing_controller.template','app/controllers/base_editing_controller.rb')
+        template('base_editing_helper.template','app/helpers/base_editing_helper.rb')
+        template('base_editing_policy.template','app/policies/base_editing_policy.rb')
+        say "Tutti i Controller che dovranno lavorare con il base editing dovranno derivare da BaseEditingController"
+        say "Tutte le policy che dovranno lavorare con il base editing dovranno derivare da BaseEditingPolicy"
+      end
     end
 
   end

data/lib/generators/templates/base_editing_controller.template

@@ -0,0 +1,3 @@
+class BaseEditingController < <%= @controller_da_cui_derivare %>
+  include KonoUtils::Concerns::BaseEditing
+end

data/lib/generators/templates/base_editing_helper.template

@@ -0,0 +1,3 @@
+module BaseEditingHelper
+  include KonoUtils::BaseEditingHelper
+end

data/lib/generators/templates/base_editing_policy.template

@@ -0,0 +1,4 @@
+class BaseEditingPolicy < ApplicationPolicy
+  include KonoUtils::BaseEditingPolicyConcern
+
+end

data/lib/generators/templates/initializer.rb

@@ -1,3 +1,5 @@
 KonoUtils.configure do |config|
   #config.google_api_key = '' #chiave API
-end
+end
+
+Rails.application.config.action_controller.include_all_helpers=false

data/lib/kono_utils.rb

@@ -1,27 +1,29 @@
-require 'kono_utils/engine' if defined?(::Rails)
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/generators")
 
-module KonoUtils
-  extend ActiveSupport::Autoload
-
-  autoload :VirtualModel
-  autoload :Encoder
-  autoload :ParamsHashArray
-  autoload :Percentage
-  autoload :FiscalCode
-  autoload :TmpFile
-  autoload :ApplicationHelper
-  autoload :BaseEditingHelper
-  autoload :BaseSearch
-  autoload :Concerns
-
-  class Configuration
-    attr_accessor :google_api_key
+
+if defined?(::Rails)
+  if Rails.gem_version <= Gem::Version.new('4.2.0')
+    # Non facciamo eager load nel caso di nuovi rails
+    translations_concerns = "#{__dir__}/kono_utils/concerns/active_record_translation"
+    loader.do_not_eager_load(translations_concerns)
   end
+else
+  # non carichiamo l'engine se non presente rails
+  loader.do_not_eager_load("#{__dir__}/kono_utils/engine")
+end
+
+loader.enable_reloading # you need to opt-in before setup
+loader.setup
+
+module KonoUtils
 
   class << self
     attr_writer :configuration
   end
 
+  # @return [Configuration]
   def self.configuration
     @configuration ||= Configuration.new
   end
@@ -34,8 +36,4 @@ module KonoUtils
 end
 
 
-if defined?(::Rails)
-  if Rails.gem_version > Gem::Version.new('4.2.0')
-    require 'kono_utils/concerns/active_record_translation'
-  end
-end
+loader.eager_load

data/lib/kono_utils/application_core_helper.rb

@@ -0,0 +1,524 @@
+module KonoUtils
+  module ApplicationCoreHelper
+
+    # def self.included(base)
+    #
+    #
+    #
+    #   base.send :include, FontAwesome::Rails::IconHelper
+    #
+    # end
+
+    # def will_paginate_bst(collection)
+    #   will_paginate collection, renderer: BootstrapPagination::Rails
+    # end
+
+
+    ##
+    # Crea un DIV che racchiude tutto il contenuto all'interno della classe utilizzata, splittando il nome della classe
+    # per suoi moduli, rendendo quindi filtrabile il contenuto sottostante
+    # @param [Proc] block -> contenuto che verrà inserito nel content
+    # @return [String]
+    def namespace_content(&block)
+      content_tag :div, class: "#{(controller.class.name.split("::") + [action_name]).join(" ")}" do
+        yield
+      end
+
+    end
+
+    # def true_false_label(val)
+    #
+    #   if val
+    #     icon =fa_icon(:check)
+    #     classe='success'
+    #   else
+    #     classe='danger'
+    #     icon =fa_icon(:times)
+    #   end
+    #
+    #   content_tag(:span, icon, class: "label label-#{classe}")
+    #
+    # end
+
+
+    ##
+    # Genera una modal da riutilizzare per far aspettare determinate operazioni al client
+    # def bootstrap_please_wait
+    #   content_tag(:div,
+    #               class: 'modal fade',
+    #               id: 'processing_wait',
+    #               tabindex: "-1",
+    #               role: "dialog",
+    #               "aria-hidden".to_sym => "true") do
+    #     content_tag :div, class: 'modal-dialog modal-sm' do
+    #       content_tag :div, class: 'modal-content' do
+    #
+    #         buff = ActiveSupport::SafeBuffer.new
+    #
+    #         buff << content_tag(:div, class: 'modal-header') do
+    #           content_tag(:h4, "Processing...", class: "modal-title")
+    #         end
+    #
+    #         buff << content_tag(:div, class: 'modal-body') do
+    #           content_tag :div, class: "progress" do
+    #             content_tag :div, ' ', class: "progress-bar progress-bar-striped active", role: "progressbar", style: "width: 100%"
+    #           end
+    #         end
+    #
+    #         buff
+    #       end
+    #     end
+    #   end
+    # end
+
+
+    ##
+    # Genera la form di ricerca
+    # * *Args*    :
+    #   - search_model  -> KonoUtils::BaseSearch
+    #   - args          -> Hash with configurations:
+    #                       - attributes      -> array of symbols for the search, if empty used from search_model
+    #                       - reset_path      -> path per cui resettare la ricerca, nil
+    #                       - form_opts       -> opzioni da aggiungere per la form
+    #                       - buttons_editor  -> Proc chiamata, con il passaggio dell'oggetto della form e
+    #                                            del ActiveSupport::SafeBuffer con all'interno dei bottoni
+    #                                            come parametro, deve ritornare
+    #                                             un ActiveSupport::SafeBuffer a sua volta
+    # * *Returns* :
+    #   -
+    #
+    # def search_form(search_model, args={})
+    #
+    #   args = {
+    #       :attributes => [],
+    #       :reset_path => nil,
+    #       :form_opts => {},
+    #       :field_option => {:wrapper_html => {:class => "col-xs-12 col-sm-6 col-md-4 col-lg-3"}},
+    #       :buttons_editor => Proc.new {|form_obj, sb| sb}
+    #   }.merge(args)
+    #
+    #   base_search_form_wrapper(search_model, {:attributes => args[:attributes], :form_opts => args[:form_opts]}) do |f|
+    #
+    #     render :partial => '/application/search_panel.html', locals: {
+    #         form: f,
+    #         search_model: search_model
+    #     }.merge(args)
+    #
+    #   end
+    #
+    # end
+
+    # class BaseSearchFormWrapper < Struct.new(:formtastic_form, :attributes, :current_user)
+    #
+    #   def fields_builder(cfgs={field_options: {}})
+    #     form_buffer = ActiveSupport::SafeBuffer.new
+    #
+    #     self.attributes.each do |field|
+    #
+    #       form_options = field.form_options
+    #       if form_options.is_a?(Proc)
+    #         form_options = form_options.call(current_user, self.formtastic_form)
+    #       end
+    #
+    #       form_buffer << self.formtastic_form.input(field.field, cfgs[:field_options].merge(form_options))
+    #     end
+    #
+    #     form_buffer
+    #   end
+    # end
+
+    ##
+    # Utility interna che si occupa della logica minima per generare la il form di ricerca
+    # def base_search_form_wrapper(search_model, args={:attributes => [], :form_opts => {}})
+    #   attributes = args[:attributes] || {}
+    #   form_opts = args[:form_opts] || {}
+    #   if attributes.length==0
+    #     attributes = search_model.search_attributes
+    #   end
+    #
+    #   form_opts = {method: :get, :html => {autocomplete: 'off'}}.merge(form_opts)
+    #
+    #   semantic_form_for search_model, form_opts do |f|
+    #     yield BaseSearchFormWrapper.new(f, attributes, @current_user)
+    #   end
+    # end
+
+
+    ##
+    # Helper per generare una modal con all'interno un form
+    # Utilizzare passando un block il quale riceve come parametro la form di formtastic
+    # possibile passare anche una proc in buttons_proc per scrivere in modo differente i bottoni nella modal,
+    # alla proc viene passato il solito form di formtastic e il bottone standard di chiusura
+    #
+    # def modal_form_generator(args = {})
+    #
+    #   args = {
+    #       id: 'modal',
+    #       class: '',
+    #       title: 'Titolo',
+    #       form_cfgs: [],
+    #       buttons_proc: Proc.new do |f, default_close_btn|
+    #         default_close_btn +
+    #             f.action(:submit, button_html: {class: 'btn btn-primary'}, :label => :save_and_close)
+    #       end
+    #   }.merge(args)
+    #
+    #   raise 'Passare le configurazioni per la form' if args[:form_cfgs]==[]
+    #
+    #   default_close_btn = content_tag(:button, 'Chiudi', type: 'button', class: 'btn btn-default', data: {dismiss: "modal"})
+    #
+    #   content_tag(:div,
+    #               class: "modal fade kono_modal_form",
+    #               id: args[:id],
+    #               tabindex: "-1",
+    #               role: "dialog",
+    #               "aria-hidden".to_sym => "true") do
+    #     content_tag :div, class: 'modal-dialog' do
+    #       semantic_form_for(*args[:form_cfgs]) do |f|
+    #         content_tag :div, class: 'modal-content' do
+    #
+    #           buff = ActiveSupport::SafeBuffer.new
+    #
+    #           buff << content_tag(:div, class: 'modal-header') do
+    #             content_tag(:button, raw("&times;"), type: "button", class: "close", data: {dismiss: 'modal'}, "aria-hidden".to_sym => "true") +
+    #                 content_tag(:h4, args[:title], class: "modal-title")
+    #           end
+    #
+    #           buff << content_tag(:div, class: 'modal-body') do
+    #             yield f
+    #           end
+    #
+    #           buff << content_tag(:div, class: 'modal-footer') do
+    #             args[:buttons_proc].call(f, default_close_btn)
+    #           end
+    #
+    #           buff
+    #         end
+    #       end
+    #     end
+    #   end
+    #
+    # end
+
+
+    ##
+    # Genera il bottone per editazione con una modal del contenuto,
+    # gli viene passato un block contenente la modal da lanciare per l'editazione,
+    # solitamente generata con modal_form_generator.
+    # come parametri viene passato l'id del target che si aspetta di richiamare
+    #
+    # ES:
+    #  modal_edit_button do |id|
+    #    render 'tikal_core/people/person_contacts/modal_form', :contact => contact, :id => id %>
+    #  end
+    #
+    # Attributes:
+    #   align: left|rigth
+    #   updatable_content: elemento da rimpiazzare con il partial restituito
+    #   class: classi aggiuntive per selezionare meglio il bottone
+    #   btn_class: classi aggiuntive del bottone
+    #   bnt_icon: Symbol che identifica che icona utilizzare per il bottone
+    #
+    #
+    # def modal_edit_button(*args, &block)
+    #
+    #   options = {
+    #       align: 'left',
+    #       updatable_content: '',
+    #       class: '',
+    #       btn_class: '',
+    #       bnt_icon: :edit
+    #   }.merge(args.extract_options!)
+    #
+    #   id = "#{SecureRandom.hex}"
+    #
+    #
+    #   content_tag :div, class: "kono_edit_button align-#{options[:align]} #{options[:class]}", :data => {updatable_content: options[:updatable_content]} do
+    #     buffer = ActiveSupport::SafeBuffer.new
+    #
+    #     buffer << button_tag(data: {toggle: 'modal', target: "##{id}"}, class: "btn btn-default btn-xs #{options[:btn_class]}") {fa_icon(options[:bnt_icon])}
+    #
+    #     buffer << capture do
+    #       block.call(id)
+    #     end
+    #
+    #     buffer
+    #   end
+    # end
+
+
+    ##
+    # Genera il bottone per la cancellazione di un elemento
+    #
+    # modal_delete_button(path, [options])
+    # path -> resource to delete
+    # options:
+    #  *  confirm         : Text to display in modal
+    #  *  align           : left|right
+    #  *  callback_remove : id dell'elemento da rimuove una volta avuto successo il javascript di cancellazione
+    #  *  bnt_icon        : Symbol che identifica che icona utilizzare per il bottone
+    # def modal_delete_button(*args)
+    #   options = {
+    #       confirm: 'Sicuri di voler eliminare il record? L\'azione non è annullabile.',
+    #       align: 'left',
+    #       callback_remove: nil,
+    #       bnt_icon: :times
+    #   }.merge(args.extract_options!)
+    #   path = args[0]
+    #
+    #   id = "#{SecureRandom.hex}"
+    #
+    #   content_tag :div, class: "tk_delete_button align-#{options[:align]}" do
+    #
+    #     buffer = ActiveSupport::SafeBuffer.new
+    #
+    #     buffer<<button_tag(data: {toggle: 'modal', target: "##{id}"}, class: 'btn btn-danger btn-xs') {fa_icon(options[:bnt_icon])}
+    #
+    #     buffer<< content_tag(:div,
+    #                          class: 'modal fade',
+    #                          id: id,
+    #                          tabindex: "-1",
+    #                          role: "dialog",
+    #                          "aria-hidden".to_sym => "true") do
+    #       form_tag(path, method: :delete, data: {callback_remove: options[:callback_remove]}) do
+    #         content_tag :div, class: 'modal-dialog' do
+    #           content_tag :div, class: 'modal-content' do
+    #
+    #             buff = ActiveSupport::SafeBuffer.new
+    #
+    #             buff << content_tag(:div, class: 'modal-header') do
+    #               tmp_buff = ActiveSupport::SafeBuffer.new
+    #               tmp_buff<<button_tag(fa_icon(:times), type: "button", class: "close", data: {dismiss: "modal"}, "aria-hidden".to_sym => true)
+    #               tmp_buff<<content_tag(:h4, "Attenzione", class: "modal-title")
+    #               tmp_buff
+    #             end
+    #
+    #             buff << content_tag(:div, options[:confirm], class: 'modal-body text-danger')
+    #
+    #             buff << content_tag(:div, class: 'modal-footer') do
+    #               button_tag('Annulla', type: "button", class: "btn btn-default", data: {dismiss: "modal"})+
+    #                   button_tag('Conferma', type: 'submit', class: "btn btn-danger")
+    #             end
+    #
+    #             buff
+    #           end
+    #
+    #         end
+    #       end
+    #     end
+    #
+    #     buffer << content_tag(:script, raw("$('##{id} form').kono_delete_button();"), :type => 'text/javascript')
+    #
+    #     buffer
+    #   end
+    # end
+
+    ##
+    # Colleziona i mesi per la select box
+    def month_collection
+      (1..12).collect {|m| [t('date.month_names')[m].capitalize, m]}
+    end
+
+
+    ##
+    # Genera una collection degli anni per la select box
+    # parte da -8 a +1
+    #
+    def year_collection(start=-8, last=1)
+      ((Time.now.year+start)..(Time.now.year+last)).to_a.reverse
+    end
+
+    module_function :year_collection
+
+
+    ##
+    # Si occupa di generare la visualizzazione dell'exception passata, con informazioni
+    # aggiuntive se utente è super admin
+    # * *Args*    :
+    #   - exception   -> Exception
+    # def bs_rescue_printer(exception)
+    #   bff = ActiveSupport::SafeBuffer.new
+    #
+    #   bff<< content_tag(:div, class: "alert alert-warning") do
+    #     button_tag(raw("&times;"), data: {dismiss: "alert", hidden: "true"}, class: 'close') +
+    #         content_tag(:strong, 'Errore') +
+    #         " Attenzione, il codice eseguito non è valido, contattare l'amministratore."
+    #   end
+    #
+    #   if @current_user.is_super_admin?
+    #
+    #     bff<<content_tag(:div, class: "panel panel-info") do
+    #       tmp = ActiveSupport::SafeBuffer.new
+    #       tmp<<content_tag(:div, class: "panel-heading") do
+    #         content_tag :h3, "Messagio di Errore: #{exception.message} "
+    #       end
+    #       tmp<<content_tag(:div, class: "panel-body") do
+    #         content_tag :pre, exception.backtrace.join("\n")
+    #       end
+    #
+    #       tmp
+    #     end
+    #   end
+    #
+    #   bff
+    # end
+
+    ##
+    #
+    # * *Args*    :
+    #   - int   -> Valore intero per definire
+    #   - class -> optional classi aggiuntive
+    # * *Returns* :
+    #   - content
+    #
+    # def bs_spacer(space, classe='')
+    #   content_tag :div, nil, class: "v-spacer space-x#{space} #{classe}"
+    # end
+
+
+    ##
+    # Costruisce una tabella con i campi utili alla creazione di elementi multipli
+    #
+    # Attributes:
+    # form -> la form proveniente da formtastic
+    # field -> il campo referente dell'associazione
+    # fields -> elenco di campi su cui costruire le varie colonne
+    # options -> Hash di opzioni:
+    #             :disable_duplication => [false]    : server per disabilitare il bottone della duplicazione
+    #
+    # se gli si passa un blocco allora possiamo elaborare la costruzione dei differenti campi in modo personale
+    # al blocco viene passato la classe di formtastic della form, il campo, e un blocco contenente la proc per
+    # elaborare i campi in modo standard
+    #
+    #   multiple_elements_table(form, :campo_has_many, [:label, :string_value, :number_value]) do |field, form|
+    #     case field
+    #       when :string_value, :number_value
+    #         form.input field, label: false, input_html: {:autocomplete => 'off', class: 'toggle_value'}
+    #       else
+    #         form.input field, label: false, input_html: {:autocomplete => 'off'}
+    #     end
+    #   end
+    #
+    # Traduzioni delle colonne:
+    #
+    #   modello_iniziale/campo_has_many:
+    #     campo_del_has_many
+    #
+    #
+    # def multiple_elements_table(*params)
+    #   options = params.extract_options!
+    #
+    #   options = {:disable_duplication => false}.merge(options)
+    #
+    #   form = params[0]
+    #   field = params[1]
+    #   fields = params[2]
+    #
+    #   semantic_form_nested=[field]
+    #
+    #   #inserimento logiche per scope su elenco elementi multipli
+    #   unless options[:scope].nil?
+    #     semantic_form_nested<<options[:scope]
+    #   end
+    #
+    #   content_tag :table, class: "table table-bordered" do
+    #
+    #     b = ActiveSupport::SafeBuffer.new
+    #
+    #     b<< content_tag(:thead) do
+    #       content_tag :tr do
+    #         c = ActiveSupport::SafeBuffer.new
+    #
+    #         fields.each do |f|
+    #           ::Rails.logger.debug {form.object.class.inspect}
+    #           ::Rails.logger.debug {field}
+    #           ::Rails.logger.debug {f.inspect}
+    #           c<<content_tag(:th, form.object.class.human_attribute_name("#{field}.#{f}"), class: "multi_tab_#{f}")
+    #         end
+    #         unless options[:disable_duplication]
+    #           c<<content_tag(:td, nil)
+    #         end
+    #
+    #         c
+    #       end
+    #     end
+    #
+    #     b<<content_tag(:tbody) do
+    #       form.semantic_fields_for(*semantic_form_nested) do |measure|
+    #
+    #         default_execution = Proc.new {|field| measure.input field, :label => false}
+    #
+    #         content_tag :tr, class: "form-inline list riga_misura" do
+    #
+    #           d = ActiveSupport::SafeBuffer.new
+    #
+    #           fields.each do |f|
+    #             d<<content_tag(:td, class: "multi_tab_#{f}") do
+    #
+    #               if block_given?
+    #                 yield(f, measure, default_execution)
+    #               else
+    #                 default_execution.call(f)
+    #               end
+    #
+    #             end
+    #           end
+    #
+    #           unless options[:disable_duplication]
+    #             d << content_tag(:td) do
+    #
+    #               link_to "#", class: 'btn btn-xs btn-default add_one_more' do
+    #
+    #                 h = ActiveSupport::SafeBuffer.new
+    #                 h<< fa_icon(:plus)
+    #                 h<< measure.input(:_destroy, as: :hidden)
+    #
+    #                 h
+    #               end
+    #
+    #             end
+    #           end
+    #
+    #           d
+    #         end
+    #       end
+    #     end
+    #
+    #     b
+    #   end
+    # end
+
+
+    ##
+    # Genera un'albero con bootstrap-tree
+    # deve ricevere un array di dati da trasformare in json.
+    # per come scrivere il parametro data vedi
+    # https://github.com/jonmiles/bootstrap-treeview
+    #
+    # def bs_tree(data)
+    #
+    #   id_div = SecureRandom.hex(10)
+    #
+    #   tmp = ActiveSupport::SafeBuffer.new
+    #
+    #   tmp<< content_tag(:div, nil, id: id_div, class: 'bs_tree_list')
+    #
+    #   tmp<< javascript_tag do
+    #     raw "$('##{id_div}').treeview({data: #{data.to_json}});"
+    #   end
+    #
+    # end
+
+    ##
+    # Stampa una data con il default delle date se questa non è nil
+    #
+    def print_rescue_date(date)
+      unless date.nil?
+        return l date.to_date
+      end
+      ''
+    end
+
+
+  end
+end