base_editing_bootstrap 0.1.2

data/config/locales/it.yml

@@ -0,0 +1,67 @@
+it:
+  search: "Esegui ricerca"
+  save: "Salva"
+  back: "Indietro"
+  new: "Nuovo"
+  newa: "Nuova"
+  edit: "Modifica"
+  del: "Cancella"
+  wait: "Wait..."
+  are_you_sure: "Confermi la cancellazione?"
+  undo: "Annulla"
+  error: "Errore"
+  notice: "Informazione"
+  alert: "Attenzione"
+
+  #serve per intestazioni tabelle
+  created_at: "Data creazione"
+  updated_at: "Data aggiornamento"
+  name: "Nome"
+  id: "Id"
+  user_create: "Utente creazione"
+  user_update: "Utente modifica"
+
+  male: "Maschio"
+  female: "Femmina"
+  other: "Altro"
+
+  download: "Download"
+  delete: "Elimina"
+  
+  impersonate: "Impersona"
+  configure: "Configura"
+  execute_commands: "Esegui Comandi"
+  assigned_to: "Assegnato a %{user}"
+
+  pundit:
+    default: 'Non sei autorizzato ad eseguire questa azione.'
+#    #MEMO nel caso si volesse dare messaggi specifici per le policy
+#    post_policy:
+#      update?: 'You cannot edit this post!'
+#      create?: 'You cannot create posts!'
+  activerecord:
+    successful:
+      messages:
+        created: "%{model} creato correttamente."
+        updated: "%{model} aggiornato correttamente."
+        destroyed: "%{model} è stato correttamente cancellato."
+    unsuccessful:
+      messages:
+        created: "Ci sono errori che impediscono la creazione di %{model}"
+        updated: "Ci sono errori che impediscono l'aggiornamento di %{model}"
+    errors:
+      messages:
+        record_invalid: "Record non valido"
+        blank: "non può essere lasciato in bianco"
+        required: "richiesto"
+        taken: "già presente"
+    attributes:
+      application_record: #serve per ransack default
+        created_at: "Data creazione"
+        updated_at: "Data aggiornamento"
+        id: "Id"
+  menu:
+    items: []
+  ransack:
+    predicates:
+      i_cont: "contiene"

data/config/routes.rb

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

data/docker-compose.yml

@@ -0,0 +1,20 @@
+services:
+  app:
+    command: /app/spec/dummy/bin/dev
+    build:
+      context: .
+    user: ${CMPS_UID_GID}
+    volumes:
+      - '.:/app'
+      - 'bundle:/bundle'
+      - '~/.gitconfig:/home/nobody/.gitconfig'
+      - '~/.gnupg:/home/nobody/.gnupg'
+      - '~/.gem:/home/nobody/.gem'
+      - '~/.ssh:/home/nobody/.ssh'
+    environment:
+      RAILS_ENV: development
+    ports:
+      - 3000:3000
+
+volumes:
+  bundle:

data/lib/base_editing_bootstrap/base_model.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module BaseEditingBootstrap
+  module BaseModel
+    extend ActiveSupport::Concern
+
+    included do
+      include IsValidated
+      delegate :ransackable_attributes, :ransackable_associations, to: :@class
+    end
+
+    class_methods do
+      def ransackable_attributes(auth_object = nil)
+        if auth_object
+          Pundit.policy(auth_object, self.new).permitted_attributes_for_ransack
+        else
+          Pundit.policy(User.new, self.new).permitted_attributes_for_ransack
+        end
+      end 
+      
+      def ransackable_associations(auth_object = nil)
+        if auth_object
+          Pundit.policy(auth_object, self.new).permitted_associations_for_ransack.map(&:to_s)
+        else
+          Pundit.policy(User.new, self.new).permitted_associations_for_ransack.map(&:to_s)
+        end
+      end
+    end
+  end
+end

data/lib/base_editing_bootstrap/engine.rb

