compony 0.5.2 → 0.5.4

data/lib/compony/components/button.rb

@@ -7,7 +7,7 @@ module Compony
 
       # 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, **, &)
+      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)'
@@ -23,6 +23,8 @@ module Compony
         @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)
 
@@ -47,9 +49,9 @@ module Compony
           if @visible
             case @type
             when :button
-              concat button_to(@label, @path, method: @method, disabled: !@enabled, title: @title)
+              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)
+              concat button_tag(@label, type: :submit, disabled: !@enabled, title: @title, value: @value)
             end
           end
         end

data/lib/compony/components/form.rb

@@ -3,9 +3,10 @@ module Compony
     # @api description
     # This component is used for the _form partial in the Rails paradigm.
     class Form < Component
-      def initialize(*args, cancancan_action: :missing, **kwargs)
+      def initialize(*args, cancancan_action: :missing, disabled: false, **kwargs)
         @schema_lines_for_data = [] # Array of procs taking data returning a Schemacop proc
         @cancancan_action = cancancan_action
+        @form_disabled = disabled
         super
       end
 
@@ -35,7 +36,8 @@ module Compony
         end
 
         content do
-          form_html = simple_form_for(data, method: @comp_opts[:submit_verb], url: @submit_path) do |f|
+          form_params = { method: @comp_opts[:submit_verb], url: @submit_path }.merge(@form_params || {})
+          form_html = simple_form_for(data, **form_params) do |f|
             component.with_simpleform(f, controller) do
               instance_exec(&form_fields)
               div class: 'compony-form-buttons' do
@@ -94,30 +96,38 @@ module Compony
 
       # Called inside the form_fields block. This makes the method `field` available in the block.
       # See also notes for `with_simpleform`.
-      def field(name, **input_opts)
+      # If multilang is true, a suffixed field is generated for every available locale (useful with gem "mobility"). Render the array as you wish.
+      def field(name, multilang: false, **input_opts)
         fail("The `field` method may only be called inside `form_fields` for #{inspect}.") unless @simpleform
-        name = name.to_sym
 
-        # Check per-field authorization
-        if @cancancan_action.present? && @controller.current_ability.permitted_attributes(@cancancan_action, @simpleform.object).exclude?(name)
-          Rails.logger.debug do
-            "Skipping form field #{name.inspect} because the current user is not allowed to perform #{@cancancan_action.inspect} on #{@simpleform.object}."
+        if multilang
+          I18n.available_locales.map { |locale| field("#{name}_#{locale}", **input_opts) }
+        else
+          name = name.to_sym
+
+          input_opts.merge!(disabled: true) if @form_disabled
+
+          # Check per-field authorization
+          if @cancancan_action.present? && @controller.current_ability.permitted_attributes(@cancancan_action, @simpleform.object).exclude?(name)
+            Rails.logger.debug do
+              "Skipping form field #{name.inspect} because the current user is not allowed to perform #{@cancancan_action.inspect} on #{@simpleform.object}."
+            end
+            return
           end
-          return
-        end
 
-        hidden = input_opts.delete(:hidden)
-        model_field = @simpleform.object.fields[name]
-        fail("Field #{name.inspect} is not defined on #{@simpleform.object.inspect} but was requested in #{inspect}.") unless model_field
+          hidden = input_opts.delete(:hidden)
+          model_field = @simpleform.object.fields[name]
+          fail("Field #{name.inspect} is not defined on #{@simpleform.object.inspect} but was requested in #{inspect}.") unless model_field
 
-        if hidden
-          return model_field.simpleform_input_hidden(@simpleform, self, **input_opts)
-        else
-          unless @focus_given || @skip_autofocus
-            input_opts[:autofocus] = true unless input_opts.key? :autofocus
-            @focus_given = true
+          if hidden
+            return model_field.simpleform_input_hidden(@simpleform, self, **input_opts)
+          else
+            unless @focus_given || @skip_autofocus
+              input_opts[:autofocus] = true unless input_opts.key? :autofocus
+              @focus_given = true
+            end
+            return model_field.simpleform_input(@simpleform, self, **input_opts)
           end
