dynaspan 0.1.4 → 1.0.0

data/app/assets/javascripts/dynaspan/dynaspan.js

@@ -0,0 +1,271 @@
+// Dynaspan: click-to-edit, in-place AJAX text editing for Rails.
+// https://github.com/danielpclark/dynaspan
+// MIT License. Copyright (c) 2014-2026 Daniel P. Clark
+//
+// Works with Sprockets (`//= require dynaspan/dynaspan`), Propshaft
+// (`javascript_include_tag "dynaspan/dynaspan"`) and importmap-rails
+// (`import "dynaspan"`). No jQuery, rails-ujs or Turbo required.
+(function (window, document) {
+  'use strict';
+
+  if (!window || !document || (window.Dynaspan && window.Dynaspan.version)) return;
+
+  var BLOCK_SELECTOR = '[data-dynaspan]';
+
+  function parts(uid) {
+    return {
+      block: document.getElementById('dyna_span_block' + uid),
+      container: document.getElementById('dyna_span_div' + uid),
+      field: document.getElementById('dyna_span_field_val_' + uid),
+      span: document.getElementById('dyna_span_span' + uid),
+      last: document.getElementById('last_dyna_span_val_' + uid)
+    };
+  }
+
+  function uidFor(element) {
+    var block = element && element.closest && element.closest(BLOCK_SELECTOR);
+    return block ? block.getAttribute('data-dynaspan') : null;
+  }
+
+  function dispatch(target, name, detail, cancelable) {
+    var event = new CustomEvent('dynaspan:' + name, { bubbles: true, cancelable: !!cancelable, detail: detail });
+    return target.dispatchEvent(event);
+  }
+
+  function fieldValue(field) {
+    if (field.multiple) {
+      return Array.prototype.map.call(field.selectedOptions, function (option) { return option.value; }).join(',');
+    }
+    return field.value;
+  }
+
+  function fieldText(field) {
+    if (field.tagName === 'SELECT') {
+      return Array.prototype.map.call(field.selectedOptions, function (option) { return option.text; }).join(', ');
+    }
+    return field.value;
+  }
+
+  function isTextInput(field) {
+    return field.tagName === 'TEXTAREA' || (field.tagName === 'INPUT' && /^(text|search|url|tel|email|password)?$/i.test(field.type));
+  }
+
+  // Resets the field to the last value that was saved.
+  function restore(uid) {
+    var p = parts(uid);
+    if (p.field && p.last && !p.field.multiple) p.field.value = p.last.value;
+  }
+
+  function show(uid) {
+    var p = parts(uid);
+    if (!p.block || !p.container || !p.field || !p.span) return;
+    if (!p.block.classList.contains('ds-dialog-open')) {
+      restore(uid);
+      p.span.setAttribute('data-ds-display', p.span.style.display);
+      p.span.style.display = 'none';
+      p.container.style.display = '';
+      p.block.classList.add('ds-dialog-open');
+      dispatch(p.block, 'open', { selector: '#' + p.block.id, value: fieldValue(p.field) });
+    }
+    p.field.focus();
+    if (isTextInput(p.field) && p.field.setSelectionRange) {
+      var end = p.field.value.length;
+      try { p.field.setSelectionRange(end, end); } catch (e) { /* not supported for this input type */ }
+    }
+  }
+
+  function hide(uid, options) {
+    options = options || {};
+    var p = parts(uid);
+    if (!p.block || !p.container || !p.field || !p.span) return;
+    if (!p.block.classList.contains('ds-dialog-open')) return;
+
+    if (options.cancel) restore(uid);
+
+    var value = fieldValue(p.field);
+    var text = fieldText(p.field);
+    var changed = !options.cancel && (!p.last || p.last.value !== value);
+
+    p.block.classList.remove('ds-dialog-open');
+    p.container.style.display = 'none';
+    p.span.style.display = p.span.getAttribute('data-ds-display') || '';
+
+    if (changed) {
+      p.span.textContent = text;
+      if (p.last) p.last.value = value;
+      p.block.classList.toggle('ds-content-present', text.length > 0);
+      save(p, text, value);
+    }
+
+    dispatch(p.block, 'close', { selector: '#' + p.block.id, value: value, changed: changed });
+  }
+
+  // Appends a parameter to a JavaScript call written as a string:
+  // "foo('a');" => "foo('a',param);"
+  function appendParameter(command, param) {
+    var withArgs = /\(([^)]+)\);?$/.exec(command);
+    var withoutArgs = /\(\);?$/.exec(command);
+    if (withArgs) return command.replace(withArgs[0], '(' + withArgs[1] + ',' + param + ');');
+    if (withoutArgs) return command.replace(withoutArgs[0], '(' + param + ');');
+    return command.replace(/;$/, '') + '(' + param + ');';
+  }
+
+  function runCallback(block, code, values) {
+    try {
+      if (values) {
+        new Function('__dynaspan_values__', appendParameter(code, '__dynaspan_values__')).call(block, values);
+      } else {
+        new Function(code).call(block);
+      }
+    } catch (error) {
+      if (window.console) window.console.error('Dynaspan callback failed:', error);
+    }
+  }
+
+  function csrfToken(form) {
+    var field = form.querySelector('input[name="authenticity_token"]');
+    if (field && field.value) return field.value;
+    var meta = document.querySelector('meta[name="csrf-token"]');
+    return meta ? meta.getAttribute('content') : null;
+  }
+
+  function cspNonce() {
+    var meta = document.querySelector('meta[name="csp-nonce"]');
+    return meta ? meta.getAttribute('content') : null;
+  }
+
+  // Handles `update.turbo_stream.erb` and `update.js.erb` style responses.
+  function handleResponse(response, body) {
+    var type = response.headers.get('Content-Type') || '';
+    if (/turbo-stream/.test(type) && window.Turbo && window.Turbo.renderStreamMessage) {
+      window.Turbo.renderStreamMessage(body);
+    } else if (/(java|ecma)script/.test(type) && body) {
+      var script = document.createElement('script');
+      var nonce = cspNonce();
+      if (nonce) script.setAttribute('nonce', nonce);
+      script.text = body;
+      document.head.appendChild(script).parentNode.removeChild(script);
+    }
+  }
+
+  function save(p, text, value) {
+    var block = p.block;
+    var form = p.container.querySelector('form');
+    var detail = { selector: '#' + block.id, input: text, value: value, form: form };
+
+    if (!form || !dispatch(block, 'update', detail, true)) return;
+
+    var headers = {
+      Accept: 'text/vnd.turbo-stream.html, text/javascript, application/javascript, application/json, text/html;q=0.9, */*;q=0.1',
+      'X-Requested-With': 'XMLHttpRequest'
+    };
+    var token = csrfToken(form);
+    if (token) headers['X-CSRF-Token'] = token;
+
+    block.classList.add('ds-saving');
+    block.classList.remove('ds-error');
+
+    window.fetch(form.action, { method: 'POST', body: new FormData(form), headers: headers, credentials: 'same-origin' })
+      .then(function (response) {
+        return response.text().then(function (body) {
+          if (!response.ok) {
+            var error = new Error('Dynaspan update failed with HTTP status ' + response.status);
+            error.response = response;
+            throw error;
+          }
+          handleResponse(response, body);
+          detail.response = response;
+          dispatch(block, 'success', detail);
+        });
+      })
+      .catch(function (error) {
+        block.classList.add('ds-error');
+        detail.error = error;
+        detail.response = error.response;
+        dispatch(block, 'error', detail);
+      })
+      .then(function () {
+        block.classList.remove('ds-saving');
+      });
+
+    var withValues = block.getAttribute('data-ds-callback-with-values');
+    if (withValues) runCallback(block, withValues, { ds_selector: '#' + block.id, ds_input: text });
+    var onUpdate = block.getAttribute('data-ds-callback-on-update');
+    if (onUpdate) runCallback(block, onUpdate);
+  }
+
+  function isTrigger(element) {
+    return element.closest('.dyna-span-text, .dyna-span-edit-text');
+  }
+
+  function isInput(element) {
+    return element.classList && element.classList.contains('dyna-span-input');
+  }
+
+  document.addEventListener('click', function (event) {
+    var uid = uidFor(event.target);
+    if (uid && isTrigger(event.target)) show(uid);
+  });
+
+  document.addEventListener('focusout', function (event) {
+    var uid = uidFor(event.target);
+    if (uid && isInput(event.target)) hide(uid);
+  });
+
+  document.addEventListener('keydown', function (event) {
+    var target = event.target;
+    var uid = uidFor(target);
+    if (!uid) return;
+
+    if (target.classList.contains('dyna-span-text')) {
+      if (event.key === 'Enter' || event.key === ' ') {
+        event.preventDefault();
+        show(uid);
+      }
+      return;
+    }
+
+    if (!isInput(target)) return;
+
+    var textarea = target.tagName === 'TEXTAREA';
+    var submitKey = event.key === 'Enter' && (!textarea || event.ctrlKey || event.metaKey);
+    if (event.key === 'Escape' || (submitKey && target.tagName !== 'SELECT')) {
+      event.preventDefault();
+      hide(uid, { cancel: event.key === 'Escape' });
+      var span = parts(uid).span;
+      if (span) span.focus();
+    }
+  });
+
+  // Never let the browser, rails-ujs or Turbo submit a Dynaspan form.
+  document.addEventListener('submit', function (event) {
+    var uid = uidFor(event.target);
+    if (!uid) return;
+    event.preventDefault();
+    event.stopPropagation();
+    hide(uid);
+  }, true);
+
+  var Dynaspan = {
+    version: '1.0.0',
+    show: show,
+    hide: function (uid) { hide(uid); },
+    cancel: function (uid) { hide(uid, { cancel: true }); },
+    appendParameter: appendParameter
+  };
+  window.Dynaspan = Dynaspan;
+
+  // Backwards compatibility with the jQuery API of Dynaspan 0.x:
+  // $().dynaspan.upShow(id), $().dynaspan.upHide(id), $().dynaspan.upLast(id)
+  function installJQueryApi() {
+    var $ = window.jQuery;
+    if (!$ || !$.fn || $.fn.dynaspan) return;
+    $.fn.dynaspan = function () { return this; };
+    $.fn.dynaspan.upShow = show;
+    $.fn.dynaspan.upHide = Dynaspan.hide;
+    $.fn.dynaspan.upLast = restore;
+    $.fn.dynaspan.appendParameter = appendParameter;
+  }
+  installJQueryApi();
+  document.addEventListener('DOMContentLoaded', installJQueryApi);
+})(typeof window !== 'undefined' ? window : undefined, typeof document !== 'undefined' ? document : undefined);