@@ -0,0 +1,15 @@
+module BaseEditingBootstrap
+  class Engine < ::Rails::Engine
+
+    config.generators do |g|
+      g.test_framework :rspec
+      g.fixture_replacement :factory_bot
+      g.factory_bot dir: 'spec/factories'
+    end
+
+    initializer "base_editing_bootstrap.deprecator" do |app|
+      app.deprecators[:base_editing_bootstrap] = BaseEditingBootstrap.deprecator
+    end
+
+  end
+end

data/lib/base_editing_bootstrap/forms/base.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module BaseEditingBootstrap::Forms
+  class Base < ActionView::Helpers::FormBuilder
+    [
+      :text_field,
+      :text_area,
+      :date_field,
+      :datetime_field,
+      :time_field,
+      :file_field,
+      :number_field
+    ].each do |selector|
+      class_eval <<-RUBY_EVAL, __FILE__, __LINE__ + 1
+          def #{selector}(method, options = {})  
+            super(method,
+                  options.merge(class: form_style_class_for(method, options))
+            )
+          end                                    
+      RUBY_EVAL
+    end
+
+    ##
+    # Costruisce l'array delle classi che devono essere presenti sul campo della form
+    #
+    def form_style_class_for(method, options = {})
+      classes = ["form-control"]
+      classes << "is-invalid" if object.errors && object.errors.include?(method)
+      classes << options[:class].split(" ") if options[:class]
+      classes.flatten.compact.uniq.join(" ")
+    end
+
+    def decimal_field(field, options = {})
+      number_field(field,
+                   options.reverse_merge(
+                     value: @template.number_with_delimiter(object[field].to_f,
+                                                            separator: ".", # questo è secondo definizione html5
+                                                            delimiter: ""),
+                     step: :any
+                   ))
+    end
+
+    def ckeditor_text_area(field, options = {})
+      text_area(field, options.reverse_merge(data: {controller: "ckeditor"}))
+    end
+
+    def select(method, choices = nil, options = {}, html_options = {}, &block)
+      html_options[:class] = "form-select #{html_options[:class]}"
+      super(method, choices, options, html_options.merge(class: form_style_class_for(method, html_options)), &block)
+    end
+
+    def check_box(method, options = {}, checked_value = "1", unchecked_value = "0")
+      label = options.extract!(:label)[:label] || nil
+      if label
+        label_tag = label(label, class: "form-check-label")
+      else
+        label_tag = nil
+      end
+      classes = (["form-check"] + (options.extract!(:class)[:class] || "").split(" ")).join(" ")
+      @template.content_tag(:div, class: classes) do
+        super(method, options.reverse_merge(class: "form-check-input"), checked_value, unchecked_value) + label_tag
+      end
+    end
+
+    def switch_box(method, options = {}, checked_value = "1", unchecked_value = "0")
+      options[:class] = (["form-switch"] + (options[:class] || "").split(" ")).join(" ")
+      self.check_box(method, options, checked_value, unchecked_value)
+    end
+
+    def collection_check_boxes(method, collection, value_method, text_method, options = {}, html_options = {}, &block)
+      super do |builder|
+        @template.content_tag(:div, class: "form-check") do
+          builder.check_box(class: "form-check-input") + builder.label(class: "form-check-label")
+        end
+      end
+    end
+
+    def radio_button(method, tag_value, options = {})
+      @template.content_tag(:div, class: "form-check") do
+        super(method, tag_value, options.reverse_merge(class: "form-check-input")) +
+          label(method, class: "form-check-label")
+      end
+    end
+
+    ##
+    # Se necessario modificare il testo dell' "undo", basta aggiungere nelle traduzioni
+    # nella solita struttura di active record l'attributo :_submit_undo,
+    # per il normale submit consiglio la lettura della guida standard di rails
+    # ATTENZIONE: nelle classi del bottone undo, abbiamo aggiunto .btn-undo-button
+    #             che ascoltiamo dalle modal e utilizziamo per chiudere la modal, al posto
+    #             seguire realmente il link con il browser.
+    def submit(value = nil, options = {})
+      @template.content_tag(:div, class: "btn-group mr-1") do
+        super(value, options.reverse_merge(class: "btn btn-primary")) +
+          @template.link_to(object.class.human_attribute_name(:_submit_undo, default: :undo),
+                            @template.index_custom_polymorphic_path(object.class),
+                            class: "btn btn-default btn-undo-button")
+      end
+    end
+  end
+end

