compony 0.0.1

data/lib/compony/components/button.rb

@@ -0,0 +1,59 @@
+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(*args, label: nil, path: nil, method: nil, type: nil, enabled: nil, visible: nil, title: nil, **kwargs, &block)
+        @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]
+
+        fail "Unsupported button type #{@type}, use on of: #{SUPPORTED_TYPES.inspect}" unless SUPPORTED_TYPES.include?(@type)
+
+        super(*args, **kwargs, &block)
+      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)
+            when :submit
+              concat button_tag(@label, type: :submit, disabled: !@enabled, title: @title)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/compony/components/form.rb

@@ -0,0 +1,138 @@
+module Compony
+  module Components
+    # @api description
+    # This component is used for the _form partial in the Rails paradigm.
+    class Form < Component
+      def initialize(...)
+        @schema_lines_for_data = [] # Array of procs taking data returning a Schemacop proc
+        super
+      end
+
+      def check_config!
+        super
+        fail "#{inspect} requires config.form_fields do ..." if @form_fields.blank?
+      end
+
+      setup do
+        before_render do
+          # Must render the buttons now as the rendering within simple form breaks the form
+          @submit_button = Compony.button_component_class.new(
+            label: @submit_label || I18n.t('compony.components.form.submit'), icon: 'arrow-right', type: :submit
+          ).render(controller)
+          @submit_path = @comp_opts[:submit_path]
+          @submit_path = @submit_path.call(controller) if @submit_path.respond_to?(:call)
+        end
+
+        content do
+          form_html = simple_form_for(data, method: @comp_opts[:submit_verb], url: @submit_path) do |f|
+            component.with_simpleform(f) do
+              instance_exec(&form_fields)
+              div @submit_button, class: 'compony-form-buttons'
+            end
+          end
+          concat form_html
+        end
+      end
+
+      # DSL method, use to set the form content
+      def form_fields(&block)
+        return @form_fields unless block_given?
+        @form_fields = block
+      end
+
+      # Attr reader for @schema_wrapper_key with auto-calculated default
+      def schema_wrapper_key_for(data)
+        if @schema_wrapper_key.present?
+          return @schema_wrapper_key
+        else
+          # If schema was not called, auto-infer a default
+          data.model_name.singular
+        end
+      end
+
+      # Attr reader for @schema_block with auto-calculated default
+      def schema_block_for(data)
+        if @schema_block
+          return @schema_block
+        else
+          # If schema was not called, auto-infer a default
+          local_schema_lines_for_data = @schema_lines_for_data
+          return proc do
+            local_schema_lines_for_data.each do |schema_line|
+              instance_exec(&schema_line.call(data))
+            end
+          end
+        end
+      end
+
+      # This method is used by render to store the simpleform instance inside the component such that we can call
+      # methods from inside `form_fields`. This is a workaround required because the form does not exist when the
+      # RequestContext is being built, and we want the method `field` to be available inside the `form_fields` block.
+      # @todo Refactor? Could this be greatly simplified by having `form_field to |f|` ?
+      def with_simpleform(simpleform)
+        @simpleform = simpleform
+        yield
+        @simpleform = nil
+      end
+
+      # 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)
+        fail("The `field` method may only be called inside `form_fields` for #{inspect}.") unless @simpleform
+
+        hidden = input_opts.delete(:hidden)
+        model_field = @simpleform.object.fields[name.to_sym]
+        fail("Field #{name.to_sym.inspect} is not defined on #{@simpleform.object.inspect} but was requested in #{inspect}.") unless model_field
+
+        if hidden
+          return @simpleform.input model_field.schema_key, as: :hidden, **input_opts
+        else
+          return model_field.simpleform_input(@simpleform, self, **input_opts)
+        end
+      end
+
+      # Called inside the form_fields block. This makes the method `f` available in the block.
+      # See also notes for `with_simpleform`.
+      def f
+        fail("The `f` method may only be called inside `form_fields` for #{inspect}.") unless @simpleform
+        return @simpleform
+      end
+
+      # Quick access for wrapping collections in Rails compatible format
+      def collect(...)
+        Compony::ModelFields::Anchormodel.collect(...)
+      end
+
+      protected
+
+      # DSL method, adds a new line to the schema whitelisting a single param inside the schema's wrapper
+      def schema_line(&block)
+        @schema_lines_for_data << proc { block }
+      end
+
+      # 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)
+        @schema_lines_for_data << proc do |data|
+          field = data.class.fields[field_name.to_sym] || fail("No field #{field_name.to_sym.inspect} found for #{data.inspect} in #{inspect}.")
+          next field.schema_line
+        end
+      end
+
+      # DSL method, mass-assigns schema fields
+      def schema_fields(*field_names)
+        field_names.each { |field_name| schema_field(field_name) }
+      end
+
+      # DSL method, use to replace the form's schema and wrapper key for a completely manual schema
+      def schema(wrapper_key, &block)
+        if block_given?
+          @schema_wrapper_key = wrapper_key
+          @schema_block = block
+        else
+          fail 'schema requires a block to be given'
+        end
+      end
+    end
+  end
+end

