compony 0.7.0 → 0.8.0

data/lib/compony/view_helpers.rb

@@ -4,55 +4,12 @@ module Compony
   # Rule of thumb: this holds methods that require a view context and results are rendered immediately.
   # @see Compony Compony for standalone/pure helpers
   module ViewHelpers
-    # Use this in your application layout to render all actions of the current root component.
-    def compony_actions
-      return nil unless Compony.root_comp
-      Compony.root_comp.render_actions(self, wrapper_class: 'root-actions', action_class: 'root-action')
-    end
-
-    # Renders a link to a component given a comp and model or family. If authentication is configured
+    # Renders a button/link to a component given a comp and model or family. If authentication is configured
     # and the current user has insufficient permissions to access the target object, the link is not displayed.
-    # @param comp_name_or_cst [String,Symbol] The component that should be loaded, for instance `ShowForAll`, `'ShowForAll'` or `:show_for_all`
-    # @param model_or_family_name_or_cst [String,Symbol,ApplicationRecord] Either the family that contains the requested component,
-    #                                    or an instance implementing `model_name` from which the family name is auto-generated. Examples:
-    #                                    `Users`, `'Users'`, `:users`, `User.first`
-    # @param link_args [Array] Positional arguments that will be passed to the Rails `link_to` helper
-    # @param label_opts [Hash] Options hash that will be passed to the label method (see {Compony::ComponentMixins::Default::Labelling#label})
-    # @param link_kwargs [Hash] Named arguments that will be passed to the Rails `link_to` helper
-    def compony_link(comp_name_or_cst_or_class,
-                     model_or_family_name_or_cst = nil,
-                     *link_args,
-                     label: nil,
-                     label_opts: {},
-                     params: {},
-                     feasibility_action: nil,
-                     feasibility_target: nil,
-                     standalone_name: nil,
-                     **link_kwargs)
-      model = model_or_family_name_or_cst.respond_to?(:model_name) ? model_or_family_name_or_cst : nil
-      if comp_name_or_cst_or_class.is_a?(Class) && (comp_name_or_cst_or_class <= Compony::Component)
-        target_comp_instance = comp_name_or_cst_or_class.new(data: model)
-      else
-        target_comp_instance = Compony.comp_class_for!(comp_name_or_cst_or_class, model_or_family_name_or_cst).new(data: model)
-      end
-      return unless target_comp_instance.standalone_access_permitted_for?(self, standalone_name:)
-      feasibility_action ||= comp_name_or_cst_or_class.to_s.underscore.to_sym
-      feasibility_target ||= model
-      label ||= target_comp_instance.label(model, **label_opts)
-      path ||= Compony.path(target_comp_instance.comp_name, target_comp_instance.family_name, model, standalone_name:, **params)
-      if feasibility_target && !feasibility_target.feasible?(feasibility_action)
-        path = '#'
-        link_kwargs[:class] = link_kwargs[:class].is_a?(String) ? "#{link_kwargs[:class]} disabled" : 'disabled'
-        link_kwargs[:title] = feasibility_target.full_feasibility_messages(feasibility_action).presence
-      end
-      return helpers.link_to(label, path, *link_args, **link_kwargs)
-    end
-
-    # Given a component and a family/model, this instanciates and renders a button component.
-    # @see Compony#button Check Compony.button for accepted params
-    # @see Compony::Components::Button Compony::Components::Button: the default underlying implementation
-    def compony_button(...)
-      Compony.button(...).render(helpers.controller)
+    # When inside a request context (`content do...`), this is preceded by {RequestContext#render_intent}.
+    # @param button [Hash] Parameters that will be given to the button component initializer.
+    def render_intent(*, button: {}, **)
+      Compony.intent(*, **).render(self, **button)
     end
   end
 end

data/lib/compony/virtual_model.rb

@@ -0,0 +1,10 @@
+module Compony
+  class VirtualModel < ActiveType::Object
+    # Use this as a base class whenever you would be inheriting from ActiveType::Object
+    # Note: this class is only available in applications that have `active_type` in their Gemfile
+
+    include Compony::ModelMixin
+    include Anchormodel::ModelMixin
+    include ActiveModel::Attributes
+  end
+end

data/lib/compony.rb