-          return model_field.simpleform_input(@simpleform, self, **input_opts)
         end
       end
 
@@ -155,6 +165,16 @@ module Compony
         Compony::ModelFields::Anchormodel.collect(...)
       end
 
+      # DSL method, disables all inputs
+      def disable!
+        @form_disabled = true
+      end
+
+      # DSL method, allows to customize parameters given to simple_form_for
+      def form_params(**new_form_params)
+        @form_params = new_form_params
+      end
+
       protected
 
       # DSL method, adds a new line to the schema whitelisting a single param inside the schema's wrapper
@@ -165,19 +185,24 @@ module Compony
 
       # DSL method, adds a new field to the schema whitelisting a single field of data_class
       # This auto-generates the correct schema line for the field.
-      def schema_field(field_name)
-        # This runs upon component setup.
-        @schema_lines_for_data << proc do |data, controller|
-          # This runs within a request context.
-          field = data.class.fields[field_name.to_sym] || fail("No field #{field_name.to_sym.inspect} found for #{data.inspect} in #{inspect}.")
-          # Check per-field authorization
-          if @cancancan_action.present? && controller.current_ability.permitted_attributes(@cancancan_action.to_sym, data).exclude?(field.name.to_sym)
-            Rails.logger.debug do
-              "Skipping form schema_field #{field_name.inspect} because the current user is not allowed to perform #{@cancancan_action.inspect} on #{data}."
+      # If multilang is true, a suffixed field is generated for every available locale (useful with gem "mobility")
+      def schema_field(field_name, multilang: false)
+        if multilang
+          I18n.available_locales.each { |locale| schema_field("#{field_name}_#{locale}") }
+        else
+          # This runs upon component setup.
+          @schema_lines_for_data << proc do |data, controller|
+            # This runs within a request context.
+            field = data.class.fields[field_name.to_sym] || fail("No field #{field_name.to_sym.inspect} found for #{data.inspect} in #{inspect}.")
+            # Check per-field authorization
+            if @cancancan_action.present? && controller.current_ability.permitted_attributes(@cancancan_action.to_sym, data).exclude?(field.name.to_sym)
+              Rails.logger.debug do
+                "Skipping form schema_field #{field_name.inspect} because the current user is not allowed to perform #{@cancancan_action.inspect} on #{data}."
+              end
+              next nil
             end
-            next nil
+            next field.schema_line
           end
-          next field.schema_line
         end
       end
 
@@ -190,7 +215,7 @@ module Compony
           # Check per-field authorization
           unless @cancancan_action.nil? || controller.current_ability.can?(:set_password, data)
             Rails.logger.debug do
-              "Skipping form schema_pw_field #{name.inspect} because the current user is not allowed to perform :set_password on #{data}."
+              "Skipping form schema_pw_field #{field_name.inspect} because the current user is not allowed to perform :set_password on #{data}."
             end
             next nil
           end

data/lib/compony/model_mixin.rb

@@ -19,21 +19,27 @@ module Compony
       end
 
       # DSL method, defines a new field which will be translated and can be added to field groups
-      def field(name, type, **extra_attrs)
-        name = name.to_sym
-        self.fields = fields.dup
-        field = Compony.model_field_class_for(type.to_s.camelize).new(name, self, **extra_attrs)
-        # Handle the case where ActiveType would interfere with attribute registration
-        if defined?(ActiveType) && self <= ActiveType::Object && !include?(ActiveModel::Attributes)
-          fail "Please add `include ActiveModel::Attributes` at the top of the class #{self}, as attributes cannot be registered otherwise with ActiveType."
-        end
-        # Register the field as an attribute
-        if defined?(ActiveType) && self <= ActiveType::Object
-          ar_attribute(name)
+      # If multilang is true, a suffixed field is generated for every available locale, along with a non-suffixed virtual field (useful with gem "mobility")
+      def field(name, type, multilang: false, **extra_attrs)
+        if multilang
+          field(name, type, virtual: true, **extra_attrs)
+          I18n.available_locales.each { |locale| field("#{name}_#{locale}", type, **extra_attrs) }
         else
