elaine_crud 0.1.0

data/docs/HAS_MANY_IMPLEMENTATION.md

@@ -0,0 +1,154 @@
+# has_many Relationship Implementation
+
+This document describes the implementation of `has_many` relationship support in ElaineCrud using filtered flat resources (URLs like `/meetings?meeting_room_id=4`).
+
+## Implementation Summary
+
+The has_many implementation adds the following features:
+
+### 1. Automatic Detection
+- ElaineCrud automatically detects all `has_many` relationships in your ActiveRecord models
+- Auto-configures display fields for related records
+- Includes automatic query optimization with `includes()` to prevent N+1 queries
+
+### 2. Parent Filtering
+- Supports URLs like `/meetings?meeting_room_id=4` to show filtered views
+- Automatically filters records based on parent relationship parameters
+- Maintains parent context in forms and redirects
+
+### 3. Smart Display
+- **Index Views**: Shows relationship summaries with counts and previews
+- **Links**: Automatically generates links to filtered views (e.g., "5 meetings: Daily Standup, Team Review...")
+- **Forms**: Pre-populates parent relationships when creating from filtered context
+
+### 4. UI Enhancements
+- Context-aware breadcrumbs showing the parent record
+- "View All" links to remove filters
+- Parent information display in forms
+
+## Usage Examples
+
+### Automatic Configuration (No Code Required)
+
+```ruby
+class MeetingRoomsController < ElaineCrud::BaseController
+  model MeetingRoom
+  permit_params :name, :capacity, :building
+  # has_many :meetings relationship automatically detected and configured
+end
+
+class MeetingsController < ElaineCrud::BaseController
+  model Meeting
+  permit_params :title, :start_time, :end_time, :meeting_room_id
+  # Automatic parent filtering support - no additional configuration needed
+end
+```
+
+### Manual Configuration (Optional)
+
+```ruby
+class MeetingRoomsController < ElaineCrud::BaseController
+  model MeetingRoom
+  permit_params :name, :capacity, :building
+  
+  # Optional: Customize has_many relationship display
+  has_many_relation :meetings do
+    title "Room Meetings"
+    display :title
+    show_count true
+    max_preview_items 3
+    scope -> { where('start_time > ?', Time.current) }
+  end
+end
+```
+
+## Generated URLs and Behavior
+
+```ruby
+# MeetingRoom index page shows:
+# Name        | Capacity | Meetings
+# Room A      | 20       | 5 meetings: Daily Standup, Team Review, All Hands
+# Room B      | 10       | 2 meetings: 1:1 Meeting, Code Review
+```
+
+Clicking "5 meetings: Daily Standup, Team Review..." generates:
+- URL: `/meetings?meeting_room_id=4`
+- Shows filtered view with context banner
+- "New Meeting" button pre-populates `meeting_room_id=4`
+- After creating, redirects back to filtered view
+
+## Technical Implementation
+
+### Controller Changes
+- **BaseController**: Added parent filtering logic in `fetch_records`
+- **Auto-detection**: `auto_configure_has_many_relationships` method
+- **Context management**: `@parent_context` instance variable for UI
+- **Query optimization**: Enhanced `get_all_relationship_includes`
+
+### Field Configuration
+- **FieldConfiguration**: Added `has_many_config` attribute and methods
+- **Display logic**: `render_has_many_display` method for relationship summaries
+- **DSL support**: Block-style configuration with `has_many_relation`
+
+### Helper Methods
+- **BaseHelper**: Enhanced `display_field_value` to handle has_many
+- **Link generation**: Automatic URL generation for filtered views
+- **Relationship detection**: `is_has_many_relationship?` helper
+
+### View Templates
+- **Index**: Parent context banner with breadcrumbs
+- **Forms**: Hidden fields and context information for parent relationships
+- **Styling**: TailwindCSS classes for consistent UI
+
+## Configuration Options
+
+| Option | Type | Description | Default |
+|--------|------|-------------|---------|
+| `display` | Symbol/Proc | Field or method to display | Auto-detected (name, title, etc.) |
+| `show_count` | Boolean | Show count in relationship display | `true` |
+| `max_preview_items` | Integer | Number of items to preview | `3` |
+| `scope` | Proc | Limits displayed relationships | `-> { all }` |
+| `foreign_key` | Symbol | The foreign key field name | Auto-detected |
+
+## Supported URL Patterns
+
+```ruby
+# All supported URL patterns:
+/meeting_rooms                           # All meeting rooms
+/meeting_rooms/4                        # Show specific meeting room
+/meetings                               # All meetings  
+/meetings?meeting_room_id=4             # Meetings filtered by room
+/meetings/new                           # Create new meeting
+/meetings/new?meeting_room_id=4         # Create meeting for specific room
+/meetings/123?meeting_room_id=4         # Show meeting in room context
+```
+
+## Migration from Manual Configuration
+
+If you previously configured has_many relationships manually, ElaineCrud respects existing configurations:
+
+```ruby
+# Your existing configuration takes precedence
+has_many_relation :meetings do
+  display :custom_title
+  show_count false
+end
+# Auto-detection skips this field since it's already configured
+```
+
+## Performance Considerations
+
+- **Automatic Includes**: Related models are automatically included in queries
+- **Lazy Loading**: Relationship counts and previews are loaded only when displayed
+- **Query Optimization**: Uses single queries with joins rather than N+1 patterns
+- **Caching**: Consider adding Rails caching for frequently accessed relationship displays
+
+## Error Handling
+
+ElaineCrud handles various error scenarios gracefully:
+- **Missing Parent Record**: Shows error message with record ID
+- **Configuration Errors**: Falls back to basic display in production
+- **Missing Display Fields**: Uses fallback display methods
+- **Database Errors**: Logs errors and shows user-friendly messages
+
+This implementation provides a powerful, automatic has_many relationship system that works out-of-the-box while still allowing for extensive customization when needed.