@@ -3,17 +3,25 @@
 # the setters, create an initializer `config/initializers/compony.rb` and call
 # them from there.
 # @see Compony::ViewHelpers Compony::ViewHelpers for helpers that require a view context and render results immediately
+# @see Compony::RequestContext Compony::RequestContext for helpers that require a view context and render results immediately
 module Compony
   ##########=====-------
   # Configuration writers
   ##########=====-------
 
-  # Setter for the global button component class. This allows you to implement a
-  # custom button component and have all Compony button helpers use your custom
-  # button component instead of {Compony::Components::Button}.
-  # @param button_component_class [String] Name of your custom button component class (inherit from {Compony::Components::Button} or {Compony::Component})
-  def self.button_component_class=(button_component_class)
-    @button_component_class = button_component_class
+  # Adds a button style that can be referred to when rendering an intent.
+  # @param name [Symbol] Name of the style. If it exists already, will override the style.
+  # @param button_component_class [String] String with the class name of the button component that will be instanciated to render the intent.
+  def self.register_button_style(name, button_component_class_name)
+    @button_component_class_names ||= {}
+    @button_component_class_names[name.to_sym] = button_component_class_name
+  end
+
+  # Setter for the default button style. Defaults to :css_button.
+  # @param default_button_style [Symbol] Name of the style that should be used as default.
+  # @see {Compony#default_button_style}
+  def self.default_button_style=(default_button_style)
+    @default_button_style = default_button_style
   end
 
   # Setter for the global field namespaces. This allows you to implement custom
@@ -58,12 +66,31 @@ module Compony
   # Configuration readers
   ##########=====-------
 
-  # Getter for the global button component class.
-  # @see Compony#button_component_class= Explanation of button_component_class (documented in the corresponding setter)
-  def self.button_component_class
-    @button_component_class ||= Components::Button
-    @button_component_class = const_get(@button_component_class) if @button_component_class.is_a?(String)
-    return @button_component_class
+  # Getter for the button component class for a given style.
+  # @param style [Symbol] Style for which the matching button component class should be returned. Defaults to {Compony.default_button_style}.
+  # @see {Compony#register_button_style}
+  # @see {Compony#default_button_style}
+  def self.button_component_class(style = default_button_style)
+    # Lazy initialize
+    if @button_component_classes.nil?
+      @button_component_classes = {
+        css_button: Compony::Components::Buttons::CssButton,
+        link:       Compony::Components::Buttons::Link
+      }.merge(@button_component_class_names&.transform_values(&:constantize) || {})
+      @button_component_classes.each_value do |button_component_class|
+        unless button_component_class.is_a?(Class) && button_component_class < Compony::Component
+          fail("Expected a button component class, got #{button_component_class.inspect}")
+        end
+      end
+    end
+    # Retrieval
+    return @button_component_classes[style&.to_sym] || fail("Unknown button style #{style.inspect}. Use one of: #{@button_component_classes.keys.inspect}")
+  end
+
+  # Getter for the default button style, defaults to `:css_button`.
+  # @see {Compony#default_button_style=}
+  def self.default_button_style
+    return @default_button_style || :css_button
   end
 
   # Getter for the global field namespaces.
@@ -94,123 +121,38 @@ module Compony
   # Application-wide available pure helpers
   ##########=====-------
 
+  # Pure helper to create a Compony Intent. If given an intent, will return it unchanged. Otherwise, will give all params to the intent initializer.
+  def self.intent(intent_or_comp_args, ...)
+    if intent_or_comp_args.is_a?(Intent)
+      return intent_or_comp_args
+    else
+      return Intent.new(intent_or_comp_args, ...)
+    end
+  end
+
   # Generates a Rails path to a component. Examples: `Compony.path(:index, :users)`, `Compony.path(:show, User.first)`
