feature_pack 0.7.0 → 0.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bd71ce9bce49e1aeb7eab0f90082368e855a4c008f2e16428e5471c2a42db9f4
-  data.tar.gz: ddd54c8b5bc72def245c0d580d72914121aca811cda1debb56e81d43f6af1ad6
+  metadata.gz: 102101eb87f4153fd1db6cdd46f15bf1776912773498a1f585db49e7a6be707d
+  data.tar.gz: a3492ed0b1add63f95a171964c2e688f9d94d351d18112c2961aabcb1c80b845
 SHA512:
-  metadata.gz: f9772f47ad2adf747b7086203a9d8fa4e3d817c80eba21d8a22e978faa11fa1861a5134dceb11364f2748a1ca2f2654d4a3d5d6063d73bbf93f463ba8182a5a3
-  data.tar.gz: 1957dc76a52fc033ba7b8793d2d466fb4465da07c57b066c4ca441d3b5b5b4b3512f8f29272df378ab0b54bc5e7a6bb25a21f72773724552b81c4f0e365ec158
+  metadata.gz: d959f7066efab1bb4371914ad61689384d4c6d9a25c4bbc57a0982f14c6cb694c7025aa5e81557790e52327e6112c6ef28cac5e36612abcfaf01f432d5fe01f1
+  data.tar.gz: f6e1c3c5bd1518732d146567446b4a36b4f4812605425c7ee476c0951685ab97f1ed4f4a87d91defbfb0b876b4428620a7fe28d3737a09b26142b2ad72671c9a

data/README.md

@@ -1,91 +1,297 @@
 # Feature Pack Gem
-Organizes and sets up the architecture of micro-applications within a Ruby On Rails application, enabling the segregation of code, management, and isolation of functionalities, which can be developed, tested, and maintained independently of each other.
 
