compony 0.7.1 → 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.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'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: compony
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Sandro Kalbermatter
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-11-20 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
@@ -254,15 +259,14 @@ files:
 - doc/guide/example.md
 - doc/guide/feasibility.md
 - doc/guide/generators.md
-- doc/guide/helpers.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/button.md
 - doc/guide/pre_built_components/destroy.md
 - doc/guide/pre_built_components/edit.md
 - doc/guide/pre_built_components/form.md
@@ -272,7 +276,6 @@ files:
 - doc/guide/pre_built_components/show.md
 - doc/guide/pre_built_components/with_form.md
 - doc/guide/resourceful.md
-- doc/guide/root_actions.md
 - doc/guide/standalone.md
 - doc/guide/virtual_models.md
 - doc/imgs/intro-example-destroy.png
@@ -297,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
@@ -308,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

data/doc/guide/helpers.md

@@ -1,156 +0,0 @@
-[Back to the guide](/README.md#guide)
-
-# Compony helpers, links and buttons
-
-When pointing to or instantiating a component, writing the whole class name would be cumbersome. For this reason, Compony has several helpers that will retrieve the correct class for you. The most important ones are explained in this subsection. The terms are defined as follows:
-
-- Component name or constant: For a component `Components::Users::Show`, this would be `'Show'`, `'show'`, or `:show`
-- Family name or constant: For a component `Components::Users::Show`, this would be `'Users'`, `'users'`, or `:users`
-- Model: an instance of a class that implements the `model_name` method in the same way as `ActiveRecord::Base` does. For helpers that support giving models, Compony will use `model_name` to auto-infer the family name. This requires you to name the component according to convention, i.e. the family name must match the model's pluralized camelized `model_name`.
-
-## Getting the class of a component
-
-- `Compony.comp_class_for(comp_name_or_cst, model_or_family_name_or_cst)` returns the class or nil if not found.
-- `Compony.comp_class_for!(comp_name_or_cst, model_or_family_name_or_cst)` returns the class. If the class is not found, an error will be raised.
-
-Example:
-
-```ruby
-my_component = Compony.comp_class_for!(:show, User.first).new
-my_component.class # Components::Users::Show
-```
-
-### Getting a path to a component
-
-- `Compony.path(comp_name_or_cst, model_or_family_name_or_cst)` returns the route to a component. Additional positional and keyword arguments will be passed to the Rails helper.
-
-If a model is given, its ID will automatically be added as the `id` parameter when generating the route. This means:
-
-- To generate a path to a non-resourceful component, pass the family name.
-- To generate a path to a resourceful component, prefer passing an instance instead of a family name.
-
-Examples:
-
-```ruby
-link_to 'User overview', Compony.path(:index, :users) # -> 'users/index'
-link_to 'See user page', Compony.path(:show, User.first) # -> 'users/show/1'
-link_to 'See user page', Compony.path(:show, :users, id: 1) # -> 'users/show/1'
-```
-
-Note that the generated paths in the example are just for illustration purposes. The paths point to whatever path you configure in the target component's default standalone config. Also, this example is not how you should generate links to components, as is explained in the next subsection.
-
-### Customizing path generation
-
-By implementing `path do ... end` inside the `setup` method of a component, you can override the way paths to that component are generated. Customizing the path generation will affect all mentioned methods mentioned here involving paths, such as `Compony.path`, `compony_link`, `Compony.button`, `compony_button` etc.
-
-This is an advanced usage. Refer to the default implementation of `Component`'s `path_block` to see an exmple.
-
-## Generating a link to a component
-
-In order to allow a user to visit another component, don't implement your links and buttons manually. Instead, use Compony's links and buttons, as those extract information from the target component, avoiding redundant code and making refactoring much easier.
-
-Compony comes with the view helper `compony_link` that is available in any of your views, including a component's `content` blocks. The link's label is inferred from the component the link points to. `compony_link` is used as follows:
-
-- To generate a link to a non-resourceful component, pass the family name.
-- To generate a link to a resourceful component, prefer passing an instance instead of a family name. More precisely, you must pass an instance if the component's label requires an argument.
-
-Any additional arguments passed to `compony_link` will be given to Rails' `link_to` method, allowing you to set parameters, HTTP method, terget, rel etc.
-
-Examples:
-
-```ruby
-compony_link(:index, :users) # "View all users" -> 'users/index'
-compony_link(Components::Users::Index) # same as above
-compony_link(:index, :users, label_opts: { format: :short }) # "All" -> 'users/index'
-compony_link(:show, User.first) # "View John Doe" -> 'users/show/1'
-compony_link(:destroy, User.first, method: :delete) # "Delete John Doe" -> 'users/destroy/1'
-
-# NOT working:
-compony_link(:show, :users, id: 1) # Error: The label for the Users::Show component takes an argument which was not provided (the user's label)
-```
-
-## Generating a button to a component
-
-Compony buttons are components that render a button to another component. While the view helper `compony_button` works similar to `compony_link`, you can also manually instantiate a button and work with it like with any other component.
-
-Similar to links, Compony buttons take a component name and either a family or model. The label, path, method and title (i.e. tooltip) can be overwritten by passing the respective arguments as shown below.
-
-Compony buttons have a type that is either `:button` or `:submit`. While the first works like a link redirecting the user elsewhere, the second is used for submitting forms. It can be used inside a `form_for` or `simple_form_for`.
-
-A compony button figures out on it's own whether it's clickable or not:
-
-- Buttons can be disabled explicitly by passing `enabled: false` as a parameter.
-- If a user is not authorized to access the component a button is pointing to, the button is not displayed.
-- If the target component should not be accessible due to a prevention in the [feasibility framework](./feasibility.md), the button is disabled and a tooltip is shown explaining why the button is not clickable.
-
-Do not directly instantiate `Compony::Components::Button`. Instead, use `Compony.button`:
-
-```ruby
-my_button = Compony.button(:index, :users) # "View all users" -> 'users/index'
-my_button = Compony.button(:index, :users, label_opts: { format: :short }) # "All" -> 'users/index'
-my_button = Compony.button(:index, :users, label: 'Back') # "Back" -> 'users/index'
-my_button = Compony.button(:show, User.first) # "View John Doe" -> 'users/show/1'
-my_button = Compony.button(:new, :users, label: 'New customer', params: { user: { type: 'customer' } }) # "New customer" -> 'users/new?user[type]=customer'
-my_button = Compony.button(:new, :users, label: 'New customer', params: { user: { type: 'customer' } }, method: :post) # Instantly creates user.
-my_button = Compony.button(label: 'I point to a plain Rails route', path: 'some/path') # Specifying a custom path
-my_button = Compony.button(label: 'Nothing happens if you click me') # javascript:void()
-my_button = Compony.button(label: 'Not implemented yet', enabled: false) # Disabled button
-
-# `enabled` and `path` can also be provided with a callable (block or lambda) to defer evaluation until when the button is rendered.
-# The lambdas will be called in the button's `before_render` and given the controller, allowing you to query request specific data.
-my_button = Compony.button(label: 'I point to a plain Rails route', path: ->{ |controller| controller.helpers.some_rails_path })
-my_button = Compony.button(:index, :users, enabled: -> { |controller| controller.current_ability.can?(:read, :index_pages) })
-```
-
-A Compony button can be rendered like any other component:
-
-```erb
-<%= my_button.render(controller) %>
-```
-
-However, it is much easier to just use the appropriate view helper instead, which takes the same arguments as `Compony.button`:
-
-```ruby
-compony_button(:index, :users)
-```
-
-If you need to render many buttons that share a parameter, the call `Compony.with_button_defaults` allows you to DRY up your code:
-
-```ruby
-# Assuming this is inside a Dyny view context and each button should be inside a div.
-# Without with_button_defaults:
-  div compony_button(:new, :documents, label_opts: { format: :short }, method: :post)
-  div compony_button(:new, :letters, label_opts: { format: :short }, method: :post)
-  div compony_button(:new, :articles, label_opts: { format: :short }, method: :post)
-
-# Equivalent using with_button_defaults:
-Compony.with_button_defaults(label_opts: { format: :short }, method: :post) do
-  div compony_button(:new, :documents)
-  div compony_button(:new, :letters)
-  div compony_button(:new, :articles)
-end
-```
-
-### Implementing custom buttons
-
-Plain HTML buttons are not exactly eye candy, so you will likely want to implement your button kind with black jack and icons. For this reason, the button instantiated by Compony's button helpers can be customized.
-
-To build your own button class, inherit as follows:
-
-```ruby
-class MyButton < Compony::Components::Button
-  def initialize(*args, **kwargs, &block) # Add extra arguments here
-    super(*args, **kwargs, &block)
-    # Add extra initialization code here
-  end
-
-  # Add/replace before_render/content here. Be careful to not overwrite code you depend on. Check Compony's button's code for details.
-end
-```
-
-Then, in the Compony initializer, register your custom button class to have Compony instantiate it whenever `Compony.button` or another helper is called:
-
-```ruby
-# config/initializers/compony.rb
-Compony.button_component_class = 'MyButton'
-```

data/doc/guide/pre_built_components/button.md

@@ -1,8 +0,0 @@
-- [Back to the guide](/README.md#guide)
-- [List of pre-built components](/doc/guide/pre_built_components.md)
-
-# Pre-built components: Button
-
-As stated earlier, buttons are just regular components that rendered in-place. They don't make use of nesting logic (and presumably never will), and thus they are rendered as-is, without `sub_comp`.
-
-You will rarely (or probably never) instantiate a button on your own, but use helpers like `Compony.button` or `compony_button`. For this reason, the documentation for instantiating buttons is located in the [section documenting helpers](/doc/guide/helpers.md).

data/doc/guide/root_actions.md

@@ -1,67 +0,0 @@
-[Back to the guide](/README.md#guide)
-
-# Compony root actions
-
-The word "actions" is heavily overused, so here is a disambiguation:
-
-- Rails controller actions: a method that is implemented in a Rails controller
-- CanCanCan actions: the first method to CanCanCan's `can?` method
-- Compony root actions: buttons that point to other components
-
-At this point, Compony actions are a loose concept, which will likely be refined in the future. Currently, Compony actions are defined as buttons, rendered by the application layout, that point to other components. They provide context-sensitive buttons to your application.
-
-## Defining and manipulating root actions
-
-In addition to regular buttons that are rendered as part of the content blocks, components can expose root actions with the `actions` call. Root actions will only be rendered if the component they are defined in is currently the root component.
-
-To have a component expose a root action, call the method `action` in a `setup` block and return a Compony button:
-
-```ruby
-setup do
-  action :edit do
-    Compony.button(:edit, @data)
-  end
-
-  action :destroy do
-    Compony.button(:destroy, @data)
-  end
-end
-```
-
-The name of the action ("edit" and "destroy" in the example above) allows you to refer to that action in a component inheriting from this one:
-
-```ruby
-# Assuming that this component inherits from the example above
-setup do
-  skip_action :destroy
-
-  action :overview, before: :edit do
-    Compony.button(:index, :users, label: 'Overview')
-  end
-end
-```
-
-In this example, two actions will be shown: overview and edit.
-
-An action button can be disabled through the [feasibility framework](./feasibility.md). However, it can also instead be hidden completely by returning nil from within the action block:
-
-```ruby
-action :edit do
-  next if @data.locked?
-  Compony.button(:edit, @data)
-end
-```
-
-The action in this example will be skipped entirely if `locked?` returns true.
-
-## Displaying root actions
-
-Root actions are not shown by default in Compony because layouting is up to you. In order to display the root component's actions, add the following view helper call to your layout:
-
-```erb
-<%# layouts/application.html.erb %>
-...
-<%= compony_actions %>
-```
-
-If there is currently no root component, or if the root component defines no actions, this does nothing. However, if there are root actions available, the Compony buttons returned by the root component will be rendered.