data/app/assets/stylesheets/dynaspan/dynaspan.css

@@ -0,0 +1,44 @@
+/*
+ * Dynaspan default styles (optional).
+ * Load with stylesheet_link_tag "dynaspan/dynaspan", require it from your
+ * Sprockets manifest, or write your own.
+ */
+.dyna-span .dyna-span-text {
+  cursor: text;
+  min-height: 1.5em;
+  border-radius: 4px;
+  outline-offset: 2px;
+  transition: background-color 0.15s ease-in-out;
+}
+
+.dyna-span .dyna-span-text:hover,
+.dyna-span .dyna-span-text:focus-visible {
+  background-color: rgba(59, 130, 246, 0.08);
+  box-shadow: inset 0 -1px 0 rgba(59, 130, 246, 0.6);
+}
+
+.dyna-span[data-dynaspan-kind="text_area"] .dyna-span-text {
+  white-space: pre-wrap;
+}
+
+.dyna-span .dyna-span-input {
+  box-sizing: border-box;
+  width: 100%;
+  font: inherit;
+}
+
+.dyna-span .dyna-span-edit-text {
+  cursor: pointer;
+}
+
+.dyna-span.ds-dialog-open > .dyna-span-edit-text {
+  display: none;
+}
+
+.dyna-span.ds-saving .dyna-span-text {
+  opacity: 0.6;
+}
+
+.dyna-span.ds-error .dyna-span-text {
+  box-shadow: inset 0 -2px 0 #dc2626;
+}