data/lib/compony/components/resourceful/destroy.rb

@@ -0,0 +1,77 @@
+module Compony
+  module Components
+    module Resourceful
+      # @api description
+      # This component is used for the Rails destroy paradigm. Asks for confirm when queried using GET.
+      class Destroy < Compony::Component
+        include Compony::ComponentMixins::Resourceful
+
+        setup do
+          standalone path: "#{family_name}/:id/destroy" do
+            verb :get do
+              authorize { can?(:destroy, @data) }
+            end
+
+            verb :delete do
+              authorize { can?(:destroy, @data) }
+              store_data # This enables the global store_data block defined below for this path and verb.
+              respond do
+                evaluate_with_backfire(&@on_destroyed_block)
+              end
+            end
+          end
+
+          label(:long) { |data| I18n.t('compony.components.destroy.label.long', data_label: data.label) }
+          label(:short) { |_| I18n.t('compony.components.destroy.label.short') }
+          icon { :trash }
+          color { :danger }
+
+          content do
+            div I18n.t('compony.components.destroy.confirm_question', data_label: @data.label)
+            div do
+              concat compony_button(comp_cst,
+                                    @data,
+                                    label:  I18n.t('compony.components.destroy.confirm_button'),
+                                    method: :delete)
+            end
+          end
+
+          store_data do
+            # Validate params against the form's schema
+            local_data = @data # Capture data for usage in the Schemacop call
+            schema = Schemacop::Schema3.new :hash, additional_properties: true do
+              if local_data.class.primary_key_type_key == :string
+                str! :id
+              else
+                int! :id, cast_str: true
+              end
+            end
+            schema.validate!(controller.request.params)
+
+            # Perform destroy
+            @data.destroy!
+          end
+
+          on_destroyed do
+            flash.notice = I18n.t('compony.components.destroy.data_was_destroyed', data_label: @data.label)
+            redirect_to evaluate_with_backfire(&@on_destroyed_redirect_path_block), status: :see_other # 303: force GET
+          end
+
+          on_destroyed_redirect_path do
+            Compony.path(:index, family_cst)
+          end
+        end
+
+        # DSL method
+        def on_destroyed(&block)
+          @on_destroyed_block = block
+        end
+
+        # DSL method
+        def on_destroyed_redirect_path(&block)
+          @on_destroyed_redirect_path_block = block
+        end
+      end
+    end
+  end
+end

data/lib/compony/components/resourceful/edit.rb

@@ -0,0 +1,96 @@
+module Compony
+  module Components
+    module Resourceful
+      # @api description
+      # This component is used for the Rails edit and update paradigm. Performs update when the form is submitted.
+      class Edit < Compony::Components::WithForm
+        include Compony::ComponentMixins::Resourceful
+        setup do
+          submit_verb :patch
+          standalone path: "#{family_name}/:id/edit" do
+            verb :get do
+              authorize { can?(:edit, @data) }
+              assign_attributes # This enables the global assign_attributes block defined below for this path and verb.
+            end
+            verb submit_verb do
+              authorize { can?(:update, @data) }
+              assign_attributes # This enables the global assign_attributes block defined below for this path and verb.
+              store_data # This enables the global store_data block defined below for this path and verb.
+              respond do
+                if @update_succeeded
+                  evaluate_with_backfire(&@on_updated_block)
+                else
+                  evaluate_with_backfire(&@on_update_failed_block)
+                end
+              end
+            end
+          end
+
+          label(:long) { |data| I18n.t('compony.components.edit.label.long', data_label: data.label) }
+          label(:short) { |_| I18n.t('compony.components.edit.label.short') }
+          icon { :pencil }
+
+          content do
+            concat form_comp.render(controller, data: @data)
+          end
+
+          assign_attributes do
+            # Validate params against the form's schema
+            local_form_comp = form_comp # Capture form_comp for usage in the Schemacop call
+            local_data = @data # Capture data for usage in the Schemacop call
+            schema = Schemacop::Schema3.new :hash, additional_properties: true do
+              if local_data.class.primary_key_type_key == :string
+                str! :id
+              else
+                int! :id, cast_str: true
+              end
+              hsh? local_form_comp.schema_wrapper_key_for(local_data), &local_form_comp.schema_block_for(local_data)
+            end
+            schema.validate!(controller.request.params)
+
+            # TODO: Why are we not saving the validated params?
+            attrs_to_assign = controller.request.params[form_comp.schema_wrapper_key_for(@data)]
+            @data.assign_attributes(attrs_to_assign) if attrs_to_assign
+          end
+
+          store_data do
+            @update_succeeded = @data.save
+          end
+
+          on_updated do
+            flash.notice = I18n.t('compony.components.edit.data_was_updated', data_label: data.label)
+            redirect_to evaluate_with_backfire(&@on_updated_redirect_path_block)
+          end
+
+          on_updated_redirect_path do
+            if Compony.comp_class_for(:show, @data)
+              Compony.path(:show, @data)
+            else
+              Compony.path(:index, @data)
+            end
+          end
+
+          on_update_failed do
+            Rails.logger.warn(@data&.errors&.full_messages)
+            render_standalone(controller, status: :unprocessable_entity)
+          end
+        end
+
+        # DSL method
+        def on_updated(&block)
+          @on_updated_block = block
+        end
+
+        # DSL method
+        def on_updated_redirect_path(&block)
+          @on_updated_redirect_path_block = block
+        end
+
+        # DSL method
+        def on_update_failed(&block)
+          @on_update_failed_block = block
+        end
+      end
+    end
+  end
+end

data/lib/compony/components/resourceful/new.rb

@@ -0,0 +1,95 @@
+module Compony
+  module Components
+    module Resourceful
+      # @api description
+      # This component is used for the Rails new and create paradigm. Performs update when the form is submitted.
+      class New < Compony::Components::WithForm
+        include Compony::ComponentMixins::Resourceful
+
+        setup do
+          submit_verb :post
+          load_data { @data = data_class.new }
+          standalone path: "#{family_name}/new" do
+            verb :get do
+              authorize { can?(:create, data_class) }
+              assign_attributes # This enables the global assign_attributes block defined below for this path and verb.
+            end
+            verb submit_verb do
+              authorize { can?(:create, data_class) }
+              assign_attributes # This enables the global assign_attributes block defined below for this path and verb.
+              store_data # This enables the global store_data block defined below for this path and verb.
+              respond do
+                if @create_succeeded
+                  evaluate_with_backfire(&@on_created_block)
+                else
+                  evaluate_with_backfire(&@on_create_failed_block)
+                end
+              end
+            end
+          end
+
+          label(:long) { I18n.t('compony.components.new.label.long', data_class: data_class.model_name.human) }
+          label(:short) { I18n.t('compony.components.new.label.short') }
+          icon { :plus }
+
+          add_content do
+            h2 component.label
+          end
+          add_content do
+            concat form_comp.render(controller, data: @data)
+          end
+
+          assign_attributes do
+            local_form_comp = form_comp # Capture form_comp for usage in the Schemacop call
+            local_data = @data # Capture data for usage in the Schemacop call
+            schema = Schemacop::Schema3.new :hash, additional_properties: true do
+              hsh? local_form_comp.schema_wrapper_key_for(local_data), &local_form_comp.schema_block_for(local_data)
+            end
+            schema.validate!(controller.request.params)
+
+            # TODO: Why are we not saving the validated params?
+            attrs_to_assign = controller.request.params[form_comp.schema_wrapper_key_for(@data)]
+            @data.assign_attributes(attrs_to_assign) if attrs_to_assign
+          end
+
+          store_data do
+            @create_succeeded = @data.save
+          end
+
+          on_created do
+            flash.notice = I18n.t('compony.components.new.data_was_created', data_label: data.label)
+            redirect_to evaluate_with_backfire(&@on_created_redirect_path_block)
+          end
+
+          on_created_redirect_path do
+            if Compony.comp_class_for(:show, @data)
+              Compony.path(:show, @data)
+            else
+              Compony.path(:index, @data)
+            end
+          end
+
+          on_create_failed do
+            Rails.logger.warn(@data&.errors&.full_messages)
+            render_standalone(controller, status: :unprocessable_entity)
+          end
+        end
+
+        # DSL method
+        def on_created(&block)
+          @on_created_block = block
+        end
+
+        # DSL method
+        def on_created_redirect_path(&block)
+          @on_created_redirect_path_block = block
+        end
+
+        # DSL method
+        def on_create_failed(&block)
+          @on_create_failed_block = block
+        end
+      end
+    end
+  end
+end

data/lib/compony/components/with_form.rb

@@ -0,0 +1,37 @@
+module Compony
+  module Components
+    # @api description
+    # This component is destined to take a sub-component that is a form component.
+    # It can be called via :get or via `submit_verb` depending on whether its form should be shown or submitted.
+    class WithForm < Component
+      # Returns an instance of the form component responsible for rendering the form.
+      # Feel free to override this in subclasses.
+      def form_comp
+        @form_comp ||= (form_comp_class || comp_class_for!(:form, family_cst)).new(
+          self,
+          submit_verb:,
+          # If applicable, Rails adds the route keys automatically, thus, e.g. :id does not need to be passed here, as it comes from the request.
+          submit_path: ->(controller) { controller.helpers.send("#{Compony.path_helper_name(comp_name, family_name)}_path") }
+        )
+      end
+
+      # DSL method
+      # Sets or returns the previously set submit verb
+      def submit_verb(new_submit_verb = nil)
+        if new_submit_verb.present?
+          new_submit_verb = new_submit_verb.to_sym
+          available_verbs = ComponentMixins::Default::Standalone::VerbDsl::AVAILABLE_VERBS
+          fail "Unknown HTTP verb #{new_submit_verb.inspect}, use one of #{available_verbs.inspect}" unless available_verbs.include?(new_submit_verb)
+          @submit_verb = new_submit_verb
+        end
+        return @submit_verb || fail("WithForm component #{self} is missing a call to `submit_verb`.")
+      end
+
+      # DSL method
+      # Overrides the form comp class that is instanciated to render the form
+      def form_comp_class(new_form_comp_class = nil)
+        @form_comp_class ||= new_form_comp_class
+      end
+    end
+  end
+end

data/lib/compony/controller_mixin.rb

@@ -0,0 +1,12 @@
+module Compony
+  module ControllerMixin
+    extend ActiveSupport::Concern
+
+    include Compony::ViewHelpers
+
+    included do
+      # Declare all methods in each such module as helper_method
+      Compony::ViewHelpers.public_instance_methods.each { |helper_method_sym| helper_method helper_method_sym }
+    end
+  end
+end

data/lib/compony/engine.rb

@@ -0,0 +1,19 @@
+module Compony
+  class Engine < Rails::Engine
+    initializer 'compony.configure_eager_load_paths', before: :load_environment_hook, group: :all do
+      # Allow app/components/foo/bar.rb to define constants Components::Foo::Bar and make sure components are eager loaded (needed for route generation etc.)
+      Rails.application.config.eager_load_paths.delete(Rails.root.join('app', 'components').to_s)
+      Rails.application.config.eager_load_paths.unshift(Rails.root.join('app').to_s)
+
+      # Prevent *.rb files in assets and views directories to be loaded
+      Rails.autoloaders.main.ignore(Rails.root.join('app', 'assets').to_s)
+      Rails.autoloaders.main.ignore(Rails.root.join('app', 'views').to_s)
+    end
+
+    initializer 'compony.controller_mixin' do
+      ActiveSupport.on_load :action_controller_base do
+        include Compony::ControllerMixin
+      end
+    end
+  end
+end

data/lib/compony/method_accessible_hash.rb

@@ -0,0 +1,43 @@
+module Compony
+  # @api description
+  # This class is intended for configs with predefined interfaces and should be used with instances of Hash:<br>
+  # Example:<br>
+  # ```ruby
+  # instance_of_a_hash = Compony::MethodAccessibleHash.new
+  # instance_of_a_hash.merge!({ foo: :bar })
+  # instance_of_a_hash.foo --> :bar
+  # instance_of_a_hash.roo --> nil
+  # ```
+  # See: https://gist.github.com/kalsan/87826048ea0ade92ab1be93c0919b405
+  class MethodAccessibleHash < Hash
+    # Takes an optional hash as argument and constructs a new
+    # MethodAccessibleHash.
+    def initialize(hash = {})
+      super()
+
+      hash.each do |key, value|
+        self[key.to_sym] = value
+      end
+    end
+
+    # @private
+    def merge(hash)
+      super(hash.symbolize_keys)
+    end
+
+    # @private
+    def method_missing(method, *args, &)
+      if method.end_with?('=')
+        name = method.to_s.gsub(/=$/, '')
+        self[name.to_sym] = args.first
+      else
+        self[method.to_sym]
+      end
+    end
+
+    # @private
+    def respond_to_missing?(_method, _include_private = false)
+      true
+    end
+  end
+end

data/lib/compony/model_fields/anchormodel.rb

@@ -0,0 +1,28 @@
+module Compony
+  module ModelFields
+    class Anchormodel < Base
+      # Takes an array of objects implementing the methods `label` and `key` and returns an array suitable for simple_form select fields.
+      def self.collect(flat_array, label_method: :label, key_method: :key)
+        return flat_array.map { |entry| [entry.send(label_method), entry.send(key_method)] }
+      end
+
+      def value_for(data, controller: nil, **_)
+        return transform_and_join(data.send(@name), controller:, &:label)
+      end
+
+      def simpleform_input(form, _component, **input_opts)
+        selected_cst = form.object.send(@name)
+        anchormodel_attribute = @model_class.anchormodel_attributes[@name]
+        anchormodel_class = anchormodel_attribute.anchormodel_class
+        opts = {
+          collection:    self.class.collect(anchormodel_class.all),
+          label_method:  :first,
+          value_method:  :second,
+          selected:      selected_cst&.key || anchormodel_class.all.first,
+          include_blank: anchormodel_attribute.optional
+        }.merge(input_opts)
+        return form.input @name, **opts
+      end
+    end
+  end
+end

data/lib/compony/model_fields/association.rb

@@ -0,0 +1,53 @@
+module Compony
+  module ModelFields
+    class Association < Base
+      def initialize(...)
+        super
+        resolve_association!
+      end
+
+      def value_for(data, link_to_component: nil, link_opts: {}, controller: nil)
+        if link_to_component
+          return transform_and_join(data.send(@name), controller:) do |el|
+            el.nil? ? nil : controller.helpers.compony_link(link_to_component, el, **link_opts)
+          end
+        else
+          return transform_and_join(data.send(@name), controller:) { |el| el&.label }
+        end
+      end
+
+      def schema_line
+        local_schema_key = @schema_key # Capture schema_key as it will not be available within the lambda
+        if multi?
+          return proc do
+            ary? local_schema_key do
+              list :integer, cast_str: true
+            end
+          end
+        else
+          return proc do
+            int? local_schema_key, cast_str: true
+          end
+        end
+      end
+
+      def simpleform_input(form, _component, **input_opts)
+        return form.association @name, **input_opts
+      end
+
+      protected
+
+      # Uses Rails methods to figure out the arity, schema key etc. and store them.
+      # This can be auto-inferred without accessing the database.
+      def resolve_association!
+        @association = true
+        association_info = @model_class.reflect_on_association(@name) || fail("Association #{@name.inspect} does not exist for #{@model_class.inspect}.")
+        @multi = association_info.macro == :has_many
+        id_name = "#{@name.to_s.singularize}_id"
+        @schema_key = @multi ? id_name.pluralize.to_sym : id_name.to_sym
+      rescue ActiveRecord::NoDatabaseError
+        Rails.logger.warn('Warning: Compony could not auto-detect fields due to missing database. This is ok when running db:create.')
+      end
+    end
+  end
+end