-          attribute(name)
+          name = name.to_sym
+          self.fields = fields.dup
+          field = Compony.model_field_class_for(type.to_s.camelize).new(name, self, **extra_attrs)
+          # Handle the case where ActiveType would interfere with attribute registration
+          if defined?(ActiveType) && self <= ActiveType::Object && !include?(ActiveModel::Attributes)
+            fail "Please add `include ActiveModel::Attributes` at the top of the class #{self}, as attributes cannot be registered otherwise with ActiveType."
+          end
+          # Register the field as an attribute
+          if defined?(ActiveType) && self <= ActiveType::Object
+            ar_attribute(name)
+          else
+            attribute(name)
+          end
+          fields[name] = field
         end
-        fields[name] = field
       end
 
       # DSL method, sets the containing model.

data/lib/compony/view_helpers.rb

@@ -19,11 +19,19 @@ module Compony
     # @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, model_or_family_name_or_cst, *link_args, label_opts: {}, **link_kwargs)
+    def compony_link(comp_name_or_cst_or_class, model_or_family_name_or_cst = nil, *link_args, label_opts: {}, params: {}, standalone_name: nil, **link_kwargs)
       model = model_or_family_name_or_cst.respond_to?(:model_name) ? model_or_family_name_or_cst : nil
-      comp = Compony.comp_class_for!(comp_name_or_cst, model_or_family_name_or_cst).new(data: model)
-      return unless comp.standalone_access_permitted_for?(self)
-      return helpers.link_to(comp.label(model, **label_opts), Compony.path(comp.comp_name, comp.family_name, model), *link_args, **link_kwargs)
+      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:)
+      return helpers.link_to(
+        target_comp_instance.label(model, **label_opts),
+        Compony.path(target_comp_instance.comp_name, target_comp_instance.family_name, model, standalone_name:, **params),
+        *link_args, **link_kwargs
+      )
     end
 
     # Given a component and a family/model, this instanciates and renders a button component.

data/lib/compony.rb

@@ -79,13 +79,13 @@ module Compony
   end
 
   # Getter for content_before_root_comp_block
-  # @see Compony#content_before_root_comp
+  # @see Compony#content_before_root_comp=
   def self.content_before_root_comp_block
     @content_before_root_comp_block
   end
 
   # Getter for content_after_root_comp_block
-  # @see Compony#content_after_root_comp
+  # @see Compony#content_after_root_comp=
   def self.content_after_root_comp_block
     @content_after_root_comp_block
   end
@@ -198,7 +198,7 @@ module Compony
       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, verb: method) }
+      visible: ->(controller) { target_comp_instance.standalone_access_permitted_for?(controller, standalone_name:, verb: method) }
     }
     if feasibility_target
       options.merge!({

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: compony
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.5.4
 platform: ruby
 authors:
 - Sandro Kalbermatter
 - contributors
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-11-20 00:00:00.000000000 Z
+date: 2025-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: yard
@@ -165,8 +164,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 3.6.1
-description:
-email:
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -312,10 +309,8 @@ files:
 - lib/generators/components/USAGE
 - lib/generators/components/components_generator.rb
 - logo.svg
-homepage:
 licenses: []
 metadata: {}
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -330,8 +325,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.22
-signing_key:
+rubygems_version: 3.6.3
 specification_version: 4
 summary: Compony is a Gem that allows you to write your Rails application in component-style
   fashion. It combines a controller action and route along \ with its view into a