data/lib/base_editing_bootstrap/is_validated.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module BaseEditingBootstrap
+
+  module IsValidated
+    extend ActiveSupport::Concern
+
+    included do
+      ##
+      # Helpers per settare su un record quando abbiamo eseguito o meno la validazione e quindi
+      # utilizzare questa informazione nella renderizzazione dello stato della form.
+      attr_reader :is_validated
+      alias_method :validated?, :is_validated
+      after_initialize -> { @is_validated = false }
+      after_validation -> { @is_validated = true }
+    end
+  end
+end

data/lib/base_editing_bootstrap/searches/base.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module BaseEditingBootstrap::Searches
+  ##
+  # PORO per la gestione dei metodi associati alla ricerca.
+  class Base
+    include ActiveModel::Naming
+    include ActiveModel::Conversion
+
+    attr_reader :model_klass, :user, :params, :scope
+
+    # @param [User] user
+    # @param [ActiveRecord::Associations::CollectionProxy] scope
+    def initialize(scope, user, params: {page: nil})
+      @model_klass = scope.klass
+      @user = user
+      @scope = scope
+      @params = params
+    end
+
+    ##
+    # Risultato della ricerca, fa da pipeline verso ransack
+    def results
+      ransack_query
+        .result(distinct: true)
+        .order(:id)
+        .page(params[:page])
+    end
+
+    def ransack_query
+      scope
+        .ransack(params[:q], auth_object: user)
+    end
+
+    def search_fields
+      Pundit.policy(@user, @model_klass).search_fields.collect { |f| Field.new(self, f) }
+    end
+
+    def search_result_fields
+      Pundit.policy(@user, @model_klass).search_result_fields
+    end
+
+    def persisted?
+      false
+    end
+  end
+end

data/lib/base_editing_bootstrap/searches/field.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module BaseEditingBootstrap::Searches
+  ##
+  # PORO per gestione del singolo campo
+  class Field
+    attr_reader :search_base, :name
+
+    def initialize(search_base, name)
+      @search_base = search_base
+      @name = name
+    end
+
+    def to_partial_path
+      "search_field"
+    end
+  end
+end

data/lib/base_editing_bootstrap/version.rb

@@ -0,0 +1,3 @@
+module BaseEditingBootstrap
+  VERSION = "0.1.2"
+end

data/lib/base_editing_bootstrap.rb

@@ -0,0 +1,26 @@
+require "ransack"
+require "kaminari"
+require "pundit"
+
+if ENV['RAILS_ENV'] == 'test' and defined? RSpec
+  dir_path = File.expand_path('../spec/support/external_shared', __dir__)
+  Dir["#{dir_path}/*.rb"].each do |file|
+    require file
+  end
+end
+
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+module BaseEditingBootstrap
+  include ActiveSupport::Configurable
+  config_accessor :inherited_controller, default: "ApplicationController"
+
+  def self.deprecator
+    @deprecator ||= ActiveSupport::Deprecation.new("1.0", "BaseEditingBootstrap")
+  end
+
+end
+
+loader.eager_load

data/lib/tasks/base_editing_bootstrap_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :base_editing_bootstrap do
+#   # Task goes here
+# end

data/spec/support/external_shared/base_editing_controller_helpers.rb

