satis 1.0.75 → 2.0.7

data/lib/generators/satis/install_generator.rb

@@ -0,0 +1,22 @@
+module Satis
+  class InstallGenerator < Rails::Generators::Base
+    source_root File.expand_path("../templates", __FILE__)
+
+    def create_initializer_file
+      template "config/initializers/satis.rb"
+    end
+
+    def add_route
+      return if Rails.application.routes.routes.detect { |route| route.app.app == Satis::Engine }
+      route %(mount Satis::Engine => "/satis")
+    end
+
+    def copy_migrations
+      rake "satis:install:migrations"
+    end
+
+    def tailwindcss_config
+      rake "satis:tailwindcss:config"
+    end
+  end
+end

data/lib/generators/satis/tailwind_config_generator.rb

@@ -0,0 +1,24 @@
+require 'rails/generators/base'
+
+module Satis
+  module Generators
+    class TailwindConfigGenerator < Rails::Generators::Base
+      source_root File.expand_path('../templates', __dir__)
+      desc 'Configures tailwind.config.js and application.tailwindcss.css'
+
+      def add_content_to_tailwind_config
+        inject_into_file "config/tailwind.config.js", before: "],\n  theme: {" do
+          "  // Satis content\n" +
+            %w[/app/views/**/* /app/helpers/**/* /app/controllers/**/* /app/components/**/* /app/javascript/**/*.js /app/assets/**/*.css].map { |path| "    \"#{Satis::Engine.root}#{path}\"" }.join(",\n") +
+            ",\n  "
+        end
+      end
+
+      def add_content_application_tailwind_css
+        inject_into_file "app/assets/stylesheets/application.tailwind.css", before: "@tailwind base;" do
+          "@import '#{Satis::Engine.root}/app/assets/stylesheets/satis/application.css';\n"
+        end
+      end
+    end
+  end
+end

data/lib/generators/satis/templates/config/initializers/satis.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+Satis.setup do |config|
+  config.submit_on_enter = false
+
+  config.logger = Rails.logger
+  config.confirm_before_leave = false
+  config.current_user = -> { Current.user }
+
+  config.default_help_text = lambda do |template, object, key, additional_scope|
+    I18n.t((["help"] + [key.to_s]).join("."), default: nil)
+  end
+end

data/lib/satis/concerns/contextual_translations.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+
+module Satis
+  module Concerns
+    module ContextualTranslations
+      extend ActiveSupport::Concern
+
+      included do
+        #
+        # This provides us with a translation helper which scopes into the original view
+        # and thereby conveniently scopes the translations.
+        #
+        # In your component.html.slim you can use:
+        # ```slim
+        # = ct(".#{tab.name}", scope: [group.to_sym])
+        # ````
+        #
+        # It'll then try and find a translation with scope: en.admin.spaces.edit.tabs.main.admin_versions
+        #
+        # NOTE: Add your own original_view_context method to refer to the original view context,
+        #       for components this is @template
+        #
+        def ct(key = nil, **options)
+          key = "#{full_i18n_scope(options).join('.')}#{key}" if key.start_with?('.')
+
+          original_view_context.t(key, **options)
+        end
+
+        def full_i18n_scope(options = {})
+          # NOTE: Caching this screws up the order
+          # return @full_i18n_scope if @full_i18n_scope
+
+          @full_i18n_scope = original_i18n_scope
+          @full_i18n_scope += Array.wrap(i18n_scope)
+          @full_i18n_scope += Array.wrap(@scope) if @scope
+          @full_i18n_scope += Array.wrap(options.delete(:scope))
+          @full_i18n_scope.flatten.compact!
+
+          @full_i18n_scope
+        end
+
+        def original_virtual_path
+          original_view_context.instance_variable_get(:@virtual_path)
+        end
+
+        def original_i18n_scope
+          original_virtual_path.sub(%r{^/}, '').gsub(%r{/_?}, '.').split('.')
+        end
+
+        def i18n_scope
+          self.class.name.split('::').second.underscore.to_sym
+        end
+      end
+    end
+  end
+end

data/lib/satis/configuration.rb

@@ -1,42 +1,52 @@
 # frozen_string_literal: true
 
 module Satis
-  class Configuration
-    attr_accessor :submit_on_enter, :confirm_before_leave
-    attr_writer :default_help_text, :current_user
-    attr_writer :logger
-
-    def initialize
-      @logger = Logger.new(STDOUT)
-      @submit_on_enter = true
-      @confirm_before_leave = false
-      @current_user = -> {}
-
-      @default_help_text = lambda do |_template, _object, key, _additional_scope|
-        scope = help_scope(template, object, additional_scope)
+  module Options
+    module ClassMethods
+      def option(name, default: nil)
+        attr_accessor(name)
+        schema[name] = default
+      end
 
