dynamic_layouts 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e0b9e03aa572a8f7d1109b8a5b712d00fbd9c6b9ece7dd130d95a69043919de
-  data.tar.gz: e595057c5c95c165a2823e666c4d9bd6ed5eace6308bbe6c310b5ffe7404bf20
+  metadata.gz: fa58eac2c16e862711740275aec6a38fe3a27124b511ddb9bbac54d31a9500da
+  data.tar.gz: 218b984c4b32fa690bf5ec1212cc0218aacffa34f071c104a95cce490823b996
 SHA512:
-  metadata.gz: 283631224c1c912cdda718d4ab769c2a87960619dac6177660d5dcc3ecb8e9fb2634947277cce17bf717821a5ab18e5ef251389cb7ec0bb43223559afab1aa3f
-  data.tar.gz: 6bead906043a49945de821c163b09c38cbee7b07231bd87fe56972a5aa247624eee1211e225a3f5f327edbd4d8d21edc5a25e4f50fec11505134e24db6618fff
+  metadata.gz: 021d57dc7a614d963784f9b5fa5332e04d79ab3df950f674cbdf1cc9ac0db5775c341489b96952e576f5106ff3985add018c90aa414512d503e118a2ba2284cc
+  data.tar.gz: ca58426ba01060c493aaffc9843ade0f21319f66856a72975a629b2238ccae377e0cb9b32ae77e50c4b818884669d575cfa83ee6859d6b489667bd9f22b3e8ac

data/README.md

@@ -1,39 +1,330 @@
-# DynamicLayouts
+# Dynamic Layouts
 
-TODO: Delete this and the text below, and describe your gem
+A Ruby on Rails gem for building flexible, database-driven UI layouts. Dynamic Layouts allows you to define and manage complex form layouts, tables, dashboards, and markdown content through a hierarchical structure stored in your database.
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/dynamic_layouts`. To experiment with that code, run `bin/console` for an interactive prompt.
+## Features
+
+- **Grid Layouts**: Create responsive form layouts with various field types
+- **Table Layouts**: Build dynamic tables with configurable columns
+- **Dashboard Widgets**: Design dashboard interfaces with customizable widgets
+- **Markdown Elements**: Add rich text content and documentation
+- **Layout Overrides**: Programmatically customize layouts at runtime
+- **Custom Transformers**: Implement business logic to modify layouts dynamically
+- **Easy Setup**: Rails generator creates all necessary migrations and models
+
+## Requirements
+
+- Ruby >= 3.2.0
+- Rails >= 6.1
 
 ## Installation
 
-TODO: Replace `UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG` with your gem name right after releasing it to RubyGems.org. Please do not do it earlier due to security reasons. Alternatively, replace this section with instructions to install your gem from git if you don't plan to release to RubyGems.org.
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'dynamic_layouts'
+```
+
+Then execute:
+
+```bash
+bundle install
+```
+
+Run the generator to create migrations and models:
 
-Install the gem and add to the application's Gemfile by executing:
+```bash
+rails generate dynamic_layouts:install
+rails db:migrate
+```
 
-    $ bundle add UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+This will create the following database tables and models:
+- `dynamic_layouts`
+- `dynamic_layout_containers`
+- `dynamic_layout_sections`
+- `dynamic_layout_grid_fields`
+- `dynamic_layout_table_configs`
+- `dynamic_layout_table_columns`
+- `dynamic_layout_dashboard_widgets`
+- `dynamic_layout_markdown_elements`
 
-If bundler is not being used to manage dependencies, install the gem by executing:
+## Architecture
 
-    $ gem install UPDATE_WITH_YOUR_GEM_NAME_PRIOR_TO_RELEASE_TO_RUBYGEMS_ORG
+Dynamic Layouts uses a hierarchical structure:
+
+```
+Layout
+  └── Container
+        └── Section
+              └── Elements (Grid Fields, Table Columns, Dashboard Widgets, or Markdown)
+```
+
+- **Layout**: The top-level container for a complete UI layout
+- **Container**: Groups related sections together
+- **Section**: Defines a specific layout type (grid, table, dashboard, or markdown)
+- **Elements**: Individual components within a section
 
 ## Usage
 