data/docs/LAYOUT_EXAMPLES.md

@@ -0,0 +1,301 @@
+# ElaineCrud Layout System
+
+ElaineCrud now supports a flexible layout system that allows you to customize how ActiveRecord items are displayed in a grid format.
+
+## Overview
+
+The layout system introduces two main concepts:
+
+1. **Layout Structure**: A nested array where the first dimension represents rows and the second dimension represents columns within each row
+2. **Layout Header**: An array of configuration objects defining column widths, titles, and sorting behavior
+
+## Default Behavior
+
+By default, ElaineCrud displays all fields in a single row with equal column distribution:
+
+```ruby
+class PeopleController < ElaineCrud::BaseController
+  model Person
+  permit_params :name, :email, :bio, :status
+  
+  field :name, title: "Full Name"
+  field :email, title: "Email Address"
+  field :bio, title: "Biography"
+  field :status, title: "Status"
+end
+```
+
+This will create a layout like:
+```
+| Name (25%) | Email (25%) | Bio (25%) | Status (25%) |
+```
+
+## Custom Layouts
+
+You can override the `calculate_layout` and `calculate_layout_header` methods to create custom layouts:
+
+### Example 1: Two-Row Layout
+
+```ruby
+class PeopleController < ElaineCrud::BaseController
+  model Person
+  permit_params :name, :email, :bio, :status, :created_at
+  
+  field :name, title: "Full Name"
+  field :email, title: "Email Address"  
+  field :bio, title: "Biography"
+  field :status, title: "Status"
+  field :created_at, title: "Joined", visible: true
+  
+  private
+  
+  # Custom layout: Name and Email on first row, Bio and metadata on second row
+  def calculate_layout(content, fields)
+    [
+      [
+        { field_name: :name, colspan: 1 },
+        { field_name: :email, colspan: 1 },
+        { field_name: :status, colspan: 1 }
+      ],
+      [
+        { field_name: :bio, colspan: 2 },
+        { field_name: :created_at, colspan: 1 }
+      ]
+    ]
+  end
+  
+  # Custom header: Define column sizes
+  def calculate_layout_header(fields)
+    ["25%", "35%", "25%", "15%"]  # 4 columns total
+  end
+end
+```
+
+### Example 2: Conditional Layout Based on Content
+
+```ruby
+class ProductController < ElaineCrud::BaseController
+  model Product
+  permit_params :name, :price, :description, :category, :image_url, :featured
+  
+  private
+  
+  # Different layouts for featured vs regular products
+  def calculate_layout(content, fields)
+    if content.featured?
+      # Featured products get a prominent layout
+      [
+        [
+          { field_name: :name, colspan: 2 },
+          { field_name: :price, colspan: 1 }
+        ],
+        [
+          { field_name: :description, colspan: 3 }
+        ],
+        [
+          { field_name: :category, colspan: 1 },
+          { field_name: :image_url, colspan: 2 }
+        ]
+      ]
+    else
+      # Regular products use compact layout
+      [
+        [
+          { field_name: :name, colspan: 1 },
+          { field_name: :price, colspan: 1 },
+          { field_name: :category, colspan: 1 }
+        ]
+      ]
+    end
+  end
+  
+  def calculate_layout_header(fields)
+    ["40%", "20%", "40%"]  # Flexible 3-column grid
+  end
+end
+```
+
+### Example 3: Complex Multi-Row Layout with Spans
+
+```ruby
+class OrderController < ElaineCrud::BaseController
+  model Order
+  permit_params :order_number, :customer_name, :total, :status, :notes, :created_at
+  
+  private
+  
+  def calculate_layout(content, fields)
+    [
+      [
+        { field_name: :order_number, colspan: 1 },
+        { field_name: :customer_name, colspan: 2 },
+        { field_name: :total, colspan: 1 }
+      ],
+      [
+        { field_name: :status, colspan: 1 },
+        { field_name: :created_at, colspan: 1 },
+        { field_name: :notes, colspan: 2 }  # Notes span 2 columns
+      ]
+    ]
+  end
+  
+  def calculate_layout_header(fields)
+    ["15%", "35%", "25%", "25%"]
+  end
+end
+```
+
+## Layout Configuration Properties
+
+Each column configuration object in the layout can have the following properties:
+
+- `field_name`: **Required** - The name of the field to display
+- `colspan`: **Optional** - Number of columns this field should span (default: 1)
+- `rowspan`: **Optional** - Number of rows this field should span (default: 1) 
+- Future properties can be added as needed
+
+## Method Signatures
+
+### calculate_layout(content, fields)
+
+- **content**: The ActiveRecord object for the current row
+- **fields**: Array of field names that should be included in the layout
+- **Returns**: Array of arrays, where each sub-array represents a row of column configurations
+
+### calculate_layout_header(fields)
+
+- **fields**: Array of field names that should be included in the layout  
+- **Returns**: Array of header configuration objects with width, field_name, and/or title properties
+
+## CSS Grid Integration
+
+The layout system generates CSS Grid structures that automatically handle:
+
+- Column sizing based on `calculate_layout_header`
+- Column and row spanning based on layout configuration
+- Responsive behavior using CSS Grid's built-in capabilities
+- Proper alignment and spacing
+
+## Migration from Existing Configurations
+
+**Breaking Change**: The `grid_column_span` and `grid_row_span` field configuration options have been removed in favor of the more powerful layout system.
+
+**Before (deprecated)**:
+```ruby
+field :bio, grid_column_span: 2
+field :comments, grid_column_span: 3
+```
+
+**After (new layout system)**:
+```ruby
+private
+
+def calculate_layout(content, fields)
+  [
+    [
+      { field_name: :name, colspan: 1 },
+      { field_name: :email, colspan: 1 },
+      { field_name: :status, colspan: 1 }
+    ],
+    [
+      { field_name: :bio, colspan: 2 },
+      { field_name: :comments, colspan: 1 }
+    ]
+  ]
+end
+
+  def calculate_layout_header(fields)
+    [
+      { width: "25%", field_name: :name },     # Sortable column
+      { width: "25%", field_name: :email },    # Sortable column  
+      { width: "25%", title: "Personal Info" }, # Custom title, not sortable
+      { width: "25%" }                         # Empty column
+    ]
+  end
+```
+
+This provides much more flexibility and control over your layouts.
+
+## Header Configuration
+
+Each header configuration object can contain:
+
+- `width`: **Required** - CSS width value (e.g., "25%", "200px", "1fr")
+- `field_name`: **Optional** - Field name to display and enable sorting
+- `title`: **Optional** - Custom column title (overrides field title)
+
+### Header Examples
+
+```ruby
+# Field-based sortable column
+{ width: "30%", field_name: :name }
+
+# Custom title with field sorting  
+{ width: "25%", field_name: :created_at, title: "Created" }
+
+# Custom title without field (not sortable)
+{ width: "20%", title: "Category Info" }
+
+# Empty header column
+{ width: "10%" }
+```
+
+### Sorting Behavior
+
+- **Sortable**: Columns with `field_name` get sorting links and indicators
+- **Non-sortable**: Columns without `field_name` display plain text
+- **Custom titles**: Use `title` to override the field's configured title
+
+## Best Practices
+
+1. **Keep it Simple**: Start with the default layout and only customize when you have specific layout requirements
+2. **Consistent Headers**: Make sure your `calculate_layout_header` returns the right number of columns for your layout
+3. **Responsive Design**: Use percentage or `fr` units in your header layout for responsive behavior
+4. **Test Edge Cases**: Consider how your layout handles missing data or varying content lengths
+5. **Performance**: The layout methods are called for every record, so keep them efficient
+
+## Example Controller with Layout
+
+Here's a complete example showing the layout system in action:
+
+```ruby
+class EventController < ElaineCrud::BaseController
+  layout 'application'
+  
+  model Event
+  permit_params :title, :description, :date, :location, :organizer, :capacity
+  
+  field :title, title: "Event Title"
+  field :date, title: "Event Date"
+  field :location, title: "Venue"
+  field :organizer, title: "Organized By"
+  field :capacity, title: "Max Attendees"
+  field :description, title: "Description"
+  
+  private
+  
+  # Custom layout: Title and key info on top, description below
+  def calculate_layout(content, fields)
+    [
+      [
+        { field_name: :title, colspan: 2 },
+        { field_name: :date, colspan: 1 },
+        { field_name: :capacity, colspan: 1 }
+      ],
+      [
+        { field_name: :organizer, colspan: 2 },
+        { field_name: :location, colspan: 2 }
+      ],
+      [
+        { field_name: :description, colspan: 4 }
+      ]
+    ]
+  end
+  
+  def calculate_layout_header(fields)
+    ["25%", "25%", "25%", "25%"]  # Equal 4-column grid
+  end
+end
+```
+
+This creates a structured layout that displays events in a clear, hierarchical format while maintaining the flexibility to customize for different types of content.

