kono_utils_bootstrap_view4 0.1.0.pre.rc.1

data/config/locales/kono_utils_bootstrap4.it.yml

@@ -0,0 +1,15 @@
+it:
+  kono_utils:
+    bootstrap4:
+      forms:
+        fields:
+          file_field:
+            purge_file:
+              label: "Rimuovi file"
+      buttons:
+        download:
+          alt: Download
+        collapse_search:
+          alt: "Ricerca"
+        delete:
+          title: Conferma

data/config/locales/simple_form.en.yml

@@ -0,0 +1,31 @@
+en:
+  simple_form:
+    "yes": 'Yes'
+    "no": 'No'
+    required:
+      text: 'required'
+      mark: '*'
+      # You can uncomment the line below if you need to overwrite the whole required html.
+      # When using html, text and mark won't be used.
+      # html: '<abbr title="required">*</abbr>'
+    error_notification:
+      default_message: "Please review the problems below:"
+    # Examples
+    # labels:
+    #   defaults:
+    #     password: 'Password'
+    #   user:
+    #     new:
+    #       email: 'E-mail to sign in.'
+    #     edit:
+    #       email: 'E-mail.'
+    # hints:
+    #   defaults:
+    #     username: 'User name to sign in.'
+    #     password: 'No special characters, please.'
+    # include_blanks:
+    #   defaults:
+    #     age: 'Rather not say'
+    # prompts:
+    #   defaults:
+    #     age: 'Select your age'

data/config/routes.rb

@@ -0,0 +1,2 @@
+Rails.application.routes.draw do
+end

data/lib/generators/kono_utils_bootstrap_view4/concept/concept_generator.rb

@@ -0,0 +1,79 @@
+require 'rails/generators'
+module KonoUtilsBootstrapView4
+  class ConceptGenerator < Rails::Generators::Base
+    include ActiveSupport::Inflector
+
+    source_root File.expand_path('../templates', __FILE__)
+
+    desc "Costruisce la struttura delle cartelle e il wrapper per la selezione dei campi da renderizzare\n" +
+           "Passando CELL viene anche generata la classe nella posizione corretta"
+    argument :model_name, type: :string, desc: 'ModelName'
+    argument :cell, type: :string, default: false, desc: "Nome cella da copiare"
+
+
+    def generate_folders
+
+      if safe_constantize(model_name)
+        FileUtils.mkdir_p(File.join(path, 'cell'))
+        FileUtils.mkdir_p(File.join(path, 'view'))
+      else
+        puts "Modello inesistente"
+      end
+
+    end
+
+    ##
+    # Automatismo non completo, TO_COMPLETE
+    # class_option :generate_view, type: :boolean, default: false, desc: "Per la cella passata viene copiato la view"
+    # class_option :generate_class, type: :boolean, default: false, desc: "Per la cella passata viene copiata la classe"
+    #
+    # def copy_cell
+    #   unless cell.blank?
+    #     dirs = []
+    #
+    #     dirs << ['cell', 'view', 'erb'] if options.generate_view
+    #     dirs << ['cell', 'cell', 'rb'] if options.generate_class
+    #
+    #     puts "Devi selezionare almeno uno dei generatori: --generate-view  o --generate-class" if dirs.empty?
+    #
+    #
+    #     dirs.each do |c|
+    #
+    #       component_to_override = "#{cell.gsub(/#{c[0]}/, c[1])}.#{c[2]}"
+    #       path_src = File.join('app', 'concepts', 'kono_utils', component_to_override)
+    #
+    #       path_dest = File.join('app', 'concepts', tableize(safe_constantize(model_name).name), component_to_override)
+    #
+    #       puts path_src
+    #       puts path_dest
+    #
+    #       #copio i files
+    #       copy_file(path_src, path_dest)
+    #
+    #     end
+    #   end
+    # end
+
+
+    class_option :field_selector, type: :boolean, default: false, desc: "Copia il template per il selettore dei campi"
+    class_option :form, type: :boolean, default: false, desc: "Copia il template della form"
+
+    def copy_templates
+      if options.field_selector
+        template 'forms/field_selector.template', File.join(path, "cell", "forms", "field_selector.rb")
+      end
+      if options.form
+        template 'form.template', File.join(path, "cell", "form.rb")
+      end
+    end
+
+
+    private
+
+    def path
+      Rails.application.root.join('app', 'concepts', tableize(safe_constantize(model_name).name))
+    end
+
+
+  end
+end

data/lib/generators/kono_utils_bootstrap_view4/concept/templates/form.template

@@ -0,0 +1,8 @@
+class <%= model_name.pluralize %>::Cell::Form < KonoUtils::Object::Cell::Form
+
+  #def forms_options
+  #  [model, _form_options]
+  #end
+
+
+end

data/lib/generators/kono_utils_bootstrap_view4/concept/templates/forms/field_selector.template

@@ -0,0 +1,13 @@
+class <%= model_name.pluralize %>::Cell::Forms::FieldSelector < KonoUtils::Object::Cell::Forms::FieldSelector
+
+  def get_field
+    case model.name
+    #when :field_name
+    #  concept("cell/forms/fields/association", model, field_options: {as: :check_boxes}, layout: get_layout('associations'))
+    else
+      super
+    end
+  end
+
+
+end

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

@@ -0,0 +1,76 @@
+require 'rails/generators'
+module KonoUtilsBootstrapView4
+  class InstallGenerator < Rails::Generators::Base
+    desc "Installa l'inizializzatore"
+
+    source_root File.expand_path('../templates', __FILE__)
+
+    def install_kono_utils
+      run "rails g kono_utils:install"
+    end
+
+    def copy_initializer
+      template 'kono_utils_bootstrap_view4.template', Rails.root.join('config', 'initializers', 'kono_utils_bootstrap_view4.rb')
+    end
+
+    def install_node_dependency
+      yarn_packages = ['bootstrap@4.5.0', 'jquery@3.5.1', 'popper.js', 'moment', 'tempusdominus-bootstrap-4', '@fortawesome/fontawesome-free', 'data-confirm-modal']
+      run "yarn add #{yarn_packages.join(' ')}" unless yarn_packages.empty?
+    end
+
+    def install_cell_concept_namespacer_on_application_record
+      inject_into_file 'app/models/application_record.rb', "\n  include KonoUtilsBootstrapView4::BaseClassConceptNs", after: "ActiveRecord::Base"
+    rescue Exception => e
+      say "Attenzione, includere a mano KonoUtilsBootstrapView4::BaseClassConceptNs
+            nel modello da cui darivano i modelli del base editing - #{e.message}", :red
+    end
+
+    def append_dependecy_to_assets
+      js_requirements = [
+        'kono_utils_bootstrap_view4/application'
+      ]
+      KonoUtilsBootstrapView4.configuration.moment_js_locales.each do |l|
+        js_requirements << "moment/locale/#{l}.js"
+      end
+
+      rails6 = Gem::Version.new('6')
+      if rails6 <= Gem::Version.new(Rails.version)
+        say "in rails 6 dobbiamo avere webpacker che compila erb, creiamo un file erb che includa le nostre dipendenze", :yellow
+        run "rails webpacker:install:erb"
+        #cancelliamo il file di esempio
+        remove_file 'app/javascript/packs/hello_erb.js.erb'
+        template 'kono_utils_bootstrap_view4.js.erb.template', Rails.root.join('app', 'javascript', 'packs', 'application.js.erb')
+        say "Ricorda di aggiungere nel layout  <%= javascript_pack_tag 'application' %>", :yellow
+      else
+        inject_into_file 'app/assets/javascripts/application.js',
+                         "#{requirements.collect { |c| "\n//= require #{c}" }.join}\n",
+                         before: "//= require_tree ."
+      end
+
+
+      requirements = [
+        'kono_utils_bootstrap_view4/application'
+      ]
+      inject_into_file 'app/assets/stylesheets/application.css',
+                       "#{requirements.collect { |c| "\n *= require #{c}" }.join}\n",
+                       before: " *= require_tree ."
+
+    end
+
+    def append_gem_dependency
+
+      dips = [
+        'cells-erb', # inserita in installazione come specificato qua http://trailblazer.to/gems/cells/rails.html#engine-render-problems
+        'cells-rails',
+        'kaminari-cells'
+      ]
+      say "AGGIUNGO dipendenze per concepts, #{dips.join("  ")}", :green
+
+      dips.each do |dip|
+        gem dip
+      end
+
+
+    end
+  end
+end