-TODO: Write usage instructions here
+### Basic Layout Building
+
+Build and retrieve a layout:
+
+```ruby
+# Simple build
+layout = DynamicLayouts::DynamicLayoutBuilder.build('user_form')
+
+# Build with transformation
+layout = DynamicLayouts::DynamicLayoutBuilder.build(
+  'user_form',
+  record: @user,
+  controller: self,
+  user: current_user
+)
+```
+
+The builder will:
+1. Find the layout by name
+2. Eager load all associated sections and elements
+3. Serialize the layout to a hash structure
+4. Apply transformations if a transformer is provided
+
+### Custom Transformers
+
+Create custom transformers to modify layouts based on business logic:
+
+```ruby
+class UserLayoutTransformer < DynamicLayouts::DynamicLayoutTransformer
+  def transform
+    # Hide email field for non-admin users
+    if @current_user && !@current_user.admin?
+      hide_field('contact_info', :email)
+    end
+    
+    # Make fields read-only for archived records
+    if @record&.archived?
+      make_section_readonly('personal_details')
+    end
+    
+    @dynamic_layout
+  end
+  
+  private
+  
+  def hide_field(section_slug, field_attr)
+    section = find_section(section_slug)
+    return unless section
+    
+    field = section[:elements].find { |f| f[:attr] == field_attr.to_s }
+    field[:hidden] = true if field
+  end
+  
+  def make_section_readonly(section_slug)
+    section = find_section(section_slug)
+    return unless section
+    
+    section[:writable] = false
+  end
+  
+  def find_section(slug)
+    @dynamic_layout[:containers].each do |container|
+      section = container[:sections].find { |s| s[:slug] == slug.to_s }
+      return section if section
+    end
+    nil
+  end
+end
+```
+
+The transformer will be automatically discovered if it follows the naming convention: `{Controller}LayoutTransformer`.
+
+### Layout Overrides
+
+Override layout configuration at runtime:
+
+```ruby
+layout = DynamicLayouts::DynamicLayoutBuilder.build('user_form')
+
+overrides = {
+  contact_info: {
+    writable: false,
+    collapsed: true,
+    elements: {
+      email: { 
+        required: true,
+        tooltip: 'A valid email address is required'
+      },
+      phone: { 
+        hidden: true 
+      }
+    }
+  },
+  personal_details: {
+    elements: {
+      first_name: { 
+        label: 'First Name (Required)',
+        required: true 
+      }
+    }
+  }
+}
+
+DynamicLayouts::DynamicLayoutService.override_layout_config(layout, overrides)
+```
+
+### Grid Layout
+
+Grid layouts are ideal for forms with various field types:
+
+```ruby
+# In your layout configuration
+section = dynamic_layout.containers.first.sections.create!(
+  name: 'Contact Information',
+  slug: 'contact_info',
+  layout: 'grid',
+  position: 1,
+  writable: true
+)
+
+# Add fields
+section.grid_fields.create!(
+  label: 'Email',
+  attr: 'email',
+  attr_type: 'email',
+  required: true,
+  position: 1
+)
+
+section.grid_fields.create!(
+  label: 'Phone',
+  attr: 'phone',
+  attr_type: 'tel',
+  position: 2
+)
+```
+
+### Table Layout
+
+Table layouts display data in columns:
+
+```ruby
+section = dynamic_layout.containers.first.sections.create!(
+  name: 'Users List',
+  slug: 'users_list',
+  layout: 'table',
+  position: 1
+)
+
+table_config = section.table_config
+table_config.table_columns.create!(
+  header: 'Name',
+  attr: 'name',
+  position: 1
+)
+
+table_config.table_columns.create!(
+  header: 'Email',
+  attr: 'email',
+  position: 2
+)
+```
+
+### Dashboard Layout
+
+Dashboard layouts create widget-based interfaces:
+
+```ruby
+section = dynamic_layout.containers.first.sections.create!(
+  name: 'Analytics Dashboard',
+  slug: 'analytics',
+  layout: 'dashboard',
+  position: 1
+)
+
+section.dashboard_widgets.create!(
+  label: 'Total Users',
+  slug: 'total_users',
+  widget_type: 'stat',
+  position: 1
+)
+
+section.dashboard_widgets.create!(
+  label: 'Revenue Chart',
+  slug: 'revenue_chart',
+  widget_type: 'chart',
+  position: 2
+)
+```
+
+### Markdown Layout
+
+Markdown layouts add documentation and rich text:
+
+```ruby
+section = dynamic_layout.containers.first.sections.create!(
+  name: 'Instructions',
+  slug: 'instructions',
+  layout: 'markdown',
+  position: 1
+)
+
+section.markdown_elements.create!(
+  content: '# Welcome
+  position: 1
+)
+```
+
+### Field Options
+
+#### Dropdown Fields
+
+```ruby
+grid_field.update!(
+  attr_type: 'dropdown',
+  options: 'mode:static;values:active=Active,inactive=Inactive,pending=Pending'
+)
+
+# Or with associations
+grid_field.update!(
+  attr_type: 'dropdown',
+  options: 'mode:association;class:Department;scopes:active;label:name;value:id'
+)
+```
+
+#### Autocomplete Fields
+
+```ruby
+grid_field.update!(
+  attr_type: 'autocomplete',
+  options: 'mode:static;values:New York,Los Angeles,Chicago,Houston'
+)
+```
+
+#### Rich Text Fields
+
+```ruby
+grid_field.update!(
+  attr_type: 'rich-text',
+  options: 'placeholder_attrs:first_name,last_name,email'
+)
+```
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+## Testing
 
-## Contributing
+Run the test suite:
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/dynamic_layouts. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/dynamic_layouts/blob/main/CODE_OF_CONDUCT.md).
+```bash
+bundle exec rspec
+```
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](LICENSE.txt).
 
-## Code of Conduct
+## Contributing
 
-Everyone interacting in the DynamicLayouts project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/dynamic_layouts/blob/main/CODE_OF_CONDUCT.md).
+Bug reports and pull requests are welcome on GitHub at https://github.com/CodeTectonics/dynamic-layouts.

data/lib/dynamic_layouts/dynamic_layout_service.rb

@@ -174,8 +174,9 @@ module DynamicLayouts
         res.send(scope)
       end
 
-      data_source.where("#{options[:attribute]} IS NOT NULL AND #{options[:attribute]} != ''")
-                .select("LOWER(TRIM(#{options[:attribute]})) AS formatted_value")
+      column = Arel.sql(ActiveRecord::Base.connection.quote_column_name(options[:attribute]))
+      data_source.where("#{column} IS NOT NULL AND #{column} != ''")
+                .select("LOWER(TRIM(#{column})) AS formatted_value")
                 .order(:formatted_value).distinct
                 .map do |item|
         { label: item.formatted_value.capitalize, value: item.formatted_value.capitalize }

data/lib/dynamic_layouts/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DynamicLayouts
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamic_layouts
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Mark Harbison
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-01 00:00:00.000000000 Z
+date: 2026-09-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails