compony 0.0.1

data/lib/compony/model_fields/base.rb

@@ -0,0 +1,63 @@
+module Compony
+  module ModelFields
+    class Base
+      attr_reader :name
+      attr_reader :model_class
+      attr_reader :schema_key
+      attr_reader :extra_attrs
+
+      def multi?
+        !!@multi
+      end
+
+      def association?
+        !!@association
+      end
+
+      def initialize(name, model_class, **extra_attrs)
+        @name = name.to_sym
+        @model_class = model_class
+        @schema_key = name
+        @extra_attrs = extra_attrs
+      end
+
+      # Use this to display the label for this field, e.g. for columns, forms etc.
+      def label
+        @model_class.human_attribute_name(@name)
+      end
+
+      # Use this to display the value for this field applied to data
+      def value_for(data, controller: nil, **_)
+        # Default behavior
+        return transform_and_join(data.send(@name), controller:)
+      end
+
+      # Used for auto-providing Schemacop schemas.
+      # Returns a proc that is meant for instance_exec within a Schemacop3 hash block
+      def schema_line
+        # Default behavior
+        local_schema_key = @schema_key # Capture schema_key as it will not be available within the lambda
+        return proc { obj? local_schema_key }
+      end
+
+      # Used in form helper.
+      # Given a simpleform instance, returns the corresponding input to be supplied to the view.
+      def simpleform_input(form, _component, **input_opts)
+        return form.input @name, **input_opts
+      end
+
+      protected
+
+      # If given a scalar, calls the block on the scalar. If given a list, calls the block on every member and joins the result with ",".
+      def transform_and_join(data, controller:, &transform_block)
+        if data.is_a?(Enumerable)
+          data = data.compact.map(&transform_block) if block_given?
+          return controller.helpers.safe_join(data.compact, ', ')
+        else
+          data = transform_block.call(data) if block_given?
+          return data
+        end
+      end
+    end
+  end
+end

data/lib/compony/model_fields/boolean.rb

@@ -0,0 +1,9 @@
+module Compony
+  module ModelFields
+    class Boolean < Base
+      def value_for(data, controller: nil, **_)
+        return transform_and_join(data.send(@name), controller:) { |el| I18n.t("compony.boolean.#{el}") }
+      end
+    end
+  end
+end

data/lib/compony/model_fields/currency.rb

@@ -0,0 +1,9 @@
+module Compony
+  module ModelFields
+    class Currency < Base
+      def value_for(data, controller: nil, **_)
+        return transform_and_join(data.send(@name), controller:) { |el| controller.helpers.number_to_currency(el) }
+      end
+    end
+  end
+end

data/lib/compony/model_fields/date.rb

@@ -0,0 +1,9 @@
+module Compony
+  module ModelFields
+    class Date < Base
+      def value_for(data, controller: nil, **_)
+        return transform_and_join(data.send(@name), controller:) { |el| el.nil? ? nil : I18n.l(el) }
+      end
+    end
+  end
+end

data/lib/compony/model_fields/datetime.rb

@@ -0,0 +1,9 @@
+module Compony
+  module ModelFields
+    class Datetime < Base
+      def value_for(data, controller: nil, **_)
+        return transform_and_join(data.send(@name), controller:) { |el| el.nil? ? nil : I18n.l(el) }
+      end
+    end
+  end
+end

data/lib/compony/model_fields/decimal.rb

@@ -0,0 +1,6 @@
+module Compony
+  module ModelFields
+    class Decimal < Base
+    end
+  end
+end

data/lib/compony/model_fields/float.rb

@@ -0,0 +1,6 @@
+module Compony
+  module ModelFields
+    class Float < Base
+    end
+  end
+end

data/lib/compony/model_fields/integer.rb

@@ -0,0 +1,6 @@
+module Compony
+  module ModelFields
+    class Integer < Base
+    end
+  end
+end

data/lib/compony/model_fields/phone.rb

@@ -0,0 +1,15 @@
+module Compony
+  module ModelFields
+    # Requires 'phonelib' gem
+    class Phone < Base
+      def initialize(...)
+        fail('Please include gem "phonelib" to use the :phone field type.') unless defined?(Phonelib)
+        super
+      end
+
+      def value_for(data, controller: nil, **_)
+        return transform_and_join(data.send(@name), controller:) { |el| Phonelib.parse(el).international }
+      end
+    end
+  end
+end

data/lib/compony/model_fields/rich_text.rb

@@ -0,0 +1,9 @@
+module Compony
+  module ModelFields
+    class RichText < Base
+      def simpleform_input(form, _component, **input_opts)
+        return form.input @name, **input_opts.merge(as: :rich_text_area)
+      end
+    end
+  end
+end

data/lib/compony/model_fields/string.rb

@@ -0,0 +1,6 @@
+module Compony
+  module ModelFields
+    class String < Base
+    end
+  end
+end

data/lib/compony/model_fields/text.rb

@@ -0,0 +1,6 @@
+module Compony
+  module ModelFields
+    class Text < Base
+    end
+  end
+end

data/lib/compony/model_fields/time.rb

@@ -0,0 +1,6 @@
+module Compony
+  module ModelFields
+    class Time < Base
+    end
+  end
+end

data/lib/compony/model_mixin.rb

@@ -0,0 +1,88 @@
+module Compony
+  module ModelMixin
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :fields, default: {}
+      class_attribute :feasibility_preventions, default: {}
+      class_attribute :primary_key_type_key, default: :integer
+
+      class_attribute :autodetect_feasibilities_completed, default: false
+    end
+
+    class_methods do
+      # DSL method, defines a new field which will be translated and can be added to field groups
+      # For virtual attributes, you must pass a type explicitely, otherwise it's auto-infered.
+      def field(name, type, **extra_attrs)
+        name = name.to_sym
+        self.fields = fields.dup
+        fields[name] = Compony.model_field_class_for(type.to_s.camelize).new(name, self, **extra_attrs)
+      end
+
+      # DSL method, sets the primary key type
+      def primary_key_type(new_type)
+        unless %i[integer string].include?(new_type.to_sym)
+          fail("#{self} is declaring primary_key_type as #{new_type.inspect} but only :integer and :string are supported at this time.")
+        end
+        self.primary_key_type_key = new_type.to_sym
+      end
+
+      # DSL method, part of the Feasibility feature
+      # Block must return `false` if the action should be prevented.
+      def prevent(action_name, message, &block)
+        self.feasibility_preventions = feasibility_preventions.dup # Prevent cross-class contamination
+        feasibility_preventions[action_name.to_sym] ||= []
+        feasibility_preventions[action_name.to_sym] << MethodAccessibleHash.new(action_name:, message:, block:)
+      end
+
+      # DSL method, part of the Feasibility feature
+      # Skips autodetection of feasibilities
+      def skip_autodetect_feasibilities
+        self.autodetect_feasibilities_completed = true
+      end
+
+      def autodetect_feasibilities!
+        return if autodetect_feasibilities_completed
+        # Add a prevention that reflects the `has_many` `dependent' properties. Avoids that users can press buttons that will result in a failed destroy.
+        reflect_on_all_associations.select { |assoc| %i[restrict_with_exception restrict_with_error].include? assoc.options[:dependent] }.each do |assoc|
+          prevent(:destroy, I18n.t('compony.feasibility.has_dependent_models', dependent_class: I18n.t(assoc.klass.model_name.plural.humanize))) do
+            public_send(assoc.name).any?
+          end
+        end
+        self.autodetect_feasibilities_completed = true
+      end
+    end
+
+    # Retrieves feasibility for the given instance
+    # Calling this with an invalid action name will always return true.
+    def feasible?(action_name, recompute: false)
+      action_name = action_name.to_sym
+      @feasibility_messages ||= {}
+      # Abort if check has already run and recompute is false
+      if @feasibility_messages[action_name].nil? || recompute
+        # Lazily autodetect feasibilities
+        self.class.autodetect_feasibilities!
+        # Compute feasibility and gather messages
+        @feasibility_messages[action_name] = []
+        feasibility_preventions[action_name]&.each do |prevention|
+          if instance_exec(&prevention.block)
+            @feasibility_messages[action_name] << prevention.message
+          end
+        end
+      end
+      return @feasibility_messages[action_name].none?
+    end
+
+    def feasibility_messages(action_name)
+      action_name = action_name.to_sym
+      feasible?(action_name) if @feasibility_messages&.[](action_name).nil? # If feasibility check hasn't been performed yet for this action, perform it now
+      return @feasibility_messages[action_name]
+    end
+
+    def full_feasibility_messages(action_name)
+      text = feasibility_messages(action_name).join(', ').upcase_first
+      text += '.' if text.present?
+      return text
+    end
+  end
+end

data/lib/compony/request_context.rb

@@ -0,0 +1,45 @@
+module Compony
+  # @api description
+  # This encapsulates useful methods for accessing data within a request.
+  class RequestContext < Dslblend::Base
+    # Allow explicit access to the controller object. All controller methods are delgated.
+    attr_reader :controller
+    attr_reader :helpers
+    attr_reader :local_assigns
+
+    def initialize(component, controller, *additional_providers, helpers: nil, locals: {})
+      # DSL provider is this class, controller is an additional provider, main provider should be the component
+      # Note: we have to manually set the main provider here as the auto-detection sets it to the VerbDsl instance around the block,
+      #       leading to undesired caching effects (e.g. components being re-used, even if the comp_opts have changed)
+      @controller = controller
+      @helpers = helpers || controller.helpers
+      @local_assigns = locals.with_indifferent_access
+      super(@helpers, @controller, *additional_providers, main_provider: component)
+    end
+
+    def evaluate_with_backfire(&)
+      evaluate(backfire_vars: true, &)
+    end
+
+    def component
+      @_main_provider
+    end
+
+    # Explicit accessor to this object. As Dslblend hides where a method comes from, this makes code modifying the request context more explicit.
+    # This is for instance useful when a component wishes to extend the request context with a module in order to define methods directly on the context.
+    def request_context
+      self
+    end
+
+    # Provide access to local assigns as if it were a Rails context
+    def method_missing(method, *args, **kwargs, &)
+      return @local_assigns[method] if @local_assigns.key?(method)
+      return super
+    end
+
+    def respond_to_missing?(method, include_all)
+      return true if @local_assigns.key?(method)
+      return super
+    end
+  end
+end

data/lib/compony/version.rb

@@ -0,0 +1,11 @@
+module Compony
+  module Version
+    MAJOR = 0
+    MINOR = 0
+    PATCH = 1
+
+    EDGE = false
+
+    LABEL = [MAJOR, MINOR, PATCH, EDGE ? 'edge' : nil].compact.join('.')
+  end
+end

data/lib/compony/view_helpers.rb

@@ -0,0 +1,36 @@
+module Compony
+  # @api description
+  # Methods in this module are available in content blocks and Rails views.
+  # 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
+    # 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, model_or_family_name_or_cst, *link_args, label_opts: {}, **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)
+    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)
+    end
+  end
+end

data/lib/compony.rb

@@ -0,0 +1,268 @@
+# @api description
+# Root module, containing confguration and pure helpers. For
+# 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
+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 [Class] 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
+  end
+
+  # Setter for the global field namespaces. This allows you to implement custom
+  # Fields, be it new ones or overrides for existing Compony model fields.
+  # Must give an array of strings of namespaces that contain field classes named after
+  # the field type. The array is queried in order, if the first namespace does not
+  # contain the class we're looking for, the next is considered and so on.
+  # The classes defined in the namespace must inherit from Compony::ModelFields::Base
+  def self.model_field_namespaces=(model_field_namespaces)
+    @model_field_namespaces = model_field_namespaces
+  end
+
+  # Setter for the name of the Rails `before_action` that should be called to
+  # ensure that users are authenticated before accessing the component. For
+  # instance, implement a method `def enforce_authentication` in your
+  # `ApplicationController`. In the method, make sure the user has a session and
+  # redirect to the login page if they don't. <br> The action must be accessible
+  # by {ComponyController} and the easiest way to achieve this is to implement
+  # the action in your `ApplicationController`. If this is never called,
+  # authentication is disabled.
+  def self.authentication_before_action=(authentication_before_action)
+    @authentication_before_action = authentication_before_action.to_sym
+  end
+
+  ##########=====-------
+  # 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
+  end
+
+  # Getter for the global field namespaces.
+  # @see Compony#model_field_namespaces= Explanation of model_field_namespaces (documented in the corresponding setter)
+  def self.model_field_namespaces
+    return @model_field_namespaces ||= ['Compony::ModelFields']
+  end
+
+  # Getter for the name of the Rails `before_action` that enforces authentication.
+  # @see Compony#authentication_before_action= Explanation of authentication_before_action (documented in the corresponding setter)
+  def self.authentication_before_action
+    @authentication_before_action
+  end
+
+  ##########=====-------
+  # Application-wide available pure helpers
+  ##########=====-------
+
+  # Generates a Rails path to a component. Examples: `Compony.path(:index, :users)`, `Compony.path(:show, User.first)`
+  # @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 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, model_or_family_name_or_cst, *args_for_path_helper, **kwargs_for_path_helper)
+    # Extract model if any, to get the ID
+    kwargs_for_path_helper.merge!(id: model_or_family_name_or_cst.id) if model_or_family_name_or_cst.respond_to?(:model_name)
+    return Rails.application.routes.url_helpers.send(
+      "#{path_helper_name(comp_name_or_cst, model_or_family_name_or_cst)}_path",
+      *args_for_path_helper,
+      **kwargs_for_path_helper
+    )
+  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)
+  end
+
+  # As above but fails if none found
+  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(
+      "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, 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, model_or_family_name_or_cst, name = nil)
+    [name.presence, comp_name_or_cst.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 [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 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 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
+  # @todo add doc for feasibility
+  def self.button(comp_name_or_cst,
+                  model_or_family_name_or_cst,
+                  label_opts: nil,
+                  params: nil,
+                  feasibility_action: nil,
+                  feasibility_target: 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
+    target_comp_instance = Compony.comp_class_for!(comp_name_or_cst, model_or_family_name_or_cst).new(data: model)
+    feasibility_action ||= button_defaults[:feasibility_action] || comp_name_or_cst.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, **params),
+      visible: ->(controller) { target_comp_instance.standalone_access_permitted_for?(controller) }
+    }
+    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]
+  end
+
+  # Given a family name or a model-like class, this returns the suitable family name as String.
+  # @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.family_name_for(model_or_family_name_or_cst)
+    if model_or_family_name_or_cst.respond_to?(:model_name)
+      return model_or_family_name_or_cst.model_name.plural
+    else
+      return model_or_family_name_or_cst.to_s.underscore
+    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.
+  # @todo document params
+  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 do |key, _new_value|
+      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)
+    @model_field_namespaces.each do |model_field_namespace|
+      model_field_namespace = model_field_namespace.constantize if model_field_namespace.is_a?(::String)
+      if model_field_namespace.const_defined?(constant, false)
+        return model_field_namespace.const_get(constant, false)
+      end
+    end
+    fail("No `model_field_namespace` implements ...::#{constant}. Configured namespaces: #{Compony.model_field_namespaces.inspect}")
+  end
+end
+
+require 'cancancan'
+require 'dslblend'
+require 'dyny'
+require 'request_store'
+require 'schemacop'
+require 'simple_form'
+
+require 'compony/engine'
+require 'compony/model_fields/base'
+require 'compony/model_fields/association'
+require 'compony/model_fields/anchormodel'
+require 'compony/model_fields/boolean'
+require 'compony/model_fields/currency'
+require 'compony/model_fields/date'
+require 'compony/model_fields/datetime'
+require 'compony/model_fields/decimal'
+require 'compony/model_fields/float'
+require 'compony/model_fields/integer'
+require 'compony/model_fields/phone'
+require 'compony/model_fields/rich_text'
+require 'compony/model_fields/string'
+require 'compony/model_fields/text'
+require 'compony/model_fields/time'
+require 'compony/component_mixins/default/standalone'
+require 'compony/component_mixins/default/standalone/standalone_dsl'
+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/component'
+require 'compony/components/button'
+require 'compony/components/form'
+require 'compony/components/with_form'
+require 'compony/components/resourceful/new'
+require 'compony/components/resourceful/edit'
+require 'compony/components/resourceful/destroy'
+require 'compony/method_accessible_hash'
+require 'compony/model_mixin'
+require 'compony/request_context'
+require 'compony/version'
+require 'compony/view_helpers'
+require 'compony/controller_mixin'

data/lib/generators/component/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generate a single Compony component
+
+Example:
+    bin/rails generate component Users::New
+
+    This will create:
+        app/components/users/new.rb

data/lib/generators/component/component_generator.rb

@@ -0,0 +1,14 @@
+class ComponentGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path('templates', __dir__)
+
+  def add_component
+    segments = name.underscore.split('/')
+    fail('NAME must be of the form Family::ComponentName or family/component_name') if segments.size != 2
+    @family, @comp = segments
+    @family = @family.pluralize # Force plural
+    @family_cst = @family.camelize.pluralize # Force plural
+    @comp_cst = @comp.camelize # Tolerate singular and plural
+
+    template 'component.rb.erb', "app/components/#{@family}/#{@comp}.rb"
+  end
+end

data/lib/generators/component/templates/component.rb.erb

@@ -0,0 +1,4 @@
+class Components::<%= @family_cst %>::<%= @comp_cst %> < Compony::Component
+  setup do
+  end
+end