-        value = I18n.t((["help"] + scope + [key.to_s]).join("."))
+      def schema
+        @schema ||= {}
+      end
+    end
 
-        if /translation missing: (.+)/.match?(value)
-          nil
-        else
-          value
-        end
+    def set_defaults!
+      self.class.schema.each do |name, default|
+        instance_variable_set("@#{name}", default)
       end
     end
 
-    # Config: logger [Object].
-    def logger
-      @logger.is_a?(Proc) ? instance_exec(&@logger) : @logger
+    def self.included(cls)
+      cls.extend(ClassMethods)
     end
+  end
+
+  class Configuration
+    include Options
 
-    def default_help_text(template, object, method, additional_scope)
-      if @default_help_text.is_a?(Proc)
-        instance_exec(template, object, method, additional_scope,
-          &@default_help_text)
+    option :full_width_topbar, default: false
+    option :logger, default: Rails.logger
+    option :submit_on_enter, default: true
+    option :confirm_before_leave, default: false
+    option :current_user, default: lambda {}
+
+    option(:default_help_text, default: lambda do |template, object, key, additional_scope|
+      scope = help_scope(template, object, additional_scope)
+
+      value = I18n.t((["help"] + scope + [key.to_s]).join("."))
+
+      if /translation missing: (.+)/.match?(value)
+        nil
       else
-        @default_help_text
+        value
       end
+    end)
+
+    def initialize
+      set_defaults!
     end
 
     # Maybe not the right place?
@@ -58,11 +68,22 @@ module Satis
 
       actions.map { |action| help_scope(template, object, additional_scope, action: action) }
     end
+  end
+
+  module Configurable
+    attr_writer :config
 
-    def current_user
-      raise 'current_user should be a Proc' unless @current_user.is_a? Proc
+    def config
+      @config ||= Configuration.new
+    end
+
+    def configure
+      yield(config)
+    end
+    alias setup configure
 
-      instance_exec(&@current_user)
+    def reset_config!
+      @config = Configuration.new
     end
   end
 end

data/lib/satis/engine.rb

@@ -2,12 +2,35 @@ require 'satis/forms/builder'
 require 'satis/helpers/container'
 require 'satis/menus/builder'
 
+require 'view_component'
+require 'browser'
+require 'browser/aliases'
+require 'jsonb_accessor'
+require 'slim'
+require 'tailwindcss-rails'
+require "importmap-rails"
+require "turbo-rails"
+require "stimulus-rails"
+
 module Satis
   class Engine < ::Rails::Engine
     isolate_namespace Satis
 
-    config.autoload_paths << "#{root}/app/components"
-    config.autoload_paths << "#{root}/lib"
+    config.autoload_paths << root.join("lib")
+
+    initializer 'satis.assets' do |app|
+      app.config.assets.paths << root.join("app/javascript")
+      app.config.assets.paths << root.join("app/components")
+      app.config.assets.paths << Satis::Engine.root.join("vendor/javascript")
+      app.config.assets.precompile += %w[satis_manifest]
+    end
+
+    initializer 'satis.importmap', before: "importmap" do |app|
+      app.config.importmap.paths << root.join("config/importmap.rb")
+      app.config.importmap.cache_sweepers << root.join("app/javascript")
+      app.config.importmap.cache_sweepers << root.join("app/components")
+      app.config.importmap.cache_sweepers << Satis::Engine.root.join("vendor/javascript")
+    end
 
     initializer 'satis.helper' do
       Rails.application.reloader.to_prepare do
@@ -23,13 +46,5 @@ module Satis
         end
       end
     end
-
-    initializer :append_migrations do |app|
-      unless app.root.to_s.match? root.to_s
-        config.paths['db/migrate'].expanded.each do |expanded_path|
-          app.config.paths['db/migrate'] << expanded_path
-        end
-      end
-    end
   end
 end

data/lib/satis/forms/builder.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'satis/concerns/contextual_translations'
 require 'satis/forms/concerns/buttons'
 require 'satis/forms/concerns/file'
 require 'satis/forms/concerns/required'
@@ -19,6 +20,12 @@ module Satis
       include Concerns::Required
       include Concerns::Buttons
 
+      include Satis::Concerns::ContextualTranslations
+
+      def original_view_context
+        @template
+      end
+
       # Regular input
       def input(method, options = {}, &block)
         @form_options = options