-  # @param comp_name_or_cst_or_class [String,Symbol] The component that should be loaded, for instance `ShowForAll`, `'ShowForAll'` or `:show_for_all`
-  #                         or can also pass a component class (such as Components::Users::Show)
-  # @param model_or_family_name_or_cst [String,Symbol,ApplicationRecord] Either the family that contains the requested component,
-  #                                    or an instance implementing `model_name` from which the family name is auto-generated. Examples:
-  #                                    `Users`, `'Users'`, `:users`, `User.first`
-  # @param standalone_name [Symbol,nil] Name of the standalone config to point to (defaults to nil the default standalone config).
-  # @param args_for_path_helper [Array] Positional arguments passed to the Rails helper
-  # @param kwargs_for_path_helper [Hash] Named arguments passed to the Rails helper. If a model is given to `model_or_family_name_or_cst`,
-  #                                      the param `id` defaults to the passed model's ID.
-  def self.path(comp_name_or_cst_or_class, model_or_family_name_or_cst = nil, *args_for_path_helper, standalone_name: nil, **kwargs_for_path_helper)
-    # Extract model if any, to get the ID
-    model = model_or_family_name_or_cst.respond_to?(:model_name) ? model_or_family_name_or_cst : nil
-    comp_class = if comp_name_or_cst_or_class.is_a?(Class) && (comp_name_or_cst_or_class <= Compony::Component)
-                   comp_name_or_cst_or_class
-                 else
-                   comp_class_for!(comp_name_or_cst_or_class, model_or_family_name_or_cst)
-                 end
-    return comp_class.new.path(model, *args_for_path_helper, standalone_name:, **kwargs_for_path_helper)
+  # The first two arguments are given to create an {Intent} and all subsequend args and all kwargs are given to {Intent#path}
+  def self.path(comp_name_or_cst_or_class, model_or_family_name_or_cst = nil, ...)
+    intent(comp_name_or_cst_or_class, model_or_family_name_or_cst).path(...)
   end
 
   # Given a component and a family/model, this returns the matching component class if any, or nil if the component does not exist.
-  # @param comp_name_or_cst [String,Symbol] The component that should be loaded, for instance `ShowForAll`, `'ShowForAll'` or `:show_for_all`
-  # @param model_or_family_name_or_cst [String,Symbol,ApplicationRecord] Either the family that contains the requested component,
-  #                                    or an instance implementing `model_name` from which the family name is auto-generated. Examples:
-  #                                    `Users`, `'Users'`, `:users`, `User.first`
-  def self.comp_class_for(comp_name_or_cst, model_or_family_name_or_cst)
-    family_cst_str = family_name_for(model_or_family_name_or_cst).camelize
-    comp_cst_str = comp_name_or_cst.to_s.camelize
-    return nil unless ::Components.const_defined?(family_cst_str)
-    family_constant = ::Components.const_get(family_cst_str)
-    return nil unless family_constant.const_defined?(comp_cst_str)
-    return family_constant.const_get(comp_cst_str)
+  # @see Intent for allowed parameters.
+  def self.comp_class_for(...)
+    return intent(...).comp_class
+  rescue NameError
+    return nil
   end
 
   # Same as Compony#comp_class_for but fails if none found
+  # @see Intent for allowed parameters.
   # @see Compony#comp_class_for