data/docs/TROUBLESHOOTING.md

@@ -0,0 +1,170 @@
+# ElaineCrud Troubleshooting Guide
+
+## Form Changes Not Being Saved
+
+If you're experiencing issues where form changes are not being saved when you click "Save Changes", here's how to diagnose and fix the problem:
+
+### Step 1: Enable Debug Logging
+
+The latest version of ElaineCrud includes detailed debug logging. Check your Rails development log after attempting to save changes. Look for lines starting with "ElaineCrud:".
+
+### Step 2: Check Your Controller Configuration
+
+Add this line to your controller's action (temporarily) to see the configuration:
+
+```ruby
+class MeetingsController < ElaineCrud::BaseController
+  model Meeting
+  permit_params :title, :start_time, :end_time
+  
+  def index
+    debug_configuration  # Add this temporarily
+    super
+  end
+end
+```
+
+This will output configuration details to your console.
+
+### Step 3: Common Issues and Solutions
+
+#### Issue 1: `permit_params` called before `model`
+**Problem**: If you call `permit_params` before setting the model, foreign keys won't be auto-included.
+
+**Wrong**:
+```ruby
+permit_params :title, :start_time
+model Meeting  # Model set after permit_params
+```
+
+**Correct**:
+```ruby
+model Meeting
+permit_params :title, :start_time  # Foreign keys auto-included
+```
+
+**Note**: Recent versions automatically handle this, but it's still best practice to call `model` first.
+
+#### Issue 2: Missing permitted parameters
+**Problem**: The field you're trying to update isn't in the permitted parameters list.
+
+**Solution**: Add the field to `permit_params`:
+```ruby
+permit_params :title, :start_time, :end_time, :description
+# Foreign keys like :meeting_room_id are automatically included
+```
+
+#### Issue 3: Validation errors
+**Problem**: The model has validation errors that prevent saving.
+
+**Check**: Look in your Rails log for lines like:
+```
+ElaineCrud: Record update failed with errors: ["Title can't be blank"]
+```
+
+**Solution**: Fix the validation errors or adjust your model validations.
+
+#### Issue 4: Parameter namespace issues
+**Problem**: Form parameters aren't being submitted under the correct model name.
+
+**Check**: Look for log lines like:
+```
+ElaineCrud: Looking for params under key 'meeting'
+ElaineCrud: Available param keys: ["utf8", "authenticity_token", "commit"]
+ElaineCrud: No parameters found for model 'meeting'
+```
+
+**Solution**: This usually indicates a form submission issue. Check that your model name matches expectations.
+
+### Step 4: Manual Debugging
+
+If the automatic debugging isn't sufficient, you can add this to your controller:
+
+```ruby
+def update
+  Rails.logger.info "Raw params: #{params.inspect}"
+  Rails.logger.info "Record params: #{record_params.inspect}"
+  Rails.logger.info "Permitted attributes: #{permitted_attributes.inspect}"
+  super
+end
+```
+
+### Step 5: Common Log Patterns and Their Meanings
+
+#### Successful Update
+```
+ElaineCrud: Attempting to update with params: {:title=>"New Title", :meeting_room_id=>2}
+ElaineCrud: Record updated successfully: {"id"=>1, "title"=>"New Title", "meeting_room_id"=>2}
+```
+
+#### Missing Parameters
+```
+ElaineCrud: Looking for params under key 'meeting'
+ElaineCrud: No parameters found for model 'meeting'
+ElaineCrud: Attempting to update with params: {}
+```
+**Fix**: Check form submission and parameter names.
+
+#### Validation Errors
+```
+ElaineCrud: Record update failed with errors: ["Title can't be blank", "Meeting room must exist"]
+```
+**Fix**: Ensure required fields are filled and foreign key references are valid.
+
+#### Permission Issues
+```
+ElaineCrud: Permitted attributes: [:title]
+ElaineCrud: Attempting to update with params: {:title=>"New Title"}
+```
+**Fix**: Add missing fields to `permit_params` (foreign keys should be auto-included).
+
+### Step 6: Browser Developer Tools
+
+1. Open your browser's developer tools (F12)
+2. Go to the Network tab
+3. Attempt to save changes
+4. Look for the POST request to your update action
+5. Check the request payload to see what parameters are being sent
+
+### Step 7: Test with Rails Console
+
+You can test parameter handling directly:
+
+```ruby
+# In rails console
+controller = YourController.new
+controller.params = ActionController::Parameters.new({
+  your_model_name: { title: "Test", meeting_room_id: 1 }
+})
+puts controller.send(:record_params).inspect
+```
+
+### Step 8: Minimal Test Case
+
+Create a minimal controller to isolate the issue:
+
+```ruby
+class TestController < ElaineCrud::BaseController
+  model YourModel  # Replace with your actual model
+  permit_params :title  # Add your basic fields
+  
+  def index
+    debug_configuration
+    super
+  end
+end
+```
+
+Add a route and test with this minimal setup.
+
+## Getting Help
+
+If you're still experiencing issues:
+
+1. **Check the logs**: Include relevant log output in your issue report
+2. **Share your controller**: Include your controller code
+3. **Share your model**: Include relevant model code (relationships, validations)
+4. **Share the form**: Include the HTML form being submitted
+5. **Browser network info**: Include details from browser developer tools
+
+The debug logging should give you enough information to identify the root cause of the issue.