data/lib/generators/kono_utils_bootstrap_view4/install/templates/kono_utils_bootstrap_view4.js.erb.template

@@ -0,0 +1,20 @@
+// To reference this file, add <\%= javascript_pack_tag 'kono_utils_bootstrap_view4' %> to the appropriate
+// layout file, like app/views/layouts/application.html.erb
+
+// RICORDARSI di mantenere sincronizzate le dipendenze tra la versione non webpack negli assets,i moduli richiesti ecc
+
+// jquery risulta essere ancora una dipendenza per bootstrap4.
+global.jQuery = global.$ = require('jquery'); // rails-js cerca jquery in modo globale, quindi noi lo rendiamo globale in questo modo
+
+global.Rails = require("@rails/ujs") // serve per data-confirm-modal, rendere Rails globale
+global.Rails.start()
+require("@rails/activestorage").start()
+
+// inizio dipendenza per interfaccia Bootstrap4
+import "@fortawesome/fontawesome-free/css/all.css";
+require('bootstrap');
+require('popper.js');
+global.moment = require('moment');
+require('tempusdominus-bootstrap-4');
+require('data-confirm-modal');
+global.KonoUtilsBootstrap4 = require("<%%= KonoUtilsBootstrapView4::Engine.root.join('app','assets','javascripts','kono_utils_bootstrap_view4','kono_utils_bootstrap_view4.js') %>");

data/lib/generators/kono_utils_bootstrap_view4/install/templates/kono_utils_bootstrap_view4.template

@@ -0,0 +1,5 @@
+KonoUtilsBootstrapView4.configure do |config|
+
+  # config.moment_js_locales = [:it,:de]
+
+end

data/lib/kono_utils_bootstrap_view4.rb

@@ -0,0 +1,26 @@
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.ignore("#{__dir__}/generators")
+loader.enable_reloading # you need to opt-in before setup
+loader.setup
+
+# require "kono_utils_bootstrap_view4/engine"
+
+module KonoUtilsBootstrapView4
+
+  class << self
+    attr_writer :configuration
+  end
+
+  # @return [Configuration]
+  def self.configuration
+    @configuration ||= Configuration.new
+  end
+
+  def self.configure
+    yield configuration
+  end
+
+end
+
+loader.eager_load

data/lib/kono_utils_bootstrap_view4/application_icon_helper.rb

@@ -0,0 +1,31 @@
+module KonoUtilsBootstrapView4
+  module ApplicationIconHelper
+
+    ##
+    # Funzione clonata da una gemma, le fontawesome lo stiamo già impostando con webpack
+    def icon(style, name, text = nil, html_options = {})
+      text, html_options = nil, text if text.is_a?(Hash)
+
+      content_class = "#{style} fa-#{name}"
+      content_class << " #{html_options[:class]}" if html_options.key?(:class)
+      html_options[:class] = content_class
+
+      html = content_tag(:i, nil, html_options)
+      html << ' ' << text.to_s unless text.blank?
+      html
+    end
+
+    def fa_icon(icon, text: nil, solid_regular:"s")
+      icon = content_tag(:i, nil, class: "fa#{solid_regular} fa-#{icon} fa-fw")
+      elements = [icon]
+      unless text.blank?
+        elements << text
+        elements.reverse!
+      end
+
+      safe_join(elements, " ")
+    end
+
+
+  end
+end

data/lib/kono_utils_bootstrap_view4/base_class_concept_ns.rb