@@ -0,0 +1,154 @@
+##
+# Condiviso con applicazione esterna
+
+def check_if_should_execute(only, except, action)
+  return false if except.include?(action)
+  return true if only.empty?
+  only.include?(action)
+end
+
+##
+# Helper per testare controller derivanti da base editing
+# only e except servono per filtrare o escludere determinate actions
+RSpec.shared_examples "base editing controller" do |factory: nil, only: [], except: [], skip_invalid_checks: false|
+  if factory
+    let(:inside_factory) { factory }
+  else
+    let(:inside_factory) { "to override inside_factory" }
+  end
+  let(:persisted_instance) do
+    create(inside_factory)
+  end
+
+  ##
+  # Possibili override per la costruzione delle path
+  #
+  let(:url_for_new) { [model.new, action: :new] }
+  let(:url_for_index) { url_for(model) }
+  let(:url_for_create) { [model.new] }
+  let(:url_for_succ_delete) { url_for(model) }
+  let(:url_for_fail_delete) { url_for_succ_delete }
+  let(:url_for_edit) { [persisted_instance, action: :edit] }
+  let(:url_for_update) { [persisted_instance, params: {param_key => valid_attributes}] }
+  ## non sempre abbiamo l'index nelle action disponibili, dobbiamo quindi avere modo di eseguire un override
+  let(:url_for_unauthorized) { url_for_index }
+  ##
+  # Chiave dentro a params
+  let(:param_key) {
+    Pundit::PolicyFinder.new(model).param_key
+  }
+
+  let(:model) {
+    persisted_instance.class
+  }
+
+  let(:invalid_attributes) {
+    attributes_for(inside_factory, :with_invalid_attributes)
+  }
+
+  let(:valid_attributes) {
+    nested_attributes_for(inside_factory)
+  }
+
+  it_behaves_like "fail with unauthorized", request: -> { get url_for(url_for_unauthorized) }
+
+  if check_if_should_execute(only, except, :index)
+    describe "index" do
+      it "response" do
+        params = {q: {"foo_eq": "foo"}}
+        get url_for_index, params: params
+        expect(response).to have_http_status(:ok)
+        expect(assigns[:search_instance]).to be_an_instance_of(BaseEditingBootstrap::Searches::Base).and(have_attributes(
+                                                                                                           user: user,
+                                                                                                           params: ActionController::Parameters.new(params).permit!
+                                                                                                         ))
+      end
+    end
+  end
+
+  if check_if_should_execute(only, except, :new)
+    describe "new" do
+      it "response" do
+        get url_for(url_for_new)
+        expect(response).to have_http_status(:ok)
+        expect(assigns[:object]).to be_an_instance_of(model)
+      end
+    end
+  end
+
+  if check_if_should_execute(only, except, :edit)
+    describe "edit" do
+      it "response" do
+        get url_for(url_for_edit)
+        expect(response).to have_http_status(:ok)
+        expect(assigns[:object]).to be_an_instance_of(model)
+      end
+    end
+  end
+
+  if check_if_should_execute(only, except, :update)
+    describe "update" do
+      it "response" do
+        put url_for(url_for_update)
+        expect(assigns[:object]).to be_an_instance_of(model)
+        expect(response).to have_http_status(:see_other)
+      end
+
+      unless skip_invalid_checks
+        it "not valid" do
+          put url_for([persisted_instance, params: {param_key => invalid_attributes}])
+          expect(response).to have_http_status(:unprocessable_entity)
+        end
+      end
+    end
+  end
+
+  if check_if_should_execute(only, except, :create)
+    describe "create" do
+      it "response" do
+        post url_for([*url_for_create, params: {param_key => valid_attributes}])
+        expect(assigns[:object]).to be_an_instance_of(model)
+        expect(response).to have_http_status(:see_other)
+      end
+
+      unless skip_invalid_checks
+        it "not valid" do
+          post url_for([*url_for_create, params: {param_key => invalid_attributes}])
+          expect(response).to have_http_status(:unprocessable_entity)
+        end
+      end
+    end
+  end
+
+  if check_if_should_execute(only, except, :delete)
+    describe "delete" do
+      it "response" do
+        delete url_for(persisted_instance)
+        expect(assigns[:object]).to be_an_instance_of(model)
+        expect(response).to redirect_to(url_for_succ_delete)
+      end
+
+      it "not valid" do
+        allow_any_instance_of(model).to receive(:destroy) do |obj|
+          obj.errors.add(:base, :indestructible)
+          false
+        end
+        delete url_for(persisted_instance)
+        expect(response).to redirect_to(url_for_fail_delete)
+        expect(flash[:error]).not_to be_blank
+      end
+    end
+  end
+end
+
+default_unathorized_failure = -> { raise "TODO - passare proc con richiesta che dovrà fallire" }
+
+RSpec.shared_examples "fail with unauthorized" do |request: default_unathorized_failure|
+  it "expect to redirect to root" do
+    expect(Pundit).to receive(:authorize).with(user, any_args).and_raise(Pundit::NotAuthorizedError)
+    instance_exec(&request)
+    expect(response).to redirect_to(root_path)
+    expect(flash[:error]).not_to be_nil
+  end
+end
+