data/app/helpers/dynaspan/application_helper.rb

@@ -1,67 +1,180 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
 module Dynaspan
+  # View helpers that render a piece of text which turns into a form field
+  # when clicked and saves itself over AJAX when the field loses focus.
+  #
+  # Every helper takes the same arguments:
+  #
+  #   dynaspan_text_field(record, :attribute)
+  #   dynaspan_text_field(record, :attribute, '[edit]', options)
+  #   dynaspan_text_field(record, nested_record, :attribute, '[edit]', options)
+  #
+  # See the README for the full list of options.
   module ApplicationHelper
+    RESERVED_HTML_OPTIONS = %w[id onblur onfocus].freeze
+    INPUT_CLASSES = 'dyna-span form-control dyna-span-input'
 
-    def dynaspan_text_field(master_ds_object,*parameters)
-      dynaspan_text('field', master_ds_object, parameters)
+    def dynaspan_text_field(master_ds_object, *parameters)
+      dynaspan_render(:text_field, master_ds_object, parameters)
     end
 
-    def dynaspan_text_area(master_ds_object,*parameters)
-      dynaspan_text('area', master_ds_object, parameters)
+    def dynaspan_text_area(master_ds_object, *parameters)
+      dynaspan_render(:text_area, master_ds_object, parameters)
     end
 