-  def self.comp_class_for!(comp_name_or_cst, model_or_family_name_or_cst)
-    comp_class_for(comp_name_or_cst, model_or_family_name_or_cst) || fail(
+  def self.comp_class_for!(...)
+    comp_class_for(...) || fail(
       "No component found for [#{comp_name_or_cst.inspect}, #{model_or_family_name_or_cst.inspect}]"
     )
   end
 
-  # Given a component and a family, this returns the name of the Rails URL helper returning the path to this component.<br>
-  # The parameters are the same as for {Compony#rails_action_name}.<br>
-  # Example usage: `send("#{path_helper_name(:index, :users)}_url)`
-  # @see Compony#path
-  # @see Compony#rails_action_name rails_action_name for the accepted params
-  def self.path_helper_name(...)
-    "#{rails_action_name(...)}_comp"
-  end
-
-  # Given a component and a family or a component class, this returns the name of the ComponyController action for this component.<br>
-  # Optionally can pass a name for extra standalone configs.
-  # @param comp_name_or_cst [String,Symbol] Name of the component the action points to.
-  # @param model_or_family_name_or_cst [String,Symbol] Name of the family the action points to.
-  # @param name [String,Symbol] If referring to an extra standalone entrypoint, specify its name using this param.
-  # @see Compony#path
-  def self.rails_action_name(comp_name_or_cst_or_class, model_or_family_name_or_cst, name = nil)
-    if comp_name_or_cst_or_class.is_a?(Class) && (comp_name_or_cst_or_class <= Compony::Component)
-      comp_class = comp_name_or_cst_or_class
-      comp_name_or_cst_or_class = comp_class.comp_name
-      model_or_family_name_or_cst = comp_class.family_name
-    end
-    [name.presence, comp_name_or_cst_or_class.to_s.underscore, family_name_for(model_or_family_name_or_cst)].compact.join('_')
-  end
-
-  # Given a component and a family/model, this instanciates and returns a button component.
-  # @param comp_name_or_cst_or_class [String,Symbol,Class] The component that should be loaded, for instance `ShowForAll`, `'ShowForAll'` or `:show_for_all`
-  # @param model_or_family_name_or_cst [String,Symbol,ApplicationRecord] Either the family that contains the requested component,
-  #                                    or an instance implementing `model_name` from which the family name is auto-generated. Examples:
-  #                                    `Users`, `'Users'`, `:users`, `User.first`
-  # @param label_opts [Hash] Options hash that will be passed to the label method (see {Compony::ComponentMixins::Default::Labelling#label})
-  # @param params [Hash] GET parameters to be inclued into the path this button points to. Special case: e.g. format: :pdf -> some.url/foo/bar.pdf
-  # @param feasibility_action [Symbol] Name of the feasibility action that should be checked for this button, defaults to the component name
-  # @param feasibility_target [Symbol] Name of the feasibility target (subject) that the feasibility should be checked on, defaults to the model if given
-  # @param standalone_name [Symbol,nil] Name of the standalone config to point to (defaults to nil the default standalone config).
-  # @param override_kwargs [Hash] Override button options, see options for {Compony::Components::Button}
-  # @see Compony::ViewHelpers#compony_button View helper providing a wrapper for this method that immediately renders a button.
-  # @see Compony::Components::Button Compony::Components::Button: the default underlying implementation
-  def self.button(comp_name_or_cst_or_class,
-                  model_or_family_name_or_cst = nil,
-                  label_opts: nil,
-                  params: nil,
-                  feasibility_action: nil,
-                  feasibility_target: nil,
-                  method: nil,
-                  standalone_name: nil,
-                  **override_kwargs)
-    label_opts ||= button_defaults[:label_opts] || {}
-    params ||= button_defaults[:params] || {}
-    model = model_or_family_name_or_cst.respond_to?(:model_name) ? model_or_family_name_or_cst : nil
-    if comp_name_or_cst_or_class.is_a?(Class) && (comp_name_or_cst_or_class <= Compony::Component)
-      target_comp_instance = comp_name_or_cst_or_class.new(data: model)
-    else
-      target_comp_instance = Compony.comp_class_for!(comp_name_or_cst_or_class, model_or_family_name_or_cst).new(data: model)
-    end
-    feasibility_action ||= button_defaults[:feasibility_action] || comp_name_or_cst_or_class.to_s.underscore.to_sym
-    feasibility_target ||= button_defaults[:feasibility_target] || model
-    options = {
-      label:   target_comp_instance.label(model, **label_opts),
-      icon:    target_comp_instance.icon,
-      color:   target_comp_instance.color,
-      path:    Compony.path(target_comp_instance.comp_name, target_comp_instance.family_name, model, standalone_name:, **params),
-      method:,
-      visible: ->(controller) { target_comp_instance.standalone_access_permitted_for?(controller, standalone_name:, verb: method) }
-    }
-    if feasibility_target
-      options.merge!({
-                       enabled: feasibility_target.feasible?(feasibility_action),
-                       title:   feasibility_target.full_feasibility_messages(feasibility_action).presence
-                     })
-    end
-    options.merge!(override_kwargs.symbolize_keys)
-    return Compony.button_component_class.new(**options.symbolize_keys)
-  end
-
   # Returns the current root component, if any
   def self.root_comp
     RequestStore.store[:compony_root_comp]
@@ -228,37 +170,6 @@ module Compony
     end
   end
 
-  # Getter for current button defaults
-  # @todo document params
-  def self.button_defaults
-    RequestStore.store[:button_defaults] || {}
-  end
-
-  # Overwrites the keys of the current button defaults by the ones provided during the execution of a given block and restores them afterwords.
-  # This method is useful when the same set of options is to be given to a multitude of buttons.
-  # @param keys_to_overwrite [Hash] Options that should be given to the buttons within the block, with their values
-  # @param block [Block] Within this block, all omitted button options point to `keys_to_overwrite`
-  def self.with_button_defaults(**keys_to_overwrite, &block)
-    # Lazy initialize butto_defaults store if it hasn't been yet
-    RequestStore.store[:button_defaults] ||= {}
-    keys_to_overwrite.transform_keys!(&:to_sym)
-    old_values = {}
-    newly_defined_keys = keys_to_overwrite.keys - RequestStore.store[:button_defaults].keys
-    keys_to_overwrite.each do |key, new_value|
-      # Assign new value
-      old_values[key] = RequestStore.store[:button_defaults][key]
-      RequestStore.store[:button_defaults][key] = new_value
-    end
-    return_value = block.call
-    # Restore previous value
-    keys_to_overwrite.each_key do |key|
-      RequestStore.store[:button_defaults][key] = old_values[key]
-    end
-    # Undefine keys that were not there previously
-    newly_defined_keys.each { |key| RequestStore.store[:button_defaults].delete(key) }
-    return return_value
-  end
-
   # Goes through model_field_namespaces and returns the first hit for the given constant
   # @param constant [Constant] The constant that is searched, e.g. RichText -> would return e.g. Compony::ModelFields::RichText
   def self.model_field_class_for(constant)
@@ -279,6 +190,7 @@ require 'request_store'
 require 'schemacop'
 require 'simple_form'
 
+require 'compony/intent'
 require 'compony/engine'
 require 'compony/model_fields/base'
 require 'compony/model_fields/anchormodel'
@@ -306,8 +218,10 @@ require 'compony/component_mixins/default/standalone/verb_dsl'
 require 'compony/component_mixins/default/standalone/resourceful_verb_dsl'
 require 'compony/component_mixins/default/labelling'
 require 'compony/component_mixins/resourceful'
+require 'compony/exposed_intents_dsl'
 require 'compony/component'
-require 'compony/components/button'
+require 'compony/components/buttons/link'
+require 'compony/components/buttons/css_button'
 require 'compony/components/index'
 require 'compony/components/list'
 require 'compony/components/show'
@@ -323,3 +237,7 @@ require 'compony/request_context'
 require 'compony/version'
 require 'compony/view_helpers'
 require 'compony/controller_mixin'
+
+if defined?(ActiveType::Object)
+  require 'compony/virtual_model'
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: compony
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Sandro Kalbermatter
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-14 00:00:00.000000000 Z
+date: 2025-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
@@ -203,6 +203,9 @@ files:
 - doc/Compony/ComponentMixins/Resourceful.html
 - doc/Compony/Components.html
 - doc/Compony/Components/Button.html
+- doc/Compony/Components/Buttons.html
+- doc/Compony/Components/Buttons/CssButton.html
+- doc/Compony/Components/Buttons/Link.html
 - doc/Compony/Components/Destroy.html
 - doc/Compony/Components/Edit.html
 - doc/Compony/Components/Form.html
@@ -213,6 +216,8 @@ files:
 - doc/Compony/Components/WithForm.html
 - doc/Compony/ControllerMixin.html
 - doc/Compony/Engine.html
+- doc/Compony/ExposedIntentsDsl.html
+- doc/Compony/Intent.html
 - doc/Compony/MethodAccessibleHash.html
 - doc/Compony/ModelFields.html
 - doc/Compony/ModelFields/Anchormodel.html
@@ -240,6 +245,7 @@ files:
 - doc/Compony/RequestContext.html
 - doc/Compony/Version.html
 - doc/Compony/ViewHelpers.html
+- doc/Compony/VirtualModel.html
 - doc/ComponyController.html
 - doc/_index.html
 - doc/class_list.html
@@ -249,6 +255,29 @@ files:
 - doc/file.README.html
 - doc/file_list.html
 - doc/frames.html
+- doc/guide/basic_component.md
+- doc/guide/example.md
+- doc/guide/feasibility.md
+- doc/guide/generators.md
+- doc/guide/inheritance.md
+- doc/guide/installation.md
+- doc/guide/intents.md
+- doc/guide/internal_datastructures.md
+- doc/guide/model_fields.md
+- doc/guide/nesting.md
+- doc/guide/ownership.md
+- doc/guide/pre_built_components.md
+- doc/guide/pre_built_components/destroy.md
+- doc/guide/pre_built_components/edit.md
+- doc/guide/pre_built_components/form.md
+- doc/guide/pre_built_components/index.md
+- doc/guide/pre_built_components/list.md
+- doc/guide/pre_built_components/new.md
+- doc/guide/pre_built_components/show.md
+- doc/guide/pre_built_components/with_form.md
+- doc/guide/resourceful.md
+- doc/guide/standalone.md
+- doc/guide/virtual_models.md
 - doc/imgs/intro-example-destroy.png
 - doc/imgs/intro-example-edit.png
 - doc/imgs/intro-example-index.png
@@ -271,7 +300,8 @@ files:
 - lib/compony/component_mixins/default/standalone/standalone_dsl.rb
 - lib/compony/component_mixins/default/standalone/verb_dsl.rb
 - lib/compony/component_mixins/resourceful.rb
-- lib/compony/components/button.rb
+- lib/compony/components/buttons/css_button.rb
+- lib/compony/components/buttons/link.rb
 - lib/compony/components/destroy.rb
 - lib/compony/components/edit.rb
 - lib/compony/components/form.rb
@@ -282,6 +312,8 @@ files:
 - lib/compony/components/with_form.rb
 - lib/compony/controller_mixin.rb
 - lib/compony/engine.rb
+- lib/compony/exposed_intents_dsl.rb
+- lib/compony/intent.rb
 - lib/compony/method_accessible_hash.rb
 - lib/compony/model_fields/anchormodel.rb
 - lib/compony/model_fields/association.rb
@@ -308,6 +340,7 @@ files:
 - lib/compony/request_context.rb
 - lib/compony/version.rb
 - lib/compony/view_helpers.rb
+- lib/compony/virtual_model.rb
 - lib/generators/component/USAGE
 - lib/generators/component/component_generator.rb
 - lib/generators/component/templates/component.rb.erb

data/lib/compony/components/button.rb

@@ -1,61 +0,0 @@
-module Compony
-  module Components
-    # @api description
-    # This is the default button implementation, providing a minimal button
-    class Button < Compony::Component
-      SUPPORTED_TYPES = %i[button submit].freeze
-
-      # path: If given a block, it will be evaluated in the helpers context when rendering
-      # enabled: If given a block, it will be evaluated in the helpers context when rendering
-      def initialize(*, label: nil, path: nil, method: nil, type: nil, enabled: nil, visible: nil, title: nil, button_params: nil, value: nil, **, &)
-        @label = label || Compony.button_defaults[:label]
-        @type = type&.to_sym || Compony.button_defaults[:type] || :button
-        @path = path || Compony.button_defaults[:path] || 'javascript:void(0)'
-        @method = method || Compony.button_defaults[:method]
-        if @type != :button && !@method.nil?
-          fail("Param `method` is only allowed for :button type buttons, but got method #{@method.inspect} for type #{@type.inspect}")
-        end
-        @method ||= :get
-        @enabled = enabled
-        @enabled = Compony.button_defaults[:enabled] if @enabled.nil?
-        @enabled = true if @enabled.nil?
-        @visible = visible
-        @visible = Compony.button_defaults[:visible] if @visible.nil?
-        @visible = true if @visible.nil?
-        @title = title || Compony.button_defaults[:title]
-        @button_params = button_params
-        @value = value
-
-        fail "Unsupported button type #{@type}, use on of: #{SUPPORTED_TYPES.inspect}" unless SUPPORTED_TYPES.include?(@type)
-
-        super(*, **, &)
-      end
-
-      setup do
-        before_render do
-          if @path.respond_to?(:call)
-            @path = instance_exec(&@path)
-          end
-          if @enabled.respond_to?(:call)
-            @enabled = @enabled.call(controller)
-          end
-          if @visible.respond_to?(:call)
-            @visible = @visible.call(controller)
-          end
-          @path = 'javascript:void(0)' unless @enabled
-        end
-
-        content do
-          if @visible
-            case @type
-            when :button
-              concat button_to(@label, @path, method: @method, disabled: !@enabled, title: @title, params: @button_params)
-            when :submit
-              concat button_tag(@label, type: :submit, disabled: !@enabled, title: @title, value: @value)
-            end
-          end
-        end
-      end
-    end
-  end
-end