data/spec/support/external_shared/base_model.rb

@@ -0,0 +1,62 @@
+RSpec.shared_examples "a base model" do |ransack_permitted_attributes: [], ransack_permitted_associations: []|
+
+  it_behaves_like "a validated? object"
+
+  describe "with ransackables" do
+    where(:base_model_method, :policy_method, :result) do
+      [
+        [
+          :ransackable_attributes, :permitted_attributes_for_ransack, ransack_permitted_attributes
+        ],
+        [
+          :ransackable_associations, :permitted_associations_for_ransack, ransack_permitted_associations
+        ]
+      ]
+    end
+
+    with_them do
+      subject { described_class.send(base_model_method, auth_object) }
+
+      let(:simulated_user_instance) { instance_double("User") }
+      # before do
+      #   allow(User).to receive(:new).and_return(simulated_user_instance)
+      # end
+      let(:auth_object) { nil }
+      let(:policy) {
+        instance_double("BaseModelPolicy", policy_method => result)
+      }
+      it "new user" do
+        expect(Pundit).to receive(:policy).with(an_instance_of(User),
+                                                an_instance_of(described_class)).and_call_original
+        #.and_return(policy)
+
+        is_expected.to match_array(result)
+      end
+
+      context "with auth_object" do
+        let(:auth_object) { :auth_object }
+        it do
+          expect(Pundit).to receive(:policy).with(auth_object, an_instance_of(described_class)).and_call_original
+          # .and_return(policy)
+
+          is_expected.to match_array(result)
+        end
+      end
+    end
+  end
+end
+
+RSpec.shared_examples "a validated? object" do
+  subject {
+    # prendiamo un modello a caso per testare questa  cosa
+    described_class.new
+  }
+
+  it { is_expected.not_to be_validated }
+
+  context "validated" do
+    subject { super().tap(&:valid?) }
+
+    it { is_expected.to be_validated }
+  end
+end

data/spec/support/external_shared/factory_bot.rb

@@ -0,0 +1,28 @@
+require 'factory_bot_rails'
+##
+# Condiviso con applicazione esterna
+# 
+# Helper per la generazione dati per la creazione di un hash utile alla creazione di un record
+# completo di associazioni
+# USAGE:
+# like attributes_for
+# nested_attributes_for(:factory_name)
+module FactoryBot::Syntax::Methods
+  def nested_attributes_for(*args)
+    attributes = attributes_for(*args)
+    klass = FactoryBot::Internal.factory_by_name(args.first).build_class
+
+    klass.reflect_on_all_associations(:belongs_to).each do |r|
+      association = FactoryBot.create(r.class_name.underscore)
+      attributes[:"#{r.name}_id"] = association.id
+      attributes[:"#{r.name}_type"] = association.class.name if r.options[:polymorphic]
+    end
+
+    attributes
+  end
+end
+
+
+RSpec.configure do |config|
+  config.include FactoryBot::Syntax::Methods
+end

data/spec/support/external_shared/pundit.rb

@@ -0,0 +1,14 @@
+RSpec::Matchers.define :permit_editable_attributes do |*expected_attributes|
+  description { "to permit editable attributes:#{expected_attributes}" }
+  failure_message { "'#{actual}' does not permit attributes #{expected_attributes - actual.editable_attributes}" }
+  match do |actual|
+    actual_attributes = expected_attributes - actual.editable_attributes
+
+    actual_attributes.empty?
+  end
+  match_when_negated do |actual|
+    actual_attributes = expected_attributes & actual.editable_attributes
+
+    actual_attributes.empty?
+  end
+end