-    def dynaspan_select(master_ds_object,*parameters, &block)
-      dynaspan_text('select', master_ds_object, parameters, &block)
+    def dynaspan_select(master_ds_object, *parameters, &block)
+      dynaspan_render(:select, master_ds_object, parameters, &block)
     end
 
     private
-    module_function
 
-    def to_id(obj)
-      !!obj ? "#{obj.class.name}#{obj.try(:id)}" : ""
+    def dynaspan_render(kind, master_ds_object, parameters, &block)
+      raise ArgumentError, 'Dynaspan needs a record to update as its first argument.' if master_ds_object.nil?
+
+      parameters = parameters.dup
+      options = parameters.last.is_a?(Hash) ? parameters.pop.with_indifferent_access : ActiveSupport::HashWithIndifferentAccess.new
+      attr_object, attrib, edit_text = dynaspan_parse_arguments(parameters)
+
+      association = dynaspan_nested_association(master_ds_object, attr_object)
+      target = attr_object || master_ds_object
+      value = target.public_send(attrib)
+      unique_ref_id = options.fetch(:unique_id) { dynaspan_unique_id(master_ds_object, attr_object, attrib) }.to_s
+      choices = options[:choices]
+
+      render(
+        partial: 'dynaspan/dynaspan',
+        locals: {
+          kind: kind,
+          master_ds_object: master_ds_object,
+          attr_object: attr_object,
+          association: association,
+          attrib: attrib,
+          value: value,
+          display_text: kind == :select ? dynaspan_choice_text(choices, value) || value : value,
+          unique_ref_id: unique_ref_id,
+          dyna_span_edit_text: edit_text,
+          hidden_fields: options[:hidden_fields] || {},
+          ds_callback_on_update: options[:callback_on_update],
+          ds_callback_with_values: options[:callback_with_values],
+          form_for_options: dynaspan_form_options(options[:form_for]),
+          choices: choices,
+          select_options: (options[:options] || {}).to_h.symbolize_keys,
+          html_options: dynaspan_html_options(options[:html_options], kind, unique_ref_id),
+          block: block
+        }
+      )
     end
 