@@ -29,6 +36,13 @@ module Satis
         send(input_type_for(method, options), method, options, &block)
       end
 
+      # NOTE: TDG - seems to be overwritten below
+      # def input_array(method, options = {}, &block)
+      #   @form_options = options
+      #
+      #   input_array(method, options, &block)
+      # end
+
       # A codemirror editor, backed by a text-area
       def editor(method, options = {}, &block)
         @form_options = options
@@ -106,9 +120,9 @@ module Satis
                                        class: 'invalid-feedback')
           end
           safe_join [
-            invalid_feedback,
-            rails_fields_for(*args, options, &block)
-          ].compact
+                      invalid_feedback,
+                      rails_fields_for(*args, options, &block)
+                    ].compact
         end
       end
 
@@ -116,9 +130,9 @@ module Satis
         options = args.extract_options!
         form_group(*args, options) do
           safe_join [
-            (custom_label(*args, options[:label]) unless options[:label] == false),
-            rich_text_area(*args, options)
-          ]
+                      (custom_label(*args, options[:label]) unless options[:label] == false),
+                      rich_text_area(*args, options)
+                    ]
         end
       end
 
@@ -159,12 +173,12 @@ module Satis
       end
 
       def form_group(method, options = {}, &block)
-        tag.div(class: "form-group form-group-#{method}", data: options[:data]) do
+        tag.div(class: "form-group form-group-#{method}", data: options.delete(:data)) do
           safe_join [
-            block.call,
-            hint_text(options[:hint]),
-            error_text(method)
-          ].compact
+                      block.call,
+                      hint_text(options[:hint]),
+                      error_text(method)
+                    ].compact
         end
       end
 
@@ -206,11 +220,11 @@ module Satis
         all_classes = "#{options[:class]} form-label".strip
         label(method, title, class: all_classes, data: options[:data]) do |translation|
           safe_join [
-            tag.span(title || translation, class: required?(method) ? 'required' : ''),
-            ' ',
-            required(method, options),
-            help(method, options)
-          ]
+                      tag.span(title || translation, class: required?(method) ? 'required' : ''),
+                      ' ',
+                      required(method, options),
+                      help(method, options)
+                    ]
         end
       end
 
@@ -224,8 +238,8 @@ module Satis
         text = if options[:help].present?
                  options[:help]
                else
-                 Satis.config.default_help_text(@template, @object, method,
-                                                @options[:help_scope] || options[:help_scope])
+                 Satis.config.default_help_text.call(@template, @object, method,
+                                                     @options[:help_scope] || options[:help_scope])
                end
 
         return if text.blank?
@@ -239,73 +253,101 @@ module Satis
 
       # Inputs and helpers
       def string_input(method, options = {})