@@ -0,0 +1,47 @@
+module KonoUtilsBootstrapView4
+  module BaseClassConceptNs
+    extend ActiveSupport::Concern
+
+    class_methods do
+      include ActiveSupport::Inflector
+
+      ##
+      # Metodo richiamato per restituire un  array di path in cui ricercare le view prima della ricerca delle altre view
+      # all'interno della gemma o altro, serve per poter fare override di view anche senza la presenza della relativa
+      # classe Cell overridata.
+      def concept_prefix
+        [Rails.application.root.join('app', 'concepts', tableize(self.name), 'view')]
+      end
+
+      def concept_ns(view)
+        @_memo_concept ||= {}
+        ns = "#{tableize(self.name)}/#{view}"
+
+        unless @_memo_concept.key?(ns)
+          if safe_constantize(ns.camelize)
+            KonoUtilsBootstrapView4.configuration.logger.info { "TROVATA CLASSE PER : #{ns.camelize} --->>>" }
+            @_memo_concept[ns] = ns
+          else
+            @_memo_concept[ns] = false
+          end
+        end
+
+        if @_memo_concept[ns]
+          return @_memo_concept[ns]
+        else
+          KonoUtilsBootstrapView4.configuration.logger.debug { "CLASSE OVERRIDE NON TROVATA PER : #{ns.camelize}" }
+
+          "kono_utils/object/#{view}"
+        end
+
+      end
+
+      ##
+      # Ritorna il corretto layout per il componente, tenendo conto delle view con override
+      def layout_ns(name)
+        concept_ns(name).camelize.constantize
+      end
+
+    end
+  end
+end

data/lib/kono_utils_bootstrap_view4/base_search.rb

@@ -0,0 +1,5 @@
+module KonoUtilsBootstrapView4
+  class BaseSearch < KonoUtils::BaseSearch
+    include BaseClassConceptNs
+  end
+end

data/lib/kono_utils_bootstrap_view4/configuration.rb

@@ -0,0 +1,20 @@
+class KonoUtilsBootstrapView4::Configuration
+  attr_accessor :moment_js_locales
+
+  #@return [ActiveSupport::TaggedLogging] log di kono utils bootstrap, default estende quello di rails
+  attr_reader :logger
+
+  def initialize
+    @moment_js_locales = I18n.available_locales
+    # inizializzo logger, come quello che mi verrebbe passato
+    self.logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT))
+  end
+
+  # @param [ActiveSupport::TaggedLogging] logger
+  # @return [ActiveSupport::TaggedLogging]
+  def logger=(logger)
+    raise "Not a ActiveSupport::TaggedLogging" unless logger.is_a? ActiveSupport::TaggedLogging
+    logger.push_tags("KonoUtils") unless logger.formatter.current_tags.include?("KonoUtils")
+    @logger = logger
+  end
+end

data/lib/kono_utils_bootstrap_view4/editable_field.rb

@@ -0,0 +1,63 @@
+module KonoUtilsBootstrapView4
+
+  ##
+  # PORO che si occupa di gestire un campo da editare.
+  # questo serve per poter gestire le casistiche provenienti dagli editable attributes, che consistono in semplisy symbols
+  # o in hash che rappresentano le relazioni
+  class EditableField
+
+
+    def initialize(f)
+      @field = f
+    end
+
+
+    ##
+    # Restituisce il symbol che rappresenta il campo da editare
+    #
+    def name
+
+      if @field.is_a?(Hash)
+        @field.keys.first
+      else
+        @field.to_sym
+      end
+
+    end
+
+
+    ##
+    # Solitamente questi campi sono da renderizzare come nascosti
+    # @return [TrueClass|FalseClass]
+    def is_hidden?
+      ['id', '_destroy'].include?(name.to_s)
+    end
+
+    ##
+    # Controlla se il campo è di tipo nested (un hash con chiave ed una serie di campi interni)
+    def is_nested?
+      @field.is_a?(Hash)
+    end
+
+    ##
+    # Nei casi di campi nested, questo metodo restituisce un array di campi interni, normalizzati a EditableField
+    def inner_fields
+      is_nested? ? self.class.editable_fields_to_field_array(@field[name]) : []
+    end
+
+
+    # @return [Array<KonoUtilsBootstrapView4::EditableField>]
+    def self.editable_fields_to_field_array(attributes)
+      attributes.collect do |s|
+
+        if s.is_a?(Hash)
+          s.collect {|k, v| KonoUtilsBootstrapView4::EditableField.new({k => v})}
+        else
+          KonoUtilsBootstrapView4::EditableField.new(s)
+        end
+
+      end.flatten
+    end
+
+  end
+end