-    def dynaspan_text(kind, master_ds_object,*parameters, &block)
-      parameters.flatten!
-      if parameters.first.is_a? Symbol
+    # Accepts (attribute, edit_text?) or (nested_record, attribute, edit_text?).
+    def dynaspan_parse_arguments(parameters)
+      if parameters.first.is_a?(Symbol)
         attr_object = nil
-        attrib = parameters.first
-        edit_text = parameters.try(:[],1)
-      elsif parameters[1].is_a? Symbol
-        attr_object, attrib = parameters
-        edit_text = parameters.try(:[],2)
+        attrib, edit_text = parameters
+      elsif parameters[1].is_a?(Symbol)
+        attr_object, attrib, edit_text = parameters
       else
-        raise 'You did not provide a symbol for the form field.'
+        raise ArgumentError, 'Dynaspan needs a Symbol naming the attribute to edit, e.g. dynaspan_text_field(user, :name).'
       end
-      edit_text = nil unless edit_text.is_a? String
-      options = ActiveSupport::HashWithIndifferentAccess.new(parameters[-1].is_a?(Hash) ? parameters[-1] : {})
-      options.default = nil
-      options[:form_for] = ActiveSupport::HashWithIndifferentAccess.new(options[:form_for])
-      options[:form_for].reverse_merge!(
-        method: :patch,
-        remote: true,
-        authenticity_token: true
-      )
-      options[:html_options] = ActiveSupport::HashWithIndifferentAccess.new(options[:html_options])
-      options[:html_options][:class] = "dyna-span form-control dyna-span-input #{options[:html_options][:class]}"
-      options[:html_options].delete_if {|k,v| [:id, :onblur, :onfocus].include? k}
-      render(
-          partial: "dynaspan/dynaspan_text_#{kind}",
-          locals: {
-            master_ds_object: master_ds_object,
-            attr_object: attr_object,
-            attrib: attrib,
-            unique_ref_id: options.fetch(:unique_id) { [to_id(master_ds_object), to_id(attr_object), attrib, SecureRandom.hex(3)].join },
-            dyna_span_edit_text: edit_text,
-            hidden_fields: options[:hidden_fields],
-            ds_callback_on_update: options[:callback_on_update],
-            ds_callback_with_values: options[:callback_with_values],
-            form_for_options: options[:form_for],
-            choices: options[:choices],                    # For form 'select' field
-            options: options.fetch(:options) { Hash.new }, # For form 'select' field
-            html_options: options[:html_options],
-            block: block
-          }
-      )
+
+      [attr_object, attrib, edit_text.is_a?(String) ? edit_text : nil]
+    end
+
+    # Finds the `accepts_nested_attributes_for` association on the master
+    # record that the nested record belongs to.
+    def dynaspan_nested_association(master_ds_object, attr_object)
+      return if attr_object.nil?
+
+      klass = master_ds_object.class
+      names = klass.respond_to?(:nested_attributes_options) ? klass.nested_attributes_options.keys.map(&:to_s) : []
+
+      name = names.find do |association_name|
+        reflection = klass.try(:reflect_on_association, association_name)
+        reflection && !reflection.polymorphic? && attr_object.is_a?(reflection.klass)
+      end
+
+      name ||= begin
+        model_name = attr_object.class.model_name
+        candidates = [model_name.singular, model_name.plural, model_name.element, attr_object.class.try(:table_name)].compact
+        names.find { |association_name| candidates.any? { |candidate| association_name.include?(candidate) } }
+      end
+
+      unless name
+        raise ArgumentError,
+              "Dynaspan could not find a nested association for #{attr_object.class.name} on #{klass.name}. " \
+              "Add `accepts_nested_attributes_for` for it to #{klass.name}."
+      end
+
+      reflection = klass.try(:reflect_on_association, name)
+      { name: name.to_sym, collection: reflection.respond_to?(:collection?) && reflection.collection? }
+    end
+
+    def dynaspan_unique_id(master_ds_object, attr_object, attrib)
+      [dynaspan_record_id(master_ds_object), dynaspan_record_id(attr_object), attrib, SecureRandom.hex(3)]
+        .join.gsub(/[^A-Za-z0-9_-]/, '_')
+    end
+
+    def dynaspan_record_id(record)
+      record ? "#{record.class.name}#{record.try(:id)}" : ''
+    end
+
+    def dynaspan_form_options(custom)
+      { method: :patch, authenticity_token: true }
+        .merge((custom || {}).to_h.symbolize_keys)
+        .tap do |form_options|
+          form_options[:html] = (form_options[:html] || {}).to_h.symbolize_keys
+          form_options[:html][:data] = { turbo: false }.merge((form_options[:html][:data] || {}).to_h.symbolize_keys)
+        end
+    end
+
+    def dynaspan_html_options(custom, kind, unique_ref_id)
+      html_options = (custom || {}).to_h.stringify_keys.except(*RESERVED_HTML_OPTIONS)
+      html_options['class'] = [INPUT_CLASSES, html_options['class']].compact.join(' ').strip
+      html_options['id'] = "dyna_span_field_val_#{unique_ref_id}"
+      html_options['data'] = (html_options['data'] || {}).to_h.merge('dynaspan-input' => kind)
+      html_options.symbolize_keys
+    end
+
+    def dynaspan_input(builder, kind, attrib, locals)
+      case kind
+      when :text_field then builder.text_field(attrib, locals[:html_options])
+      when :text_area then builder.text_area(attrib, locals[:html_options])
+      when :select
+        builder.select(attrib, locals[:choices], locals[:select_options], locals[:html_options], &locals[:block])
+      end
+    end
+
+    # Looks up the label shown for `value` among select choices. Supports the
+    # formats Rails' `select` accepts: arrays, hashes, grouped choices and
+    # pre-rendered option tags (e.g. from `options_for_select`).
+    def dynaspan_choice_text(choices, value)
+      return if choices.blank?
+
+      target = value.to_s
+      if choices.is_a?(String)
+        require 'nokogiri'
+        option = Nokogiri::HTML::DocumentFragment.parse(choices).css('option').find do |node|
+          (node['value'] || node.text) == target
+        end
+        return option&.text
+      end
+
+      choices = choices.to_a if choices.is_a?(Hash)
+      choices.each do |element|
+        parts = element.is_a?(Array) ? element.reject { |part| part.is_a?(Hash) } : [element, element]
+        label = parts.first
+        option_value = parts.last
+
+        if option_value.is_a?(Array) || option_value.is_a?(Hash)
+          found = dynaspan_choice_text(option_value, value)
+          return found if found
+        elsif option_value.to_s == target
+          return label.to_s
+        end
+      end
+      nil
     end
   end
 end