-## Code and Folder Structure
+[![Gem Version](https://badge.fury.io/rb/feature_pack.svg)](https://badge.fury.io/rb/feature_pack)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-### Group
-A group is a collection of related features. Groups are represented as directories in the `app/feature_packs` folder. Each group contains a `_group_space` directory that holds group-level views and JavaScript files. Group directories follow this naming pattern:
+Feature Pack organizes and sets up the architecture of micro-applications within a Ruby on Rails application, enabling the segregation of code, management, and isolation of functionalities. Features can be developed, tested, and maintained independently of each other.
 
-#### Naming Convention
-Sample: `group_departments-100100_human_resources`
+## Installation
 
-`group_` prefix is followed by the group identification (required)
-`departments-100100` between `group_` and class name, exists only for organization purposes. The bounds are `group_` and next underscore `_`
-`human_resources` class name of the group (required)
+Add this line to your application's Gemfile:
 
-#### Note worthy
-Group name is the same as the class name. Its used internally in the backend code.
-The 'Name' within the manifest file (Group.manifest[:name]) is the name to be shown in the user interface.
+```ruby
+gem 'feature_pack'
+```
 
-The `_group_space` directory contains:
+And then execute:
 
-- `views/` - Views of the group
-#### Common Files in _group_space/views
+```bash
+bundle install
+```
 
-The `_group_space/views` directory typically contains these common files:
+## Setup
 
+Add to your `config/application.rb`:
+
+```ruby
+# After Bundler.require
+require 'feature_pack'
+FeaturePack.setup
 ```
-_group_space/views/
-├── index.html.slim    # Default view for the group
-└── partials/
-    └── _header.html.slim # Base header template for the group
-    └── _footer.html.slim # Base footer template for the group
-```
-Can have more views and partials, depending on the defined on `controller.rb` but these are the most common ones.
 
-- `javascript/` - Group-level JavaScript modules shared across features
-- `controller.rb` - Base controller class for the group's features
-- `routes.rb` - The routes files come with the default `index` action/view.
+## Concepts
+
+### Groups
+Groups are collections of related features. They provide:
+- Shared layouts and partials
+- Common base controller functionality
+- Namespace organization
+- Shared JavaScript modules
+
+### Features
+Features are individual functionalities within a group. They provide:
+- Independent controllers and views
+- Isolated routes
+- Feature-specific JavaScript
+- Complete MVC structure
+
+## Usage
 
-#### How implement a new Group
+### Creating a New Group
+
+```bash
+rails generate feature_pack:add_group human_resources
+```
+
+This creates the following structure:
 ```
-rails generate feature_pack:add_gruop <group_name>
+app/feature_packs/
+└── group_YYMMDD_human_resources/
+    └── _group_space/
+        ├── controller.rb
+        ├── manifest.yaml
+        ├── routes.rb
+        ├── javascript/
+        └── views/
+            ├── index.html.slim
+            └── partials/
+                ├── _header.html.slim
+                └── _footer.html.slim
 ```
 
-### Feature
-A feature is a single feature that can be added to a group. Feature naming patter is the same of group, but without the `group_` prefix.
+### Creating a New Feature
 
-#### Feature Routes
-Every feature has a default route, which is the `index` action/view. If the feature has more than the default `index` action/view, the routes are defined in the `routes.rb` file.
+```bash
+rails generate feature_pack:add_feature human_resources/employees
+```
 
-#### How implement a new feature
+This creates:
 ```
-rails generate feature_pack:add_feature <group_name>/<feature_name>
+app/feature_packs/
+└── group_YYMMDD_human_resources/
+    └── feature_YYMMDD_employees/
+        ├── controller.rb
+        ├── manifest.yaml
+        ├── routes.rb
+        ├── doc/
+        │   └── readme.md
+        ├── javascript/
+        ├── queries/
+        └── views/
+            ├── index.html.slim
+            └── partials/
+                ├── _header.html.slim
+                └── _footer.html.slim
 ```
 
-#### Helpers
+## Code Structure
+
+### Naming Convention
+
+#### Groups
+Format: `group_<id>_<name>`
+- `group_` - Required prefix
+- `<id>` - Unique identifier (typically YYMMDD format)
+- `<name>` - Group name in snake_case
+
+Example: `group_241209_human_resources`
+
+#### Features
+Format: `feature_<id>_<name>`
+- `feature_` - Required prefix
+- `<id>` - Unique identifier (typically YYMMDD format)
+- `<name>` - Feature name in snake_case
 
+Example: `feature_241209_employees`
+
+### Directory Structure
+
+#### Group Space (`_group_space`)
+Contains group-level resources:
+- `controller.rb` - Base controller for all features in the group
+- `manifest.yaml` - Group configuration
+- `routes.rb` - Group-level routes
+- `views/` - Shared views and layouts
+- `javascript/` - Shared JavaScript modules
+
+#### Feature Directory
+Contains feature-specific resources:
+- `controller.rb` - Feature controller
+- `manifest.yaml` - Feature configuration
+- `routes.rb` - Feature routes
+- `views/` - Feature views
+- `javascript/` - Feature-specific JavaScript
+- `queries/` - Database queries
+- `doc/` - Feature documentation
+
+## Controllers
+
+### Group Controller
+```ruby
+class FeaturePack::HumanResourcesController < FeaturePack::GroupController
+  # Group-wide functionality
+end
+```
+
+### Feature Controller
 ```ruby
-# Application Helper
-def feature_pack_group_path(group_name, *params) = send("feature_pack_#{group_name}_path".to_sym, *params)
-def feature_pack_path(group_name, feature_name, *params) = send("feature_pack_#{group_name}_#{feature_name}_path".to_sym, *params)
+class FeaturePack::HumanResources::EmployeesController < FeaturePack::HumanResourcesController
+  def index
+    # Feature-specific logic
+  end
+end
 ```
 
+## Routes
+
+Routes are automatically configured based on manifest files:
+
+```yaml
+# Group manifest.yaml
+url: /hr
+name: Human Resources
+
+# Feature manifest.yaml
+url: /employees
+name: Employees Management
+```
+
+This generates routes like:
+- `/hr` - Group index
+- `/hr/employees` - Feature index
+
 ## Helpers
 
-### Using the `feature_pack_group_path` and `feature_pack_path` Helpers
+### Path Helpers
+
+```ruby
+# Group path
+feature_pack_group_path(:human_resources)
+# => "/hr"
+
+# Feature path
+feature_pack_path(:human_resources, :employees)
+# => "/hr/employees"
+
+# With parameters
+feature_pack_path(:human_resources, :employees, id: 1)
+# => "/hr/employees?id=1"
+```
+
+### Controller Variables
+
+Available in controllers and views:
+- `@group` - Current group object
+- `@feature` - Current feature object (not available in group controller)
+
+## View Hierarchy
+
+Views are resolved in the following order:
+1. Feature-specific views
+2. Group-shared views
+3. Application default views
+
+### Partials
+Header and footer partials follow a fallback pattern:
+1. Feature's `views/partials/_header.html.slim`
+2. Group's `views/partials/_header.html.slim`
+3. Application's default header
+
+## JavaScript Integration
+
+JavaScript files are automatically discovered and can be referenced:
+
+```ruby
+# In views
+javascript_include_tag @group.javascript_module('shared')
+javascript_include_tag @feature.javascript_module('employees')
+```
+
+## Advanced Configuration
+
+### Manifest Files
+
+Group manifest (`_group_space/manifest.yaml`):
+```yaml
+url: /hr
+name: Human Resources
+const_aliases:
+  - employee_model: Employee
+  - department_model: Department
+```
+
+Feature manifest:
+```yaml
+url: /employees
+name: Employees Management
+const_aliases:
+  - service: EmployeeService
+```
+
+### Const Aliases
+
+Access aliased constants:
+```ruby
+# In controllers
+@group.employee_model  # => Employee
+@feature.service       # => FeaturePack::HumanResources::Employees::EmployeeService
+```
+
+## Best Practices
+
+1. **Group Organization**: Group related features that share common functionality
+2. **Naming**: Use descriptive snake_case names for groups and features
+3. **Isolation**: Keep features independent and loosely coupled
+4. **Shared Resources**: Place common code in group space
+5. **Documentation**: Document each feature in its `doc/readme.md`
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Group/Feature Not Found**
+   - Ensure proper naming convention
+   - Run `FeaturePack.setup` after adding new groups/features
+   - Check manifest files exist
+
+2. **Routes Not Working**
+   - Verify manifest.yaml has correct URL configuration
+   - Check routes.rb files exist
+   - Restart Rails server after changes
+
+3. **Views Not Rendering**
+   - Check view file extensions (.html.slim, .html.erb, etc.)
+   - Verify view paths in controller
+   - Check for typos in view names
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## License
 
-The `feature_pack_group_path` and `feature_pack_path` helpers are used to generate URLs for specific groups and features within the feature package system.
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
 
-- `feature_pack_group_path(group, *params)`: Generates the path for a specific group. The `group` parameter should be an object representing the desired group. Additional parameters can be passed to specify more details in the URL.
-  
-  **Usage example:**
-  ```ruby
-  # Assuming `group` is a valid group name in symbol
-  group_url = feature_pack_group_path(:group_name)
-  ```
+## Author
 
-- `feature_pack_path(group, feature, *params)`: Generates the path for a specific feature within a group. The `group` and `feature` parameters should be symbols of group and feature name, respectively. Additional parameters can be passed to specify more details in the URL.
-  
-  **Usage example:**
-  ```ruby
-  # Assuming `group` and `feature` are valid objects
-  feature_url = feature_pack_path(:my_group, :my_feature)
-  ```
+Gedean Dias - gedean.dias@gmail.com
 
-These helpers are useful for maintaining consistency and clarity when generating URLs within the application, ensuring that routes are correctly constructed based on the provided group and feature names.
+## Links
 
-## Variables
-Current group and feature are available in the controller (so as in the views too) as `@group` and `@feature` variables.
-@feature variable is not available in the group controller.
-@group variable is available in the group controller and in the its features controllers.
+- [GitHub Repository](https://github.com/gedean/feature_pack)
+- [RubyGems](https://rubygems.org/gems/feature_pack)
+- [Bug Reports](https://github.com/gedean/feature_pack/issues)

data/lib/feature_pack/controller.rb

@@ -1,42 +1,58 @@
+# Base controller for all feature controllers
+# Handles the setup of features, views, and layouts
 class FeaturePack::Controller < ApplicationController
-  before_action :set_group_and_feature
-  before_action :set_view_lookup_context_prefix
-  before_action :set_layout_paths
+  prepend_before_action :setup_feature
 
+  # Default index action
   def index; end
 
   private
 
+  # Main setup method that configures the feature environment
+  def setup_feature
+    set_group_and_feature
+    set_view_lookup_context_prefix
+    set_layout_paths
+  end
+
+  # Extracts and sets the group and feature from the controller path
   def set_group_and_feature
-    group_name, feature_name = params['controller'].delete_prefix('feature_pack/').split('/').map(&:to_sym)
-    @group = FeaturePack.group group_name
-    @feature = FeaturePack.feature group_name, feature_name
+    group_name, feature_name = params['controller']
+      .delete_prefix('feature_pack/')
+      .split('/')
+      .map(&:to_sym)
+    
+    @group = FeaturePack.group(group_name)
+    @feature = FeaturePack.feature(group_name, feature_name)
+    
+    raise FeaturePack::Error::NoGroup, "Group '#{group_name}' not found" if @group.nil?
+    raise FeaturePack::Error::NoDataError, "Feature '#{feature_name}' not found in group '#{group_name}'" if @feature.nil?
   end
 
+  # Configures the view lookup path to include feature-specific views
   def set_view_lookup_context_prefix
-    unless lookup_context.prefixes.include?(@feature.views_relative_path)
-      lookup_context.prefixes.prepend(@feature.views_relative_path)
-    end
+    return if lookup_context.prefixes.include?(@feature.views_relative_path)
+
+    lookup_context.prefixes.prepend(@feature.views_relative_path)
   end
 
+  # Sets up header and footer layout paths with fallback logic
+  # Search order:
+  # 1. Feature-specific partials
+  # 2. Group-level partials (fallback)
+  # 3. Application default (if neither exists)
   def set_layout_paths
-=begin
-    Header/Footer Lookup order
-
-    - Feature dir/_partials, if not exists
-      - Fallback to Group, if not exists
-        - Fallback to Application's default header/footer
-=end
-
     feature_partials_path = @feature.views_relative_path.join('partials')
     group_partials_path = @feature.group.views_path.concat('/partials')
 
+    # Set header layout
     if template_exists?('header', feature_partials_path, true)
       @header_layout_path = @feature.view('partials/header')
     elsif template_exists?('header', group_partials_path, true)
       @header_layout_path = @feature.group.view('partials/header')
     end
 
+    # Set footer layout
     if template_exists?('footer', feature_partials_path, true)
       @footer_layout_path = @feature.view('partials/footer')
     elsif template_exists?('footer', group_partials_path, true)

data/lib/feature_pack/error.rb

@@ -1,6 +1,7 @@
 module FeaturePack::Error
   class NoDataError < StandardError
-	end
+  end
+  
   class NoGroup < StandardError
-	end
+  end
 end

data/lib/feature_pack/feature_pack_routes.rb

@@ -1,14 +1,25 @@
+# Routes configuration for FeaturePack
+# This file is loaded by Rails routes to set up all group and feature routes
+
 FeaturePack.groups.each do |group|
+  # Configure group-level routes
   scope group.manifest[:url], as: group.name do
-    raise "Group '#{group.name}' routes file not found in #{group.metadata_path}" if group.routes_file.nil?
+    if group.routes_file.nil?
+      raise FeaturePack::Error::NoDataError, 
+            "Group '#{group.name}' routes file not found in #{group.metadata_path}"
+    end
 
     draw(group.routes_file)
   end
 
+  # Configure feature-level routes within the group namespace
   namespace group.name, path: group.manifest[:url] do
     group.features.each do |feature|
       scope feature.manifest[:url], as: feature.name do
-        raise "Feature '#{feature.name}' routes file not found in #{feature.routes_file}" if feature.routes_file.nil?
+        if feature.routes_file.nil?
+          raise FeaturePack::Error::NoDataError, 
+                "Feature '#{feature.name}' routes file not found in #{feature.routes_file_path}"
+        end
 
         draw(feature.routes_file)
       end

data/lib/feature_pack/group_controller.rb

@@ -1,31 +1,44 @@
+# Base controller for all group controllers
+# Handles the setup of groups and their views
 class FeaturePack::GroupController < ApplicationController
-  before_action :set_group
-  before_action :set_view_lookup_context_prefix
-  before_action :set_layout_paths
-
+  prepend_before_action :setup_group
+  
+  # Default index action
   def index; end
 
   private
 
+  # Main setup method that configures the group environment
+  def setup_group
+    set_group
+    set_view_lookup_context_prefix
+    set_layout_paths
+  end
+
+  # Extracts and sets the group from the controller path
   def set_group
     group_name = params[:controller].split('/')[1].to_sym
     @group = FeaturePack.group(group_name)
+    
+    raise FeaturePack::Error::NoGroup, "Group '#{group_name}' not found" if @group.nil?
   end
 
+  # Configures the view lookup path to include group-specific views
   def set_view_lookup_context_prefix
-    unless lookup_context.prefixes.include?(@group.views_path)
-      lookup_context.prefixes.prepend(@group.views_path)
-    end
+    return if lookup_context.prefixes.include?(@group.views_path)
+
+    lookup_context.prefixes.prepend(@group.views_path)
   end
 
+  # Sets up header and footer layout paths for the group
   def set_layout_paths
-    patials_path = @group.views_path.concat('/partials')
+    partials_path = @group.views_path.concat('/partials')
 
-    if template_exists?('header', patials_path, true)
+    if template_exists?('header', partials_path, true)
       @header_layout_path = @group.view('partials/header')
     end
 
-    if template_exists?('footer', patials_path, true)
+    if template_exists?('footer', partials_path, true)
       @footer_layout_path = @group.view('partials/footer')
     end
   end

data/lib/feature_pack.rb

@@ -1,12 +1,18 @@
 require 'active_support/all'
 
+# FeaturePack module provides a way to organize Rails applications into
+# groups and features, enabling better code organization and isolation
 module FeaturePack
+  # Pattern constants for identifying groups and features
   GROUP_ID_PATTERN = /^group_.*?_/.freeze
   FEATURE_ID_PATTERN = /^feature_.*?_/.freeze
+  
+  # Directory and file name constants
   GROUP_SPACE_DIRECTORY = '_group_space'.freeze
   MANIFEST_FILE_NAME = 'manifest.yaml'.freeze
   CONTROLLER_FILE_NAME = 'controller.rb'.freeze
 
+  # Attribute readers that will be dynamically defined
   ATTR_READERS = %i[
     path
     features_path
@@ -17,41 +23,113 @@ module FeaturePack
     javascript_files_paths
   ].freeze
 
-  def self.setup()
-    raise 'FeaturePack already setup!' if defined?(@@setup_executed_flag)
+  class << self
+    # Sets up the FeaturePack system
+    # This method should be called once during Rails initialization
+    def setup
+      raise 'FeaturePack already setup!' if defined?(@@setup_executed_flag)
 
-    @@path = Pathname.new(__dir__)
-    load @@path.join('feature_pack/error.rb')
+      initialize_paths
+      load_dependencies
+      discover_groups
+      discover_features
+      finalize_setup
+    end
 
-    @@features_path = Pathname.new(Rails.root.join('app/feature_packs'))
-    raise "Invalid features_path: '#{@@features_path}'" if @@features_path.nil?
-    raise "Inexistent features_path: '#{@@features_path}'" unless Dir.exist?(@@features_path)
+    # Finds a group by name
+    # @param group_name [Symbol] The name of the group
+    # @return [OpenStruct, nil] The group object or nil if not found
+    def group(group_name)
+      @@groups.find { |g| g.name.eql?(group_name) }
+    end
 
-    @@groups_controllers_paths = []
-    @@features_controllers_paths = []
+    # Finds a feature within a group
+    # @param group_name [Symbol] The name of the group
+    # @param feature_name [Symbol] The name of the feature
+    # @return [OpenStruct, nil] The feature object or nil if not found
+    def feature(group_name, feature_name)
+      requested_group = group(group_name)
+      return nil if requested_group.nil?
+      
+      requested_group.feature(feature_name)
+    end
 
-    @@ignored_paths = Dir.glob("#{@@features_path}/[!]*/")
+    private
 
-    @@javascript_files_paths = Dir.glob("#{@@features_path}/[!_]*/**/*.js")
-      .map { |js_path| js_path.sub(/^#{Regexp.escape(@@features_path.to_s)}\//, '') }.to_a
+    def initialize_paths
+      @@path = Pathname.new(__dir__)
+      @@features_path = Pathname.new(Rails.root.join('app/feature_packs'))
+      
+      validate_features_path!
+      
+      @@groups_controllers_paths = []
+      @@features_controllers_paths = []
+      @@ignored_paths = Dir.glob("#{@@features_path}/[!]*/")
+      @@javascript_files_paths = discover_javascript_files
+    end
 
-    ATTR_READERS.each { |attr| define_singleton_method(attr) { class_variable_get("@@#{attr}") } }
+    def load_dependencies
+      load @@path.join('feature_pack/error.rb')
+    end
 
-    @@ignored_paths << @@path.join('feature_pack/feature_pack_routes.rb')
+    def validate_features_path!
+      raise "Invalid features_path: '#{@@features_path}'" if @@features_path.nil?
+      raise "Features path does not exist: '#{@@features_path}'" unless Dir.exist?(@@features_path)
+    end
 
-    # raise "No Groups found in: '#{@@features_path}'" if Dir.glob("#{@@features_path}/[!_]*/").empty?
+    def discover_javascript_files
+      Dir.glob("#{@@features_path}/[!_]*/**/*.js")
+        .map { |js_path| js_path.sub(/^#{Regexp.escape(@@features_path.to_s)}\//, '') }
+        .to_a
+    end
 
-    @@groups = Dir.glob("#{@@features_path}/[!_]*/").map do |group_path|
+    def finalize_setup
+      ATTR_READERS.each { |attr| define_singleton_method(attr) { class_variable_get("@@#{attr}") } }
+      @@ignored_paths << @@path.join('feature_pack/feature_pack_routes.rb')
+      @@setup_executed_flag = true
+    end
+
+    def discover_groups
+      @@groups = Dir.glob("#{@@features_path}/[!_]*/").map do |group_path|
+        build_group(group_path)
+      end
+    end
+
+    def build_group(group_path)
       relative_path = Pathname.new(group_path)
       base_path = File.basename(group_path, File::SEPARATOR)
+      
+      validate_group_id!(base_path)
+      
+      routes_file = find_group_routes_file(group_path, base_path)
+      @@groups_controllers_paths << File.join(group_path, GROUP_SPACE_DIRECTORY, CONTROLLER_FILE_NAME)
+      
+      group = create_group_struct(base_path, group_path, relative_path, routes_file)
+      setup_group_aliases(group)
+      define_group_methods(group)
+      
+      group
+    end
 
-      # On route draw call, the extension is ignored
-      routes_file = File.exist?(File.join(group_path, GROUP_SPACE_DIRECTORY, 'routes.rb')) ? File.join(base_path, GROUP_SPACE_DIRECTORY, 'routes') : nil
+    def validate_group_id!(base_path)
+      if base_path.scan(GROUP_ID_PATTERN).empty?
+        raise "Group '#{base_path}' does not have a valid ID. Expected format: group_<id>_<name>"
+      end
+    end
 
-      @@groups_controllers_paths << File.join(group_path, GROUP_SPACE_DIRECTORY, CONTROLLER_FILE_NAME)
+    def find_group_routes_file(group_path, base_path)
+      routes_path = File.join(group_path, GROUP_SPACE_DIRECTORY, 'routes.rb')
+      File.exist?(routes_path) ? File.join(base_path, GROUP_SPACE_DIRECTORY, 'routes') : nil
+    end
 
-      raise "Group '#{base_path}' does not have a valid ID" if base_path.scan(GROUP_ID_PATTERN).empty?
-      group = OpenStruct.new(
+    def create_group_struct(base_path, group_path, relative_path, routes_file)
+      manifest_path = File.join(group_path, GROUP_SPACE_DIRECTORY, MANIFEST_FILE_NAME)
+      
+      unless File.exist?(manifest_path)
+        raise "Manifest file not found for group '#{base_path}' at #{manifest_path}"
+      end
+      
+      OpenStruct.new(
         id: base_path.scan(GROUP_ID_PATTERN).first.delete_suffix('_'),
         name: base_path.gsub(GROUP_ID_PATTERN, '').to_sym,
         metadata_path: @@features_path.join(group_path, GROUP_SPACE_DIRECTORY),
@@ -59,82 +137,139 @@ module FeaturePack
         base_dir: File.basename(relative_path, File::SEPARATOR),
         routes_file: routes_file,
         features: [],
-        manifest: YAML.load_file(File.join(group_path, GROUP_SPACE_DIRECTORY, MANIFEST_FILE_NAME)).deep_symbolize_keys
+        manifest: load_manifest(manifest_path)
       )
+    end
+
+    def load_manifest(manifest_path)
+      YAML.load_file(manifest_path).deep_symbolize_keys
+    rescue => e
+      raise "Failed to load manifest at #{manifest_path}: #{e.message}"
+    end
 
+    def setup_group_aliases(group)
       group.manifest.fetch(:const_aliases, []).each do |alias_data|
         alias_method_name, alias_const_name = alias_data.first
-        group.define_singleton_method(alias_method_name) { "FeaturePack::#{group.name.name.camelize}::#{alias_const_name}".constantize }
+        group.define_singleton_method(alias_method_name) do
+          "FeaturePack::#{group.name.to_s.camelize}::#{alias_const_name}".constantize
+        end
       end
+    end
 
-      def group.feature(feature_name) = features.find { |p| p.name.eql?(feature_name) }
-      def group.views_path = "#{base_dir}/#{GROUP_SPACE_DIRECTORY}/views"
-      def group.view(view_name) = "#{base_dir}/#{GROUP_SPACE_DIRECTORY}/views/#{view_name}"
-      def group.javascript_module(javascript_file_name) = "#{base_dir}/#{GROUP_SPACE_DIRECTORY}/javascript/#{javascript_file_name}"
-
-      group
+    def define_group_methods(group)
+      def group.feature(feature_name)
+        features.find { |p| p.name.eql?(feature_name) }
+      end
+      
+      def group.views_path
+        "#{base_dir}/#{GROUP_SPACE_DIRECTORY}/views"
+      end
+      
+      def group.view(view_name)
+        "#{base_dir}/#{GROUP_SPACE_DIRECTORY}/views/#{view_name}"
+      end
+      
+      def group.javascript_module(javascript_file_name)
+        "#{base_dir}/#{GROUP_SPACE_DIRECTORY}/javascript/#{javascript_file_name}"
+      end
     end
 
-    @@groups.each do |group|
-      Dir.glob("#{group.relative_path}[!_]*/").each do |feature_path|
-        absolute_path = @@features_path.join(feature_path)
-        relative_path = Pathname.new(feature_path)
-        base_path = File.basename(feature_path, File::SEPARATOR)
-
-        feature_name = base_path.gsub(FEATURE_ID_PATTERN, '').to_sym
-
-        routes_file_path = relative_path.join('routes.rb')
-
-        # The custom routes file loads before the Rails default routes,
-        # leading to errors like NoMethodError for 'scope'.
-        # Ignoring them is required to prevent these issues.
-        @@ignored_paths << routes_file_path
-
-        # Due to Zeiwerk rules, Controllers have special load process
-        @@features_controllers_paths << relative_path.join(CONTROLLER_FILE_NAME)
-
-        @@ignored_paths << relative_path.join(CONTROLLER_FILE_NAME)
-
-        raise "Resource '#{relative_path}' does not have a valid ID" if base_path.scan(FEATURE_ID_PATTERN).empty?
-        feature_sub_path = relative_path.sub(/^#{Regexp.escape(@@features_path.to_s)}\//, '')
-        feature = OpenStruct.new(
-          id: base_path.scan(FEATURE_ID_PATTERN).first.delete_suffix('_'),
-          name: feature_name,
-          group: group,
-          absolute_path: absolute_path,
-          relative_path: relative_path,
-          sub_path: feature_sub_path,
-          routes_file_path: routes_file_path,
-          routes_file: feature_sub_path.join('routes'),
-          # controller_path: relative_path.join('controller'),
-          views_absolute_path: absolute_path.join('views'),
-          views_relative_path: relative_path.sub(/^#{Regexp.escape(@@features_path.to_s)}\//, '').join('views'),
-          javascript_relative_path: relative_path.sub(/^#{Regexp.escape(@@features_path.to_s)}\//, '').join('javascript'),
-          manifest: YAML.load_file(File.join(feature_path, MANIFEST_FILE_NAME)).deep_symbolize_keys
-        )
-
-        def feature.class_name = "FeaturePack::#{group.name.name.camelize}::#{name.name.camelize}"
-        def feature.namespace = class_name.constantize
-
-        feature.manifest.fetch(:const_aliases, []).each do |alias_data|
-          alias_method_name, alias_const_name = alias_data.first
-          feature.define_singleton_method(alias_method_name) { "#{class_name}::#{alias_const_name}".constantize }
+    def discover_features
+      @@groups.each do |group|
+        Dir.glob("#{group.relative_path}[!_]*/").each do |feature_path|
+          build_feature(group, feature_path)
         end
+      end
+    end
 
-        def feature.view(view_name) = "#{views_relative_path}/#{view_name}"
-        def feature.javascript_module(javascript_file_name) = "#{javascript_relative_path}/#{javascript_file_name}"
+    def build_feature(group, feature_path)
+      absolute_path = @@features_path.join(feature_path)
+      relative_path = Pathname.new(feature_path)
+      base_path = File.basename(feature_path, File::SEPARATOR)
+      
+      validate_feature_id!(base_path, relative_path)
+      
+      feature_name = base_path.gsub(FEATURE_ID_PATTERN, '').to_sym
+      routes_file_path = relative_path.join('routes.rb')
+      
+      setup_feature_paths(relative_path, routes_file_path)
+      
+      feature = create_feature_struct(
+        base_path, feature_name, group, absolute_path, 
+        relative_path, routes_file_path, feature_path
+      )
+      
+      define_feature_methods(feature)
+      setup_feature_aliases(feature)
+      
+      group.features << feature
+    end
 
-        group.features << feature
+    def validate_feature_id!(base_path, relative_path)
+      if base_path.scan(FEATURE_ID_PATTERN).empty?
+        raise "Feature '#{relative_path}' does not have a valid ID. Expected format: feature_<id>_<name>"
       end
     end
 
-    @@setup_executed_flag = true
-  end
+    def setup_feature_paths(relative_path, routes_file_path)
+      # Custom routes file loads before Rails default routes
+      @@ignored_paths << routes_file_path
+      
+      # Controllers have special load process due to Zeitwerk
+      controller_path = relative_path.join(CONTROLLER_FILE_NAME)
+      @@features_controllers_paths << controller_path
+      @@ignored_paths << controller_path
+    end
+
+    def create_feature_struct(base_path, feature_name, group, absolute_path, relative_path, routes_file_path, feature_path)
+      feature_sub_path = relative_path.sub(/^#{Regexp.escape(@@features_path.to_s)}\//, '')
+      manifest_path = File.join(feature_path, MANIFEST_FILE_NAME)
+      
+      unless File.exist?(manifest_path)
+        raise "Manifest file not found for feature '#{feature_name}' at #{manifest_path}"
+      end
+      
+      OpenStruct.new(
+        id: base_path.scan(FEATURE_ID_PATTERN).first.delete_suffix('_'),
+        name: feature_name,
+        group: group,
+        absolute_path: absolute_path,
+        relative_path: relative_path,
+        sub_path: feature_sub_path,
+        routes_file_path: routes_file_path,
+        routes_file: feature_sub_path.join('routes'),
+        views_absolute_path: absolute_path.join('views'),
+        views_relative_path: relative_path.sub(/^#{Regexp.escape(@@features_path.to_s)}\//, '').join('views'),
+        javascript_relative_path: relative_path.sub(/^#{Regexp.escape(@@features_path.to_s)}\//, '').join('javascript'),
+        manifest: load_manifest(manifest_path)
+      )
+    end
 
-  def self.group(group_name) = @@groups.find { |g| g.name.eql?(group_name) }
-  def self.feature(group_name, feature_name)
-    requested_group = group(group_name)
-    return nil if requested_group.nil?
-    requested_group.feature(feature_name)
+    def define_feature_methods(feature)
+      def feature.class_name
+        "FeaturePack::#{group.name.to_s.camelize}::#{name.to_s.camelize}"
+      end
+      
+      def feature.namespace
+        class_name.constantize
+      end
+      
+      def feature.view(view_name)
+        "#{views_relative_path}/#{view_name}"
+      end
+      
+      def feature.javascript_module(javascript_file_name)
+        "#{javascript_relative_path}/#{javascript_file_name}"
+      end
+    end
+
+    def setup_feature_aliases(feature)
+      feature.manifest.fetch(:const_aliases, []).each do |alias_data|
+        alias_method_name, alias_const_name = alias_data.first
+        feature.define_singleton_method(alias_method_name) do
+          "#{class_name}::#{alias_const_name}".constantize
+        end
+      end
+    end
   end
 end

data/lib/generators/feature_pack/add_feature/add_feature_generator.rb

@@ -1,34 +1,81 @@
 require 'rails/generators/base'
 require 'rails/generators/named_base'
 
-class FeaturePack::AddFeatureGenerator < Rails::Generators::NamedBase
-  desc 'Adds a new Feature'
-  source_root File.expand_path('templates', __dir__)
+module FeaturePack
+  # Generator for creating new features within a group
+  # Usage: rails generate feature_pack:add_feature GROUP_NAME/FEATURE_NAME
+  class AddFeatureGenerator < Rails::Generators::NamedBase
+    desc 'Creates a new Feature within an existing Group'
+    source_root File.expand_path('templates', __dir__)
 
-  argument :name, type: :string, required: true, desc: 'The name (sneak case) of the group to add'
+    argument :name, type: :string, required: true, desc: 'The group/feature name (snake_case) format: group_name/feature_name'
 
-  def add_feature
-    raise "Feature name couldn't have more than one bar '/'" if name.count('/') > 1
+    def add_feature
+      validate_feature_name!
+      parse_names
+      check_group_existence!
+      check_feature_existence!
+      
+      @feature_id = generate_feature_id
+      @feature_dir = @group.relative_path.join("feature_#{@feature_id}_#{@feature_name}")
+      
+      create_feature_files
+      
+      say "Feature '#{@feature_name}' created successfully in group '#{@group_name}'!", :green
+      say "Location: #{@feature_dir}", :green
+    end
 
-    @group_name, @feature_name = name.split('/')
-    @group = FeaturePack.group(@group_name.to_sym)
-    @group_class_name = @group_name.camelcase
-    @feature_class_name = @feature_name.camelcase
+    private
 
-    raise "Group '#{@group_name}' doesn't exist. First, create it." if @group.nil?
+    def validate_feature_name!
+      if name.count('/') != 1
+        raise Thor::Error, "Feature name must be in format: group_name/feature_name"
+      end
+    end
 
-    raise "Feature '#{@group_class_name}::#{@feature_class_name}' already Exist." if FeaturePack.feature(@group_name.to_sym, @feature_name.to_sym).present?
+    def parse_names
+      @group_name, @feature_name = name.split('/')
+      
+      unless @group_name.match?(/^[a-z_]+$/) && @feature_name.match?(/^[a-z_]+$/)
+        raise Thor::Error, "Group and feature names must be in snake_case format"
+      end
+      
+      @group_class_name = @group_name.camelcase
+      @feature_class_name = @feature_name.camelcase
+    end
 
-    @feature_id = @feature_name.gsub('_', '-') + '-' + '999'
-    @feature_dir = @group.relative_path.join("feature_#{@feature_id}_#{@feature_name}")
+    def check_group_existence!
+      @group = FeaturePack.group(@group_name.to_sym)
+      
+      if @group.nil?
+        raise Thor::Error, "Group '#{@group_name}' doesn't exist. Create it first with: rails generate feature_pack:add_group #{@group_name}"
+      end
+    end
 
-    template './controller.rb.tt', @feature_dir.join('controller.rb')
-    template './manifest.yaml.tt', @feature_dir.join('manifest.yaml')
-    template './routes.rb.tt', @feature_dir.join('routes.rb')
-    template './views/index.html.slim.tt', @feature_dir.join('views/index.html.slim')
-    template './views/partials/_header.html.slim.tt', @feature_dir.join('views/partials/_header.html.slim')
-    template './views/partials/_footer.html.slim.tt', @feature_dir.join('views/partials/_footer.html.slim')
-    template './doc/readme.md.tt', @feature_dir.join('doc/readme.md')
-    create_file @feature_dir.join('queries', '.gitkeep')
+    def check_feature_existence!
+      if FeaturePack.feature(@group_name.to_sym, @feature_name.to_sym).present?
+        raise Thor::Error, "Feature '#{@feature_name}' already exists in group '#{@group_name}'"
+      end
+    end
+
+    def generate_feature_id
+      # Generate a unique ID based on timestamp
+      # Format: YYMMDD (can't contain underscores)
+      Time.now.strftime('%y%m%d')
+    end
+
+    def create_feature_files
+      template './controller.rb.tt', @feature_dir.join('controller.rb')
+      template './manifest.yaml.tt', @feature_dir.join('manifest.yaml')
+      template './routes.rb.tt', @feature_dir.join('routes.rb')
+      template './views/index.html.slim.tt', @feature_dir.join('views/index.html.slim')
+      template './views/partials/_header.html.slim.tt', @feature_dir.join('views/partials/_header.html.slim')
+      template './views/partials/_footer.html.slim.tt', @feature_dir.join('views/partials/_footer.html.slim')
+      template './doc/readme.md.tt', @feature_dir.join('doc/readme.md')
+      
+      # Create directories
+      empty_directory @feature_dir.join('queries')
+      empty_directory @feature_dir.join('javascript')
+    end
   end
 end

data/lib/generators/feature_pack/add_feature/templates/controller.rb.tt

@@ -1,3 +1,30 @@
-class FeaturePack::<%= @group_class_name %>::<%= @feature_class_name %>Controller < FeaturePack::Controller
-  # index defined in parent controller
+# Feature controller for <%= @feature_class_name %>
+class FeaturePack::<%= @group_class_name %>::<%= @feature_class_name %>Controller < FeaturePack::<%= @group_class_name %>Controller
+  # The 'index' action is already defined in the parent controller
+  # Add your feature-specific actions and logic here
+  
+  # Example actions:
+  # def show
+  #   @item = find_item(params[:id])
+  # end
+  
+  # def new
+  #   @item = Item.new
+  # end
+  
+  # def create
+  #   @item = Item.new(item_params)
+  #   if @item.save
+  #     redirect_to feature_pack_path(:<%= @group_name %>, :<%= @feature_name %>)
+  #   else
+  #     render :new
+  #   end
+  # end
+  
+  private
+  
+  # Add feature-specific private methods here
+  # def item_params
+  #   params.require(:item).permit(:name, :description)
+  # end
 end

data/lib/generators/feature_pack/add_feature/templates/manifest.yaml.tt

@@ -1,16 +1,17 @@
-:name: Feature Friendly Name
-:description: 
-:type: :alert
-:url: <%= @feature_name.gsub('_', '-') %>
-:version: 1.0.0
-#const_aliases:
-#  - :params_class: 'Processor::Params'
-:access_policy:
-  :admin: '*'
-  :coordenacao_aps: '*'
-  :coordenacao_atividade_fisica: '*'
-  :coordenacao_saude_bucal:
-    - :lista_equipes_saude_bucal
-  :professional:
-    - :whatsapp_text_alert
-    - :whatsapp_protected_pdf
+# Feature manifest configuration
+name: <%= @feature_class_name.humanize %>
+description: Description of <%= @feature_name.humanize %> feature
+url: /<%= @feature_name.gsub('_', '-') %>
+version: 1.0.0
+
+# Optional: Define constant aliases for this feature
+# const_aliases:
+#   - service: <%= @feature_class_name %>Service
+#   - repository: <%= @feature_class_name %>Repository
+
+# Optional: Define access policies
+# access_policy:
+#   admin: '*'
+#   user: 
+#     - index
+#     - show

data/lib/generators/feature_pack/add_group/add_group_generator.rb

@@ -1,29 +1,66 @@
 require 'rails/generators/base'
 require 'rails/generators/named_base'
 
-class FeaturePack::AddGroupGenerator < Rails::Generators::NamedBase
-  desc 'Adds a new Feature Group'
-  source_root File.expand_path('templates', __dir__)
-
-  argument :name, type: :string, required: true, desc: 'The name (sneak case) of the group to add'
-
-  def create_feature_group
-    raise "Group name couldn't have '/'" if name.include?('/')
-    raise "Group '#{name}' already exists" if FeaturePack.group(name.to_sym).present?
-
-    @class_name = name.camelcase
-
-    # id can't contain underline '_'
-    group_id = name.gsub('_', '-') + '-' + '999'
-    group_dir = FeaturePack.features_path.join("group_#{group_id}_#{name}")
-
-    template './_group_space/controller.rb.tt', group_dir.join('_group_space', 'controller.rb')
-    template './_group_space/manifest.yaml.tt', group_dir.join('_group_space', 'manifest.yaml')
-    template './_group_space/routes.rb.tt', group_dir.join('_group_space', 'routes.rb')
-    template './_group_space/views/index.html.slim.tt', group_dir.join('_group_space', 'views/index.html.slim')
-    template './_group_space/views/partials/_header.html.slim.tt',
-             group_dir.join('_group_space', 'views/partials/_header.html.slim')
-    template './_group_space/views/partials/_footer.html.slim.tt',
-             group_dir.join('_group_space', 'views/partials/_footer.html.slim')
+module FeaturePack
+  # Generator for creating new feature groups
+  # Usage: rails generate feature_pack:add_group GROUP_NAME
+  class AddGroupGenerator < Rails::Generators::NamedBase
+    desc 'Creates a new Feature Group with the standard directory structure'
+    source_root File.expand_path('templates', __dir__)
+
+    argument :name, type: :string, required: true, desc: 'The name (snake_case) of the group to add'
+
+    def create_feature_group
+      validate_group_name!
+      check_group_existence!
+      
+      @class_name = name.camelcase
+      @group_id = generate_group_id
+      
+      group_dir = FeaturePack.features_path.join("group_#{@group_id}_#{name}")
+      
+      create_group_files(group_dir)
+      
+      say "Group '#{name}' created successfully!", :green
+      say "Location: #{group_dir}", :green
+    end
+
+    private
+
+    def validate_group_name!
+      if name.include?('/')
+        raise Thor::Error, "Group name cannot contain '/'. Use snake_case format."
+      end
+      
+      unless name.match?(/^[a-z_]+$/)
+        raise Thor::Error, "Group name must be in snake_case format (lowercase letters and underscores only)."
+      end
+    end
+
+    def check_group_existence!
+      if FeaturePack.group(name.to_sym).present?
+        raise Thor::Error, "Group '#{name}' already exists"
+      end
+    end
+
+    def generate_group_id
+      # Generate a unique ID based on timestamp
+      # Format: YYMMDD (can't contain underscores)
+      Time.now.strftime('%y%m%d')
+    end
+
+    def create_group_files(group_dir)
+      template './_group_space/controller.rb.tt', group_dir.join('_group_space', 'controller.rb')
+      template './_group_space/manifest.yaml.tt', group_dir.join('_group_space', 'manifest.yaml')
+      template './_group_space/routes.rb.tt', group_dir.join('_group_space', 'routes.rb')
+      template './_group_space/views/index.html.slim.tt', group_dir.join('_group_space', 'views/index.html.slim')
+      template './_group_space/views/partials/_header.html.slim.tt',
+               group_dir.join('_group_space', 'views/partials/_header.html.slim')
+      template './_group_space/views/partials/_footer.html.slim.tt',
+               group_dir.join('_group_space', 'views/partials/_footer.html.slim')
+      
+      # Create javascript directory
+      empty_directory group_dir.join('_group_space', 'javascript')
+    end
   end
 end

data/lib/generators/feature_pack/add_group/templates/_group_space/controller.rb.tt

@@ -1,3 +1,13 @@
-class FeaturePack::<%= class_name %>Controller < FeaturePack::GroupController
-  # 'index' already defined in RootGroupController
+# Group controller for <%= @class_name %>
+class FeaturePack::<%= @class_name %>Controller < FeaturePack::GroupController
+  # The 'index' action is already defined in the parent GroupController
+  # Add any group-wide functionality here that will be inherited by all features
+  
+  # Example:
+  # before_action :authenticate_user!
+  # before_action :check_permissions
+  
+  private
+  
+  # Add shared private methods for this group here
 end

data/lib/generators/feature_pack/add_group/templates/_group_space/manifest.yaml.tt

@@ -1,2 +1,8 @@
-name: Group Friendly Name Here
-url: <%= name.gsub('_', '-') %>
+# Group manifest configuration
+name: <%= @class_name.humanize %>
+url: /<%= name.gsub('_', '-') %>
+
+# Optional: Define constant aliases for this group
+# const_aliases:
+#   - model_name: ModelClass
+#   - service_name: ServiceClass

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: feature_pack
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.9.0
 platform: ruby
 authors:
 - Gedean Dias
 bindir: bin
 cert_chain: []
-date: 2025-01-26 00:00:00.000000000 Z
+date: 2025-02-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -29,10 +29,10 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
-description: Organizes and sets up the architecture of micro-applications within a
-  Rails application, enabling the segregation of code, management, and isolation of
-  functionalities, which can be developed, tested, and maintained independently of
-  each other.
+description: |
+  Organizes and sets up the architecture of micro-applications within a Rails application,
+  enabling segregation, management, and isolation of functionalities, thereby supporting
+  independent development, testing, and maintenance.
 email: gedean.dias@gmail.com
 executables: []
 extensions: []
@@ -66,8 +66,11 @@ files:
 homepage: https://github.com/gedean/feature_pack
 licenses:
 - MIT
-metadata: {}
-post_install_message: Please check readme file for use instructions.
+metadata:
+  bug_tracker_uri: https://github.com/gedean/feature_pack/issues
+  source_code_uri: https://github.com/gedean/feature_pack
+  changelog_uri: https://github.com/gedean/feature_pack/blob/main/CHANGELOG.MD
+post_install_message: Please check the README file for use instructions.
 rdoc_options: []
 require_paths:
 - lib
@@ -82,7 +85,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.3
+rubygems_version: 3.6.9
 specification_version: 4
-summary: A different way to organize app features in Rails.
+summary: A different approach to organizing Rails app features.
 test_files: []