data/elaine_crud.gemspec

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative 'lib/elaine_crud/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'elaine_crud'
+  spec.version = ElaineCrud::VERSION
+  spec.authors = ['Garo']
+  spec.email = ['juho.makinen@gmail.com']
+
+  spec.summary = 'A Rails engine for generating CRUD UIs for ActiveRecord models'
+  spec.description = 'ElaineCrud provides a reusable BaseController and views to quickly generate CRUD interfaces for any ActiveRecord model with minimal configuration.'
+  spec.homepage = 'https://github.com/garo/elaine_crud'
+  spec.license = 'MIT'
+  
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/garo/elaine_crud'
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z 2>/dev/null`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+    end
+  end
+
+  spec.require_paths = ['lib']
+
+  # Runtime dependencies
+  spec.add_dependency 'rails', '>= 6.0'
+  spec.add_dependency 'kaminari', '~> 1.2'
+  spec.add_dependency 'caxlsx', '~> 4.0'
+  spec.add_dependency 'csv', '~> 3.0'
+  spec.add_dependency 'turbo-rails', '~> 2.0'
+
+  # Development dependencies
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rspec-rails', '~> 6.0'
+  spec.add_development_dependency 'capybara', '~> 3.0'
+  spec.add_development_dependency 'selenium-webdriver', '~> 4.0'
+  spec.add_development_dependency 'sqlite3', '~> 2.1'
+  spec.add_development_dependency 'puma', '~> 6.0'
+  spec.add_development_dependency 'roo', '~> 2.10'
+
+  # For more information and examples about making a new gem, check out our
+  # guide at: https://bundler.io/guides/creating_gem.html
+end