-        form_group(method, options) do
+        orig_data = options.fetch(:data, {}).merge(controller: 'satis-input')
+        scrollable = options.fetch(:scrollable, false)
+
+        css_class = ["form-control"]
+        css_class << "is-invalid" if has_error?(method)
+        css_class << "noscroll" unless scrollable
+
+        data = options[:input_html].fetch(:data, {})
+        data = data.merge('satis-input-target' => 'input')
+        options[:input_html] = options[:input_html].merge(data: data)
+
+        form_group(method, options.merge(data: orig_data)) do
           safe_join [
-            (custom_label(method, options[:label], options) unless options[:label] == false),
-            string_field(method,
-                         merge_input_options({ as: options[:as], class: "form-control #{if has_error?(method)
-                                                                                          'is-invalid'
-                                                                                        end}" }, options[:input_html]))
-          ]
+                      (custom_label(method, options[:label], options) unless options[:label] == false),
+                      string_field(method, merge_input_options({ as: options[:as], class: "#{css_class.join(' ')}" }, options[:input_html]))
+                    ]
         end
       end
 
       def number_input(method, options = {})
         form_group(method, options) do
           safe_join [
-            (custom_label(method, options[:label], options) unless options[:label] == false),
-            number_field(method,
-                         merge_input_options({ class: "form-control #{if has_error?(method)
-                                                                        'is-invalid'
-                                                                      end}" }, options[:input_html]))
-          ]
+                      (custom_label(method, options[:label], options) unless options[:label] == false),
+                      number_field(method,
+                                   merge_input_options({ class: "form-control #{
+                                     if has_error?(method)
+                                       'is-invalid'
+                                     end}" }, options[:input_html]))
+                    ]
         end
       end
 
       def text_input(method, options = {})
         form_group(method, options) do
           safe_join [
-            (custom_label(method, options[:label], options) unless options[:label] == false),
-            text_area(method,
-                      merge_input_options({ class: "form-control #{if has_error?(method)
-                                                                     'is-invalid'
-                                                                   end}" }, options[:input_html]))
-          ]
+                      (custom_label(method, options[:label], options) unless options[:label] == false),
+                      text_area(method,
+                                merge_input_options({ class: "form-control #{
+                                  if has_error?(method)
+                                    'is-invalid'
+                                  end}" }, options[:input_html]))
+                    ]
         end
       end
 
-      def editor_input(method, options = {})
+      def input_array(method, options = {})
         form_group(method, options) do
           safe_join [
-            (custom_label(method, options[:label], options) unless options[:label] == false),
-            tag.div(text_area(method,
-                              merge_input_options({
-                                                    class: 'form-control',
-                                                    data: {
-                                                      controller: 'satis-editor',
-                                                      'satis-editor-target' => 'textarea',
-                                                      'satis-editor-read-only-value' => options.delete(:read_only) || false,
-                                                      'satis-editor-mode-value' => options.delete(:mode) || 'text/html',
-                                                      'satis-editor-height-value' => options.delete(:height) || '200px',
-                                                      'satis-editor-color-scheme-value' => options.delete(:color_scheme),
-                                                      'satis-editor-color-scheme-dark-value' => options.delete(:color_scheme_dark) || 'lucario'
-                                                    }
-
-                                                  }, options[:input_html])), class: "editor #{if has_error?(method)
-                                                                                                'is-invalid'
-                                                                                              end}"),
-            hint_text(options[:hint] || '⌘-F/⌃-f: search; ⌥-g: goto line, ⌃-space: autocomplete')
-          ]
+                      (custom_label(method, options[:label], options) unless options[:label] == false),
+                      render(Satis::InputArray::Component.new(form: self, attribute: method, **options))
+                    ]
         end
       end
 
+      def editor_input(method, options = {}, &block)
+        form_group(method, options) do
+          safe_join [
+                      (custom_label(method, options[:label], options) unless options[:label] == false),
+                      @template.render(Satis::Editor::Component.new(form: self, attribute: method, **options, &block))
+                    ]
+        end
+        # form_group(method, options) do
+        #   safe_join [
+        #               (custom_label(method, options[:label], options) unless options[:label] == false),
+        #               tag.div(text_area(method,
+        #                                 merge_input_options({
+        #                                                       class: 'form-control hidden',
+        #                                                       data: {
+        #                                                         # controller: 'satis-editor',
+        #                                                         'satis-editor-target' => 'textarea',
+        #                                                         'satis-editor-read-only-value' => options.delete(:read_only) || false,
+        #                                                         'satis-editor-mode-value' => options.delete(:mode) || 'text/html',
+        #                                                         'satis-editor-height-value' => options.delete(:height) || '200px',
+        #                                                         'satis-editor-color-scheme-value' => options.delete(:color_scheme),
+        #                                                         'satis-editor-color-scheme-dark-value' => options.delete(:color_scheme_dark) || 'lucario'
+        #                                                       }
+        #
+        #                                                     }, options[:input_html])), class: "editor #{
+        #                 if has_error?(method)
+        #                   'is-invalid'
+        #                 end}", data: {
+        #                 controller: 'satis-editor'
+        #               }),
+        #               hint_text(options[:hint] || '⌘-F/⌃-f: search; ⌥-g: goto line, ⌃-space: autocomplete')
+        #             ]
+        # end
+      end
+
       def boolean_input(method, options = {})
         form_group(method, options) do
           tag.div(class: 'custom-control custom-checkbox') do
             safe_join [
-              check_box(method, merge_input_options({ class: 'custom-control-input' }, options[:input_html])),
-              label(method, options[:label], class: 'custom-control-label')
-            ]
+                        check_box(method, merge_input_options({ class: 'custom-control-input' }, options[:input_html])),
+                        label(method, options[:label], class: 'custom-control-label')
+                      ]
           end
         end
       end
@@ -315,7 +357,7 @@ module Satis
       def switch_input(method, options = {}, &block)
         form_group(method, options) do
           render(Satis::Switch::Component.new(form: self, attribute: method, title: options[:label], **options,
-&block))
+                                              &block))
         end
       end
 
@@ -329,10 +371,10 @@ module Satis
         end
         form_group(method, options) do
           safe_join [
-            (custom_label(method, options[:label], options) unless options[:label] == false),
-            render(Satis::DateTimePicker::Component.new(form: self, attribute: method, title: options[:label], **options,
-    &block))
-          ]
+                      (custom_label(method, options[:label], options) unless options[:label] == false),
+                      render(Satis::DateTimePicker::Component.new(form: self, attribute: method, title: options[:label], **options,
+                                                                  &block))
+                    ]
         end
       end
 
@@ -345,14 +387,15 @@ module Satis
 
         tag.div('data-controller' => 'phone-number') do
           safe_join [
-            hidden_field(method,
-                         merge_input_options({ class: 'form-control', 'data-phone-number-target': 'hiddenInput' },
-                                             options[:input_html])),
-            @template.text_field_tag('dummy', @object.try(method), class: "form-control #{if has_error?(method)
-                                                                                            'is-invalid'
-                                                                                          end}", 'data-phone-number-target': 'input',
-                                                                   'data-action': 'input->phone-number#change')
-          ]
+                      hidden_field(method,
+                                   merge_input_options({ class: 'form-control', 'data-phone-number-target': 'hiddenInput' },
+                                                       options[:input_html])),
+                      @template.text_field_tag('dummy', @object.try(method), class: "form-control #{
+                        if has_error?(method)
+                          'is-invalid'
+                        end}", 'data-phone-number-target': 'input',
+                                               'data-action': 'input->phone-number#change')
+                    ]
         end
       end
 