data/app/views/dynaspan/_dynaspan.html.erb

@@ -0,0 +1,32 @@
+<%# Rendered by dynaspan_text_field, dynaspan_text_area and dynaspan_select. %>
+<%= tag.div id: "dyna_span_block#{unique_ref_id}",
+            class: ['dyna-span', ('ds-content-present' if value.present?)],
+            data: {
+              dynaspan: unique_ref_id,
+              dynaspan_kind: kind,
+              ds_callback_on_update: ds_callback_on_update.presence,
+              ds_callback_with_values: ds_callback_with_values.presence
+            } do %>
+  <%= tag.input type: 'hidden', id: "last_dyna_span_val_#{unique_ref_id}", value: value, autocomplete: 'off' %>
+  <%= tag.div id: "dyna_span_div#{unique_ref_id}", class: 'dyna-span-form', style: 'display:none;' do %>
+    <%= form_for(master_ds_object, **form_for_options) do |f| %>
+      <% if association %>
+        <%= f.fields_for association[:name], (association[:collection] ? [attr_object] : attr_object) do |nested| %>
+          <%= dynaspan_input(nested, kind, attrib, local_assigns) %>
+          <% hidden_fields.each do |name, hidden_value| %>
+            <%= nested.hidden_field name, value: hidden_value %>
+          <% end %>
+        <% end %>
+      <% else %>
+        <%= dynaspan_input(f, kind, attrib, local_assigns) %>
+        <% hidden_fields.each do |name, hidden_value| %>
+          <%= f.hidden_field name, value: hidden_value %>
+        <% end %>
+      <% end %>
+    <% end %>
+  <% end %>
+  <%= tag.span display_text, id: "dyna_span_span#{unique_ref_id}", class: 'dyna-span dyna-span-text', style: 'display:block;', tabindex: 0 %>
+  <% if dyna_span_edit_text %>
+    <%= tag.div dyna_span_edit_text, class: 'dyna-span-edit-text pull-right', style: 'cursor:pointer;' %>
+  <% end %>
+<% end %>

