inline_forms 8.1.21 → 8.1.42

data/lib/inline_forms/form_elements/slider_with_values_helper.rb

@@ -5,35 +5,34 @@ module InlineForms
       module_eval(<<~'INLINE_FORMS_FORM_ELEMENT', __FILE__, __LINE__ + 1)
     # -*- encoding : utf-8 -*-
     
-    # slider_with_values
+    # slider_with_values -- native <input type="range"> since 8.1.26 (replaces
+    # the jQuery UI slider and its inline <script>). The label text next to the
+    # slider is kept in sync by initInlineFormsWidgets (class hook
+    # `slider_with_values`, labels in data-slider-values, target <output> id in
+    # data-slider-output); helpers emit no per-field scripts.
     def slider_with_values_show(object, attribute)
       values = attribute_values(object, attribute)
       value = object.send(attribute).to_i         # should be an int
-      display_value = values.assoc(value)[1]      # values should be [ [ 0, value ], [ 3, value2 ] .... ] and we lookup the key, not the place in the array!
+      # values should be [ [ 0, value ], [ 3, value2 ] .... ] and we lookup the
+      # key, not the place in the array! A value with no entry (e.g. 0 when the
+      # values hash starts at 1) falls back to the bare number instead of
+      # crashing (pre-8.1.26 code did values.assoc(value)[1] unguarded).
+      display_value = (pair = values.assoc(value)) ? pair[1] : value.to_s
       css_id = "#{object.class.to_s.underscore}_#{object.id}_#{attribute}"
       if value == 0
         out = "?"   # we use this as the 'unknown' value. So in the data, 0 should always be the unknown value. This gives problems with sliders where the real value is 0.
       else
+        # <progress> (not a disabled <input type=range>): the show panel is
+        # wrapped in the inline-edit link, and a disabled input would swallow
+        # the click; progress is non-interactive so the click-to-edit works.
         out = "".html_safe