@@ -365,21 +408,21 @@ module Satis
                                                                   else raise 'Invalid input_type for collection_of, valid input_types are ":radio_buttons", ":check_boxes"'
                                                                   end
         options[:value_method] ||= :last
-        options[:text_method]  ||= options[:label_method] || :first
+        options[:text_method] ||= options[:label_method] || :first
         form_group(method, options) do
           safe_join [
-            label(method, options[:label]),
-            tag.br,
-            (send(form_builder_method, method, options[:collection], options[:value_method],
-                  options[:text_method]) do |b|
-               tag.div(class: "custom-control #{custom_class}") do
-                 safe_join [
-                   b.send(input_builder_method, options.fetch(:input_html, {}).merge(class: 'custom-control-input')),
-                   b.label(class: 'custom-control-label')
-                 ]
-               end
-             end)
-          ]
+                      label(method, options[:label]),
+                      tag.br,
+                      (send(form_builder_method, method, options[:collection], options[:value_method],
+                            options[:text_method]) do |b|
+                        tag.div(class: "custom-control #{custom_class}") do
+                          safe_join [
+                                      b.send(input_builder_method, options.fetch(:input_html, {}).merge(class: 'custom-control-input')),
+                                      b.label(class: 'custom-control-label')
+                                    ]
+                        end
+                      end)
+                    ]
         end
       end
 
@@ -403,7 +446,7 @@ module Satis
         else
           case method.to_s
           when /password/ then password_field(method, options)
-            # FIXME: Possibly use time_zone_select with dropdown?
+          # FIXME: Possibly use time_zone_select with dropdown?
           when /time_zone/ then time_zone_select(method, options.delete(:priority_zones), options,
                                                  { class: 'custom-select form-control' })
           # FIXME: Possibly use country_select with dropdown?

data/lib/satis/forms/concerns/buttons.rb

@@ -30,9 +30,9 @@ module Satis
           # A continue button
           def continue(value = nil, options = {}, &block)
             value ||= if !@object.persisted?
-                        t('.create_continue', default: 'Create and continue editing')
+                        ct('create_continue')
                       else
-                        t('.update_continue', default: 'Update and continue editing')
+                        ct('update_continue')
                       end
             button_button(value, options.reverse_merge(name: 'commit', value: 'continue', class: 'button secondary'),
                           &block)

data/lib/satis/forms/concerns/file.rb

@@ -17,7 +17,7 @@ module Satis
                 (custom_label(method, options[:label], options) unless options[:label] == false),
                 tag.div(class: 'overflow-hidden relative inline-block -mb-2') do
                   safe_join [
-                    tag.button((options[:multiple] ? t('choose_files') : t('choose_file')), type: 'button',
+                    tag.button((options[:multiple] ? ct('choose_files') : ct('choose_file')), type: 'button',
                                                                                             class: 'bg-white py-3 px-4 border border-gray-300 rounded-md shadow-sm text-sm leading-4 font-medium text-gray-700 hover:bg-gray-100 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-primary-500'),
                     file_field(method,
                                options.merge(class: 'w-full cursor-pointer absolute block opacity-0 inset-0',