data/config/importmap.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+pin 'dynaspan', to: 'dynaspan/dynaspan.js'

data/lib/dynaspan/engine.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require 'rails'
+
+module Dynaspan
+  class Engine < ::Rails::Engine
+    isolate_namespace Dynaspan
+
+    ASSETS = %w[dynaspan/dynaspan.js dynaspan/dynaspan.css].freeze
+
+    # Make the view helpers available in every view of the host application.
+    initializer 'dynaspan.helpers' do
+      ActiveSupport.on_load(:action_view) do
+        include Dynaspan::ApplicationHelper
+      end
+    end
+
+    # Sprockets needs to be told about stand-alone assets. Propshaft serves
+    # everything in the engine's app/assets directories automatically.
+    initializer 'dynaspan.assets' do |app|
+      if app.config.respond_to?(:assets)
+        precompile = app.config.assets.precompile
+        precompile.concat(ASSETS) if precompile.respond_to?(:concat)
+      end
+    end
+
+    # With importmap-rails, `import "dynaspan"` works without any extra pins.
+    initializer 'dynaspan.importmap', before: 'importmap' do |app|
+      app.config.importmap.paths << root.join('config/importmap.rb') if app.config.respond_to?(:importmap)
+    end
+  end
+end

data/lib/dynaspan/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Dynaspan
-  VERSION = '0.1.4'
+  VERSION = '1.0.0'
 end

data/lib/dynaspan.rb

@@ -1,32 +1,8 @@
-require 'dynaspan/version'
+# frozen_string_literal: true
 
+require 'dynaspan/version'
+require 'dynaspan/engine'
 
+# Click-to-edit, in-place AJAX text editing for Rails.
 module Dynaspan
-  ASSETS = %W(dynaspan/*.js dynaspan/*.css dynaspan/*.png dynaspan/*.gif dynaspan/*.html dynaspan/*.md)
-  INITIALIZER = "initializer 'dynaspan.assets.precompile', group: :all do |app| app.config.assets.precompile += Dynaspan::ASSETS; end"
-
-  class Engine < ::Rails::Engine
-    isolate_namespace Dynaspan
-
-    eval Dynaspan::INITIALIZER
-
-    initializer 'dynaspan.action_controller' do |app|
-      ActiveSupport.on_load :action_controller do
-        helper Dynaspan::ApplicationHelper
-      end
-    end
-
-    if ::Rails.version.to_s =~ /^4/
-      rake_tasks do
-        load "dynaspan/tasks.rake"
-      end
-    end
-  end
-
-  if ::Rails.version.to_s =~ /^3\.[0]/
-    class Railtie < ::Rails::Railtie
-      eval Dynaspan::INITIALIZER
-    end
-  end
 end
-