-        out << "<div class='slider slider_#{attribute.to_s}' id='slider_#{css_id}'></div>".html_safe
-        out << "<div class='slider_value' id='value_#{css_id}'>#{display_value}</div>".html_safe
-        out << "<div style='clear: both' />".html_safe
-        out << "<input type='hidden' name='_#{object.class.to_s.underscore}[#{attribute}]' value='0' id='input_#{css_id}' />".html_safe
-        out << ('<script>
-                  $(function() {
-                    var displayvalues = ' + values.collect {|x| x[1]}.inspect + ';
-                    $( "#slider_' + css_id + '" ).slider(
-                      {
-                        value:' + value.to_s + ',
-                        range: "min",
-                        disabled: true,
-                        min: 0,
-                        max: ' + values.length.to_s + ',
-                        step: 1,
-                      }
-                    );
-                  });
-                 </script>').html_safe
+        out << content_tag(:progress, nil,
+                           value: value,
+                           max: values.collect(&:first).max.to_i,
+                           class: "slider slider_#{attribute}",
+                           id: "slider_#{css_id}")
+        out << content_tag(:div, display_value, class: 'slider_value', id: "value_#{css_id}")
+        out << "<div style='clear: both'></div>".html_safe
       end
       link_to_inline_edit object, attribute, out, from_callee: __callee__
     end
@@ -43,56 +42,24 @@ module InlineForms
       values = attribute_values(object, attribute)
       value = object.send(attribute).to_i         # should be an int, will be 0 if nil
       css_id = "#{object.class.to_s.underscore}_#{object.id}_#{attribute}"
-      display_value = values.assoc(value)[1]      # values should be [ [ 0, value ], [ 3, value2 ] .... ] and we lookup the key, not the place in the array!
+      display_value = (pair = values.assoc(value)) ? pair[1] : value.to_s
+      labels = values.collect { |x| x[1] }
       out = "".html_safe
-      out << "<div class='slider slider_#{attribute.to_s}' id='slider_#{css_id}'></div>".html_safe
-      out << "<div class='slider_value' id='value_#{css_id}'>#{display_value}</div>".html_safe
-      out << "<div style='clear: both' />".html_safe
-      out << "<input type='hidden' name='_#{object.class.to_s.underscore}[#{attribute}]' value='0' id='input_#{css_id}' />".html_safe
-      out << ('<script>
-    	$(function() {
-        var displayvalues = ' + values.collect {|x| x[1]}.inspect + ';
-    		$( "#slider_' + css_id + '" ).slider(
-          {
-            value:' + value.to_s + ',
-            range: "min",
-            min: 0,
-            max: 5,
-            step: 1,
-            slide: function( event, ui ) {
-              $( "#input_' + css_id + '" ).val( ui.value );
-              $( "#value_' + css_id + '" ).html( displayvalues[ui.value] );
-            }
-      		}
-        );').html_safe
-      out << ('$( "#value_' + css_id + '" ).html(displayvalues[' + value.to_s + ']);').html_safe
-    	out << ('$( "#input_' + css_id + '" ).val(' + value.to_s + ');').html_safe
-    	out << ('});
-    	</script>').html_safe
+      out << range_field_tag("_#{object.class.to_s.underscore}[#{attribute}]", value,
+                             id: "input_#{css_id}",
+                             class: "slider slider_#{attribute} slider_with_values",
+                             in: 0..(values.collect(&:first).max.to_i),
+                             step: 1,
+                             data: { slider_values: labels.to_json,
+                                     slider_output: "value_#{css_id}" })
+      out << content_tag(:output, display_value, class: 'slider_value', id: "value_#{css_id}")
+      out << "<div style='clear: both'></div>".html_safe
       out
     end
     
     def slider_with_values_update(object, attribute)
       object[attribute.to_sym] = params[('_' + object.class.to_s.underscore).to_sym][attribute.to_sym]
     end
-    
-    #<style>
-    #	#demo-frame > div.demo { padding: 10px !important; };
-    #	</style>
-    #
-    #
-    #
-    #<div class="demo">
-    #
-    #<p>
-    #	<label for="amount">Donation amount ($50 increments):</label>
-    #	<input type="text" id="amount" style="border:0; color:#f6931f; font-weight:bold;" />
-    #</p>
-    #
-    #<div id="slider"></div>
-    #
-    #</div><!-- End demo -->
-    #
       INLINE_FORMS_FORM_ELEMENT
     end
   end

data/lib/inline_forms/form_elements/time_helper.rb

@@ -10,9 +10,11 @@ module InlineForms
         link_to_inline_edit object, attribute, object.send(attribute).nil? ? "<i class='fi-plus'></i>".html_safe : object.send(attribute).to_datetime.strftime("%l:%M%P"), from_callee: __callee__
       end
     
+      # Native <input type="time"> (8.1.25; replaces the jQuery timepicker).
+      # Submits 24h "HH:MM", which Active Record casts directly to a time column.
       def time_select_edit(object, attribute)
         css_id = 'timepicker_' + object.class.to_s.underscore + '_' + object.id.to_s + '_' + attribute.to_s
-        out = text_field_tag attribute, ( object.send(attribute).nil? ? "" : object.send(attribute).to_datetime.strftime("%l:%M%P") ), :id => css_id, :class =>'timepicker'
+        time_field_tag attribute, ( object.send(attribute).nil? ? "" : object.send(attribute).to_datetime.strftime("%H:%M") ), :id => css_id, :class => 'time_select'
       end
     
       def time_select_update(object, attribute)

data/lib/inline_forms/gem_files.rb

@@ -1,4 +1,5 @@
 # -*- encoding: utf-8 -*-
+
 module InlineFormsGemFiles
   INSTALLER_FILE_PREFIXES = %w[
     bin/inline_forms
@@ -8,6 +9,24 @@ module InlineFormsGemFiles
     inline_forms_installer.gemspec
   ].freeze
 
+  # The schema-GUI gem lives in its own subdirectory with its own gemspec
+  # (inline_forms_schema_edit/inline_forms_schema_edit.gemspec) and packages
+  # its files itself; exclude the whole subtree from BOTH gems here.
+  SCHEMA_GUI_FILE_PREFIXES = %w[
+    inline_forms_schema_edit/
+  ].freeze
+
+  # Scratch / local-notes dir. It holds working notes and, crucially, secrets
+  # such as stuff/forgejo-token (mode 0600, only used by CI pushes to forgejo).
+  # It must NEVER be packaged into a gem. Do not rely on git ignore for this:
+  # gem_files sweeps untracked files too, and the global excludes file that
+  # ignores stuff/ is per-machine (present here, absent on the release box), so
+  # the token leaked into `gem build` on the release machine. Exclude it hard,
+  # independent of any ignore configuration.
+  EXCLUDED_FILE_PREFIXES = %w[
+    stuff/
+  ].freeze
+
   module_function
 
   REPO_ROOT = File.expand_path("../..", __dir__)
@@ -31,6 +50,14 @@ module InlineFormsGemFiles
 
     files.select! { |f| File.file?(File.join(REPO_ROOT, f)) }
 
+    files.reject! do |f|
+      EXCLUDED_FILE_PREFIXES.any? { |prefix| f == prefix || f.start_with?(prefix) }
+    end
+
+    files.reject! do |f|
+      SCHEMA_GUI_FILE_PREFIXES.any? { |prefix| f == prefix || f.start_with?(prefix) }
+    end
+
     files.reject do |f|
       installer_file = INSTALLER_FILE_PREFIXES.any? { |prefix| f == prefix || f.start_with?(prefix) }
       include_installer ? !installer_file : installer_file

data/lib/inline_forms/schema_apply.rb

@@ -0,0 +1,85 @@
+# -*- encoding : utf-8 -*-
+
+require "shellwords"
+
+module InlineForms
+  # Skeleton of the "apply" step of the staging pipeline: turn an approved
+  # SchemaIntent into the ordered shell commands a developer would run by hand
+  # (generate the migration + model edit, migrate, test, commit, restart). This
+  # is the rare, expensive, deliberate step — see the staging doc.
+  #
+  # The engine does NOT execute these itself by default: which host runs them
+  # (a rake task on a single-server box, or a CI job after a PR on a clustered
+  # deploy) is an app decision. #commands returns the plan for inspection;
+  # #run! executes it via an injectable runner (defaults to Kernel#system) and
+  # stops at the first failure, so an app/rake task can opt in.
+  class SchemaApply
+    STEPS = %i[generate migrate].freeze
+
+    # In-process generate-only executor used by the schema GUI: runs the addto
+    # generator against the app's tree (edits the model, writes the migration
+    # file) but never migrates. Overridable so tests can record the args
+    # instead of mutating the working tree.
+    DEFAULT_GENERATE_EXECUTOR = lambda do |args, destination_root|
+      require "generators/inline_forms_addto_generator"
+      InlineFormsAddtoGenerator.start(args, destination_root: destination_root)
+    end
+
+    attr_reader :intent
+
+    def initialize(intent, runner: nil)
+      @intent = intent
+      @runner = runner || ->(cmd) { system(*cmd) }
+    end
+
+    # Run the addto generator in-process (model edit + migration file) WITHOUT
+    # running db:migrate. Returns the path of the migration it created (or nil
+    # when the executor did not create one, e.g. a recording test executor).
+    # The caller (GUI) then tells the user to run `rails db:migrate` + restart;
+    # the pending-migration gate covers the interim.
+    def generate!(destination_root:, executor: DEFAULT_GENERATE_EXECUTOR)
+      before = addto_migrations(destination_root)
+      executor.call(intent.generator_args, destination_root)
+      # Only report a migration this run actually created. nil is correct and
+      # expected for a :header (no column -> no migration) and must NOT fall
+      # back to a pre-existing migration file.
+      (addto_migrations(destination_root) - before).max
+    end
+
+    # `rails g inline_forms_addto <Model> <attr:fe> [--after=..]`.
+    def generator_command
+      %w[bundle exec rails g inline_forms_addto] + intent.generator_args
+    end
+
+    def migrate_command
+      %w[bundle exec rails db:migrate]
+    end
+
+    # Ordered plan (each value is an argv array).
+    def commands
+      { generate: generator_command, migrate: migrate_command }
+    end
+
+    # Human-readable plan (what an app would show before the user confirms).
+    def preview_plan
+      STEPS.map { |step| "#{step}: #{Shellwords.join(commands.fetch(step))}" }
+    end
+
+    # Execute generate -> migrate, stopping at the first failure. Returns the
+    # step that failed, or nil on success. NOT run in tests (would shell out);
+    # an app/rake task calls this after approval + a git-clean check.
+    def run!
+      STEPS.each do |step|
+        ok = @runner.call(commands.fetch(step))
+        return step unless ok
+      end
+      nil
+    end
+
+    private
+
+    def addto_migrations(destination_root)
+      Dir.glob(File.join(destination_root.to_s, "db", "migrate", "*_inline_forms_add_to_*.rb"))
+    end
+  end
+end

data/lib/inline_forms/schema_intent.rb

@@ -0,0 +1,76 @@
+# -*- encoding : utf-8 -*-
+
+module InlineForms
+  # A *proposed* schema change: "add attribute X of form-element Y to model Z,
+  # at this position". This is the unit the end-user-facing staging pipeline
+  # (see stuff/2026-07-11-end-user-schema-changes-staging-and-pending-gate.md)
+  # drafts, previews, and finally applies.
+  #
+  # It is a plain value object — deliberately NOT an ActiveRecord model. Where
+  # intents are persisted (a drafts table) and edited (a GUI) is an app-level
+  # concern; the engine only needs the structured description plus the mapping
+  # to the generator that realizes it. Nothing renders from an intent at
+  # runtime, so it is an audit/work-queue artifact, not config-as-data.
+  #
+  # STATUS is advisory metadata for a persisting app: draft -> approved ->
+  # applied (or failed).
+  class SchemaIntent
+    STATUSES = %i[draft approved applied failed].freeze
+
+    attr_reader :model_name, :attribute, :form_element, :values, :disabled, :after, :before
+    attr_accessor :status
+
+    def initialize(model_name:, attribute:, form_element:,
+                   values: nil, disabled: nil, after: nil, before: nil, status: :draft)
+      @model_name   = model_name.to_s
+      @attribute    = attribute.to_sym
+      @form_element = form_element.to_sym
+      @values       = values
+      @disabled     = disabled
+      @after        = after&.to_sym
+      @before       = before&.to_sym
+      self.status   = status
+    end
+
+    def status=(value)
+      sym = value.to_sym
+      unless STATUSES.include?(sym)
+        raise ArgumentError, "unknown status #{value.inspect} (expected one of #{STATUSES.inspect})"
+      end
+
+      @status = sym
+    end
+
+    # The model class this intent targets. Raises NameError if it is not
+    # defined (an app should validate the name before drafting).
+    def model_class
+      model_name.constantize
+    end
+
+    # The `attr:form_element` token exactly as the generator expects it.
+    def column_token
+      "#{attribute}:#{form_element}"
+    end
+
+    # argv for `rails g inline_forms_addto <Model> <attr:form_element> [--after=..]`.
+    def generator_args
+      args = [ model_name, column_token ]
+      args << "--after=#{after}"   if after
+      args << "--before=#{before}" if before
+      args
+    end
+
+    def to_h
+      {
+        model_name: model_name,
+        attribute: attribute,
+        form_element: form_element,
+        values: values,
+        disabled: disabled,
+        after: after,
+        before: before,
+        status: status
+      }
+    end
+  end
+end

data/lib/inline_forms/schema_label.rb

@@ -0,0 +1,65 @@
+# -*- encoding : utf-8 -*-
+
+require "yaml"
+require "fileutils"
+
+module InlineForms
+  # Writes a human label for a model attribute (or header) into a locale file,
+  # so `human_attribute_name` renders it. Used by the schema GUI's optional
+  # "Label" field. Like the header/field edits, this is a code/config change
+  # that lands in the working tree (git-tracked) — never the DB.
+  #
+  # The label is merged (not clobbered) into
+  #   config/locales/inline_forms_labels.<locale>.yml
+  # under the key inline_forms renders from:
+  #   <locale>: activerecord: attributes: <model_i18n_key>: <attribute>: "Label"
+  #
+  # A dedicated file (rather than editing an existing app locale file) keeps the
+  # write a whole-document load -> deep_merge -> dump, which is robust against
+  # comments/formatting concerns.
+  module SchemaLabel
+    module_function
+
+    def file_path(destination_root, locale)
+      File.join(destination_root.to_s, "config", "locales", "inline_forms_labels.#{locale}.yml")
+    end
+
+    def i18n_key_for(model_class)
+      if model_class.respond_to?(:model_name)
+        model_class.model_name.i18n_key.to_s
+      else
+        model_class.to_s.underscore
+      end
+    end
+
+    # Merge the label into the locale file and return its path.
+    def write(destination_root:, model_class:, attribute:, label:, locale:)
+      path      = file_path(destination_root, locale)
+      key       = i18n_key_for(model_class)
+      existing  = load_document(path)
+      addition  = {
+        locale.to_s => {
+          "activerecord" => {
+            "attributes" => {
+              key => { attribute.to_s => label.to_s }
+            }
+          }
+        }
+      }
+      merged = existing.deep_merge(addition)
+
+      FileUtils.mkdir_p(File.dirname(path))
+      File.write(path, merged.to_yaml)
+      path
+    end
+
+    def load_document(path)
+      return {} unless File.exist?(path)
+
+      loaded = YAML.safe_load(File.read(path))
+      loaded.is_a?(Hash) ? loaded : {}
+    rescue StandardError
+      {}
+    end
+  end
+end

data/lib/inline_forms/schema_preview.rb

@@ -0,0 +1,135 @@
+# -*- encoding : utf-8 -*-
+
+module InlineForms
+  # Cheap preview of a SchemaIntent, WITHOUT running a migration or booting a
+  # second app. The trick (see the staging doc): declare the proposed attribute
+  # as a *virtual* typed attribute on a throwaway subclass of the target model,
+  # so it reads/writes in memory with no column, and render the stock inline
+  # forms against an AttributeList that has the proposed row spliced in at the
+  # requested position. The real class and its table are untouched.
+  #
+  #   obj, list = InlineForms::SchemaPreview.build(intent, existing_record)
+  #   # render "inline_forms/show" with @object = obj,
+  #   #   @inline_forms_attribute_list = list  (the controller already supports
+  #   #   this per-request override — see attr_writer :inline_forms_attribute_list)
+  #
+  # Scope of the stab: scalar attributes preview fully. Relation dropdowns
+  # (backed by a foreign key + association) and uploader/rich_text fields need
+  # model-side wiring the preview does not synthesize; #supported? reports this
+  # so a caller can fall back to a "available after apply" placeholder.
+  module SchemaPreview
+    module_function
+
+    # Map an AR column type (from the engine's form-element maps) to an
+    # ActiveModel::Type symbol for a virtual attribute.
+    COLUMN_TYPE_TO_VIRTUAL = {
+      string: :string,
+      text: :string,
+      integer: :integer,
+      decimal: :decimal,
+      float: :float,
+      boolean: :boolean,
+      date: :date,
+      time: :time,
+      datetime: :datetime,
+      timestamp: :datetime
+    }.freeze
+
+    # Form elements the GUI must not offer as "add a scalar field":
+    #  * :header / :info are not real fields — :header is a display-only
+    #    separator (adding one via addto would create a pointless string
+    #    column), :info is read-only over an existing column.
+    #  * uploaders need a mounted CarrierWave uploader; :money_field a
+    #    monetize declaration; :devise_password_field a Devise model; :pdf_link
+    #    a route — a virtual attribute alone cannot faithfully preview them.
+    PREVIEW_UNSUPPORTED_FORM_ELEMENTS = %i[
+      header
+      info
+      image_field
+      audio_field
+      file_field
+      multi_image_field
+      simple_file_field
+      pdf_link
+      money_field
+      devise_password_field
+    ].freeze
+
+    # Returns [preview_object, attribute_list]. `base_record` seeds the preview
+    # object's existing attributes when given (so the rest of the form shows
+    # real data); otherwise a blank instance is used.
+    def build(intent, base_record = nil)
+      base_class = intent.model_class
+      list       = attribute_list_for(base_class, intent)
+      preview    = preview_class_for(base_class, intent)
+
+      object = base_record ? preview.new(base_record.attributes) : preview.new
+      object.inline_forms_attribute_list = list
+      [ object, list ]
+    end
+
+    # False when the intent's form element needs model-side wiring the preview
+    # cannot synthesize (relations, uploaders, rich_text).
+    def supported?(intent)
+      !virtual_type(intent.form_element).nil?
+    end
+
+    # The sorted list of form elements the GUI offers (those that preview via a
+    # virtual attribute): scalar text/number/date/boolean/choice elements.
+    def supported_form_elements
+      candidates = InlineForms::SPECIAL_COLUMN_TYPES.keys +
+                   InlineForms::DEFAULT_FORM_ELEMENTS.values
+      candidates.uniq.select { |fe| !virtual_type(fe).nil? }.sort
+    end
+
+    # The AttributeList the preview should render: the model's current list with
+    # the proposed row inserted at --after/--before (falling back to append).
+    def attribute_list_for(base_class, intent)
+      current = base_class.new.inline_forms_attribute_list
+      list    = InlineForms::AttributeList.wrap(current.map(&:dup))
+      opts    = { values: intent.values, disabled: intent.disabled }.compact
+
+      # Value-bearing choice elements need a values hash or their _edit/_show
+      # helper raises. Mirror the addto generator: inject a placeholder the user
+      # edits after apply (so preview and apply produce the same row).
+      if opts[:values].nil? && InlineForms::VALUE_BEARING_FORM_ELEMENTS.include?(intent.form_element)
+        opts[:values] = InlineForms::PLACEHOLDER_VALUES
+      end
+
+      if intent.after && list.include_attribute?(intent.after)
+        list.insert_after(intent.after, intent.attribute, intent.form_element, **opts)
+      elsif intent.before && list.include_attribute?(intent.before)
+        list.insert_before(intent.before, intent.attribute, intent.form_element, **opts)
+      else
+        list.field(intent.attribute, intent.form_element, **opts)
+      end
+      list
+    end
+
+    # A throwaway subclass with the proposed attribute declared virtual (when
+    # supported), masquerading as the base class so partials/routes resolve.
+    def preview_class_for(base_class, intent)
+      type = virtual_type(intent.form_element)
+      klass = Class.new(base_class)
+      klass.attribute(intent.attribute, type) if type
+
+      base_name       = base_class.name
+      base_model_name = base_class.model_name
+      klass.define_singleton_method(:name) { base_name }
+      klass.define_singleton_method(:model_name) { base_model_name }
+      klass
+    end
+
+    def virtual_type(form_element)
+      fe = form_element.to_sym
+      return nil if PREVIEW_UNSUPPORTED_FORM_ELEMENTS.include?(fe)
+
+      column_type =
+        InlineForms::SPECIAL_COLUMN_TYPES[fe] ||
+        (InlineForms::DEFAULT_FORM_ELEMENTS.value?(fe) ? :string : nil)
+      return nil if column_type.nil? || column_type == :no_migration || column_type == :belongs_to
+
+      COLUMN_TYPE_TO_VIRTUAL[column_type]
+    end
+  end
+end