ratamin 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02ee6e23e9d84b754a71528330d35e2e19337d1dc4e9dc2573c0ead727e6f196
-  data.tar.gz: cba72054dff87188c6c1764ff69ad78ecc0d11383138fa6068d5fb486016535a
+  metadata.gz: 443a14265f91ecb7a42d6ba90bfe3266fb6684978f4c2d9b323fe676969d2c11
+  data.tar.gz: 5227b26d004cad5fa090a7eff43947d41a6812e5e7f28a02b8633583a56a3a75
 SHA512:
-  metadata.gz: 9516cf7d76cf5e85907cf6a4d5e0f2cee6d990b772259a7c86b970a47a1d5fd7d70e87bea8c544ec5b9d7ec8c382aa5bb0814f46665fee35b6ef027f006336ff
-  data.tar.gz: 9d33dc214b7353fb81d867598ffaa5eb100a7e748dd4f247e833637f7df469803530fd715fd145f58f0acd8ef0ebbb0bdb70aca86ada03fcfd22e2aa3940e01d
+  metadata.gz: f53c415e467dfeb6cff17ca9bb584ee9b6248c8fb3243037c8ee87ab08b48134f881360e51a575e2186163da8ef3f9c74314c40d7812bc136132c731b85ed57a
+  data.tar.gz: 665b48695e5b0c74da01683528aa9c774676a83ca61bc5ad028eabd3641e6bd1fa8fb151397777f1e2e9daecdd9469809f73692a629d529927ff214a47a42b5f

data/.claude/skills/release-gem/SKILL.md

@@ -8,27 +8,29 @@ Release the gem. If $ARGUMENTS is provided, that is the new version number. Othe
 
 Steps:
 
-1. **Confirm version**: Read `lib/ratamin/version.rb`. If $ARGUMENTS differs from the current version, update the file and commit the change.
+1. **Confirm version**: Read `lib/ratamin/version.rb`. If $ARGUMENTS differs from the current version, update the file.
 
-2. **Run tests**: `bundle exec rspec` — abort if any tests fail.
+2. **Bundle**: Run `bundle` to update `Gemfile.lock` with the new version.
 
-3. **Update CHANGELOG.md**: Add a new section for this version at the top (below the `## [Unreleased]` header if present), using Keep a Changelog format:
+3. **Run tests**: `bundle exec rspec` — abort if any tests fail.
+
+4. **Update CHANGELOG.md**: Add a new section for this version at the top (below the `## [Unreleased]` header if present), using Keep a Changelog format:
    ```
    ## [X.Y.Z] - YYYY-MM-DD
    ### Added / Changed / Fixed
    - ...
    ```
-   Ask the user what to put in the changelog if there is nothing obvious from recent commits. Commit the changelog update together with any version bump.
+   Ask the user what to put in the changelog if there is nothing obvious from recent commits. Commit `lib/ratamin/version.rb`, `Gemfile.lock`, and `CHANGELOG.md` together in a single commit.
 
-4. **Build the gem**: `gem build ratamin.gemspec`
+5. **Build the gem**: `gem build ratamin.gemspec`
 
-5. **Push to RubyGems**: `gem push ratamin-X.Y.Z.gem`
+6. **Push to RubyGems**: `gem push ratamin-X.Y.Z.gem`
 
-6. **Create git tag**: `git tag vX.Y.Z`
+7. **Create git tag**: `git tag vX.Y.Z`
 
-7. **Push commits and tag**: `git push origin main --tags`
+8. **Push commits and tag**: `git push origin main --tags`
 
-8. **Create GitHub Release**: Extract the release notes for this version from CHANGELOG.md and run:
+9. **Create GitHub Release**: Extract the release notes for this version from CHANGELOG.md and run:
    ```
    gh release create vX.Y.Z --title "vX.Y.Z" --notes-file <(extracted notes)
    ```

data/CHANGELOG.md

@@ -7,6 +7,29 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.0] - 2026-03-15
+
+### Added
+- Create new records with `n` key in table view
+- `create_row(attributes)` method on the `DataSource` protocol
+- Two-mode form UX: select mode (vim-style navigation) and inline edit mode
+- Unsaved changes confirmation dialog when leaving a dirty form
+- Ctrl+E opens `$EDITOR` for any field type (not just `:text`)
+- Vim-style `j`/`k` field navigation in form select mode
+- PageUp/PageDown pagination (replaces `n`/`p`)
+
+### Changed
+- Form title is now dynamic ("New Record" vs "Edit Record")
+- Removed duplicate help text from form body (shown only in status bar)
+- Removed dead code from `TableView#compute_widths`
+
+### Fixed
+- SQL logging no longer interferes with TUI in dev mode (suppressed for entire session)
+- Esc in edit mode now discards field changes (Enter confirms)
+- Save errors display inline instead of crashing
+- Stale in-memory data no longer shown after failed save (record reloaded)
+- Column labels use raw names instead of capitalized
+
 ## [0.2.0] - 2026-03-14
 
 ### Added
@@ -35,6 +58,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - RSpec test suite with in-memory SQLite for ActiveRecord integration tests
 - GitHub Actions CI on Ruby 3.3, 3.4, and 4.0
 
-[Unreleased]: https://github.com/onyxblade/ratamin/compare/v0.2.0...HEAD
+[Unreleased]: https://github.com/onyxblade/ratamin/compare/v0.3.0...HEAD
+[0.3.0]: https://github.com/onyxblade/ratamin/compare/v0.2.0...v0.3.0
 [0.2.0]: https://github.com/onyxblade/ratamin/compare/v0.1.0...v0.2.0
 [0.1.0]: https://github.com/onyxblade/ratamin/releases/tag/v0.1.0

data/README.md

@@ -14,16 +14,9 @@ gem "ratamin"
 
 ## Usage
 
-### Rails integration (recommended)
+### Rails integration (automatic)
 
-Add the Railtie to an initializer to unlock `Model.ratamin` and `scope.ratamin` across your entire app:
-
-```ruby
-# config/initializers/ratamin.rb
-require "ratamin/railtie"
-```
-
-Then define which columns to show in your model:
+In a Rails app, `Model.ratamin` and `scope.ratamin` are available automatically — no configuration needed. Just add the gem and define which columns to show in your model:
 
 ```ruby
 class User < ApplicationRecord
@@ -44,7 +37,7 @@ User.where(role: "admin").ratamin      # filtered scope
 
 Column type (`:text` vs `:string`) and editability (`id`, `created_at`, `updated_at` are read-only by default) are inferred from the schema. Any option explicitly passed to `column` overrides the inferred default.
 
-Without the Railtie, `scope.ratamin` is unavailable. You can still call `User.ratamin` after manually including `Ratamin::ModelMixin` in the model.
+To opt out of the Rails integration, use `require: false` in your Gemfile and `require "ratamin"` manually — `scope.ratamin` will then be unavailable, but the core API still works.
 
 ### Manual usage (without Railtie)
 
@@ -92,19 +85,35 @@ Ratamin::App.new(ds).run
 | `k` / `Up` | Previous row |
 | `g` | First row |
 | `G` | Last row |
-| `Enter` | Edit selected record |
+| `l` / `Enter` | Edit selected record |
 | `r` | Reload data |
-| `q` | Quit |
+| `PageDown` | Next page |
+| `PageUp` | Previous page |
+| `Esc` / `q` | Quit |
 
-### Form view
+### Form view — select mode
 
 | Key | Action |
 |-----|--------|
+| `j` / `Down` | Next field |
+| `k` / `Up` | Previous field |
 | `Tab` | Next field |
 | `Shift+Tab` | Previous field |
-| `Enter` | Save |
-| `Esc` | Cancel |
-| `e` | Open `$EDITOR` (on `:text` fields) |
+| `l` / `Enter` | Edit field |
+| `Ctrl+E` | Open `$EDITOR` |
+| `s` | Save |
+| `h` / `Esc` | Cancel (back to table) |
+
+### Form view — edit mode
+
+| Key | Action |
+|-----|--------|
+| `Enter` | Confirm and move to next field |
+| `Esc` | Discard changes and exit edit |
+| `Ctrl+E` | Open `$EDITOR` |
+| `Left` / `Right` | Move cursor |
+| `Home` / `End` | Jump to start/end |
+| `Backspace` / `Delete` | Delete character |
 
 ## Architecture
 

data/lib/ratamin/app.rb

@@ -9,17 +9,20 @@ module Ratamin
       @table_view = TableView.new(data_source)
       @form_state = nil
       @form_view = nil
+      @form_action = nil
       @mode = :table
     end
 
     def run
-      RatatuiRuby.run do |tui|
-        loop do
-          tui.draw { |frame| render(tui, frame) }
-
-          event = tui.poll_event
-          result = handle_event(event)
-          break if result == :quit
+      @data_source.with_silenced_output do
+        RatatuiRuby.run do |tui|
+          loop do
+            tui.draw { |frame| render(tui, frame) }
+
+            event = tui.poll_event
+            result = handle_event(event)
+            break if result == :quit
+          end
         end
       end
     end
@@ -55,13 +58,20 @@ module Ratamin
     end
 
     def table_help
-      help = " q:quit  j/↓:down  k/↑:up  g:first  G:last  enter:edit  r:reload"
-      help += "  n:next page  p:prev page" if @data_source.paginated?
+      help = " Esc/q:quit  j/↓:down  k/↑:up  g:first  G:last  l/Enter:edit  n:new  r:reload"
+      help += "  PgDn:next  PgUp:prev" if @data_source.paginated?
       help + " "
     end
 
     def form_help
-      " Tab:next field  Shift+Tab:prev  Enter:save  Esc:cancel "
+      case @form_state&.mode
+      when :edit
+        " Esc:discard  Enter:confirm  Ctrl+E:editor "
+      when :confirm_exit
+        " ←/→:switch  Enter:confirm  Esc:back "
+      else
+        " s:save  h/Esc:back  j/k:navigate  l/Enter:edit  Ctrl+E:editor "
+      end
     end
 
     def handle_event(event)
@@ -73,7 +83,7 @@ module Ratamin
 
     def handle_table_event(event)
       case event
-      in {type: :key, code: "q"} | {type: :key, code: "c", modifiers: ["ctrl"]}
+      in {type: :key, code: "q"} | {type: :key, code: "esc"} | {type: :key, code: "c", modifiers: ["ctrl"]}
         :quit
       in {type: :key, code: "j"} | {type: :key, code: "down"}
         @table_view.select_next
@@ -87,14 +97,17 @@ module Ratamin
       in {type: :key, code: "G"} | {type: :key, code: "g", modifiers: ["shift"]}
         @table_view.select_last
         nil
-      in {type: :key, code: "enter"}
+      in {type: :key, code: "enter"} | {type: :key, code: "l"}
         enter_form
         nil
-      in {type: :key, code: "n"} if @data_source.paginated?
+      in {type: :key, code: "n"}
+        enter_new_form
+        nil
+      in {type: :key, code: "page_down"} if @data_source.paginated?
         @data_source.next_page
         @table_view.reset_selection
         nil
-      in {type: :key, code: "p"} if @data_source.paginated?
+      in {type: :key, code: "page_up"} if @data_source.paginated?
         @data_source.prev_page
         @table_view.reset_selection
         nil
@@ -126,6 +139,15 @@ module Ratamin
 
       @form_state = FormState.new(@data_source.columns, row)
       @form_view = FormView.new(@form_state)
+      @form_action = :edit
+      @mode = :form
+    end
+
+    def enter_new_form
+      empty_row = @data_source.columns.each_with_object({}) { |col, h| h[col.key] = "" }
+      @form_state = FormState.new(@data_source.columns, empty_row)
+      @form_view = FormView.new(@form_state, title: " New Record ")
+      @form_action = :create
       @mode = :form
     end
 
@@ -133,17 +155,27 @@ module Ratamin
       @mode = :table
       @form_state = nil
       @form_view = nil
+      @form_action = nil
     end
 
     def save_form
-      idx = @table_view.selected_index
-      return unless idx
+      result = if @form_action == :create
+        @data_source.create_row(@form_state.changes)
+      else
+        idx = @table_view.selected_index
+        return unless idx
+        @data_source.update_row(idx, @form_state.changes)
+      end
 
-      result = @data_source.update_row(idx, @form_state.changes)
       if result.ok?
+        if @form_action == :create
+          @data_source.reload!
+          @table_view.reset_selection
+        end
         exit_form
       else
         @form_state.set_errors(result.errors)
+        @form_state.reset_mode
       end
     end
 

data/lib/ratamin/array_data_source.rb

@@ -22,6 +22,11 @@ module Ratamin
       UpdateResult.success
     end
 
+    def create_row(attributes)
+      @rows << attributes.dup
+      UpdateResult.success
+    end
+
     def reload!
       # no-op for array source
     end

data/lib/ratamin/column.rb

@@ -3,7 +3,7 @@
 module Ratamin
   Column = Data.define(:key, :label, :width, :type, :editable) do
     def initialize(key:, label: nil, width: nil, type: :string, editable: true)
-      super(key: key, label: label || key.to_s.capitalize, width: width, type: type, editable: editable)
+      super(key: key, label: label || key.to_s, width: width, type: type, editable: editable)
     end
   end
 end

data/lib/ratamin/data_source.rb

@@ -7,6 +7,7 @@ module Ratamin
   #   #rows       -> [Hash]  (current page of data)
   #   #row_count  -> Integer
   #   #update_row(index, changes) -> UpdateResult
+  #   #create_row(attributes) -> UpdateResult
   #   #reload!    -> void
   #
   # Pagination (optional, when #paginated? returns true):
@@ -20,5 +21,9 @@ module Ratamin
     def paginated?
       false
     end
+
+    def with_silenced_output
+      yield
+    end
   end
 end

data/lib/ratamin/form_state.rb

@@ -2,7 +2,7 @@
 
 module Ratamin
   class FormState
-    attr_reader :columns, :values, :field_index, :cursor_positions, :errors
+    attr_reader :columns, :values, :field_index, :cursor_positions, :errors, :mode, :confirm_selection
 
     def initialize(columns, row)
       @columns = columns
@@ -11,6 +11,7 @@ module Ratamin
       @field_index = first_editable_index || 0
       @cursor_positions = @values.map(&:length)
       @errors = []
+      @mode = :select
     end
 
     def errors?
@@ -25,47 +26,19 @@ module Ratamin
       @errors = []
     end
 
-    def handle_event(event)
-      # Enter/Esc always work, even when all fields are read-only.
-      case event
-      in {type: :key, code: "enter"}
-        return :save
-      in {type: :key, code: "esc"}
-        return :cancel
-      else
-        nil
-      end
-
-      case event
-      in {type: :key, code: "tab", modifiers: []}
-        return next_field
-      in {type: :key, code: "backtab"} | {type: :key, code: "tab", modifiers: ["shift"]}
-        return prev_field
-      else
-        nil
-      end
+    def reset_mode
+      @mode = :select
+    end
 
-      return nil unless current_column&.editable
+    def dirty?
+      changes.any?
+    end
 
-      case event
-      in {type: :key, code: "e"} if current_column.type == :text
-        return :editor
-      in {type: :key, code: "backspace"}
-        handle_backspace
-      in {type: :key, code: "delete"}
-        handle_delete
-      in {type: :key, code: "left"}
-        move_cursor_left
-      in {type: :key, code: "right"}
-        move_cursor_right
-      in {type: :key, code: "home"}
-        @cursor_positions[@field_index] = 0
-      in {type: :key, code: "end"}
-        @cursor_positions[@field_index] = @values[@field_index].length
-      in {type: :key, code: c, modifiers: []} if c.length == 1
-        insert_char(c)
-      else
-        nil
+    def handle_event(event)
+      case @mode
+      when :select then handle_select_event(event)
+      when :edit then handle_edit_event(event)
+      when :confirm_exit then handle_confirm_exit_event(event)
       end
     end
 
@@ -142,6 +115,92 @@ module Ratamin
 
     private
 
+    def handle_select_event(event)
+      case event
+      in {type: :key, code: "esc"} | {type: :key, code: "h", modifiers: []}
+        if dirty?
+          @confirm_selection = 0
+          @mode = :confirm_exit
+        else
+          return :cancel
+        end
+      in {type: :key, code: "s", modifiers: []}
+        return :save
+      in {type: :key, code: "e", modifiers: ["ctrl"]}
+        return :editor if current_column&.editable
+      in {type: :key, code: "enter"} | {type: :key, code: "l", modifiers: []}
+        enter_edit_mode
+      in {type: :key, code: "j", modifiers: []} | {type: :key, code: "down"}
+        next_field
+      in {type: :key, code: "k", modifiers: []} | {type: :key, code: "up"}
+        prev_field
+      in {type: :key, code: "tab", modifiers: []}
+        next_field
+      in {type: :key, code: "backtab"} | {type: :key, code: "tab", modifiers: ["shift"]}
+        prev_field
+      else
+        nil
+      end
+    end
+
+    def handle_edit_event(event)
+      case event
+      in {type: :key, code: "esc"}
+        discard_edit
+      in {type: :key, code: "enter"}
+        @mode = :select
+      in {type: :key, code: "e", modifiers: ["ctrl"]}
+        return :editor
+      in {type: :key, code: "backspace"}
+        handle_backspace
+      in {type: :key, code: "delete"}
+        handle_delete
+      in {type: :key, code: "left"}
+        move_cursor_left
+      in {type: :key, code: "right"}
+        move_cursor_right
+      in {type: :key, code: "home"}
+        @cursor_positions[@field_index] = 0
+      in {type: :key, code: "end"}
+        @cursor_positions[@field_index] = @values[@field_index].length
+      in {type: :key, code: c, modifiers: []} if c.length == 1
+        insert_char(c)
+      else
+        nil
+      end
+    end
+
+    def handle_confirm_exit_event(event)
+      case event
+      in {type: :key, code: "enter"}
+        @confirm_selection == 0 ? :save : :cancel
+      in {type: :key, code: "h", modifiers: []} | {type: :key, code: "left"} |
+         {type: :key, code: "l", modifiers: []} | {type: :key, code: "right"} |
+         {type: :key, code: "tab"}
+        @confirm_selection = 1 - @confirm_selection
+        nil
+      in {type: :key, code: "esc"}
+        @mode = :select
+        nil
+      else
+        nil
+      end
+    end
+
+    def enter_edit_mode
+      return unless current_column&.editable
+      @edit_snapshot = [@values[@field_index].dup, @cursor_positions[@field_index]]
+      @mode = :edit
+    end
+
+    def discard_edit
+      if @edit_snapshot
+        @values[@field_index], @cursor_positions[@field_index] = @edit_snapshot
+        @edit_snapshot = nil
+      end
+      @mode = :select
+    end
+
     def any_editable?
       columns.any?(&:editable)
     end

data/lib/ratamin/form_view.rb

@@ -2,16 +2,17 @@
 
 module Ratamin
   class FormView
-    attr_reader :state
+    attr_reader :state, :title
 
-    def initialize(state)
+    def initialize(state, title: " Edit Record ")
       @state = state
+      @title = title
     end
 
     def render(tui, frame, area)
       border_style = state.errors? ? {fg: :red} : {fg: :yellow}
       inner_block = tui.block(
-        title: " Edit Record ",
+        title: title,
         borders: [:all],
         border_type: :rounded,
         border_style: border_style
@@ -22,14 +23,8 @@ module Ratamin
       columns = state.columns
 
       constraints = []
-      # Error lines
-      if state.errors?
-        constraints << RatatuiRuby::Layout::Constraint.length(state.errors.length + 1)
-      end
-      # Field rows
+      constraints << RatatuiRuby::Layout::Constraint.length(state.errors.length + 1) if state.errors?
       columns.each { constraints << RatatuiRuby::Layout::Constraint.length(1) }
-      # Help line + spacer
-      constraints << RatatuiRuby::Layout::Constraint.length(1)
       constraints << RatatuiRuby::Layout::Constraint.fill(1)
 
       regions = RatatuiRuby::Layout::Layout.split(
@@ -40,11 +35,9 @@ module Ratamin
 
       region_idx = 0
 
-      # Render errors if present
       if state.errors?
         error_text = state.errors.map { |e| " ! #{e}" }.join("\n")
-        error_widget = tui.paragraph(text: error_text, style: {fg: :red, modifiers: [:bold]})
-        frame.render_widget(error_widget, regions[region_idx])
+        frame.render_widget(tui.paragraph(text: error_text, style: {fg: :red, modifiers: [:bold]}), regions[region_idx])
         region_idx += 1
       end
 
@@ -52,10 +45,11 @@ module Ratamin
 
       columns.each_with_index do |col, i|
         field_area = regions[region_idx + i]
-        label_area, value_area = RatatuiRuby::Layout::Layout.split(
+        marker_area, label_area, value_area = RatatuiRuby::Layout::Layout.split(
           field_area,
           direction: :horizontal,
           constraints: [
+            RatatuiRuby::Layout::Constraint.length(2),
             RatatuiRuby::Layout::Constraint.length(label_width),
             RatatuiRuby::Layout::Constraint.fill(1)
           ]
@@ -64,34 +58,93 @@ module Ratamin
         active = i == state.field_index
 
         if col.editable
+          in_edit = active && state.mode == :edit
+          marker = active ? (in_edit ? "» " : "> ") : "  "
+          marker_style = active ? {fg: :yellow} : {fg: :dark_gray}
           label_style = active ? {fg: :yellow, modifiers: [:bold]} : {fg: :dark_gray}
+
+          frame.render_widget(tui.paragraph(text: marker, style: marker_style), marker_area)
           frame.render_widget(tui.paragraph(text: "#{col.label}: ", style: label_style), label_area)
 
           display_value = if col.type == :text && state.values[i].length > 40
-            "[press 'e' to edit in $EDITOR]"
+            "[Ctrl+E to edit in $EDITOR]"
           else
             state.values[i]
           end
 
-          value_style = active ? {fg: :white, modifiers: [:underlined]} : {fg: :gray}
+          value_style = in_edit ? {fg: :white, modifiers: [:underlined]} : (active ? {fg: :yellow} : {fg: :gray})
           frame.render_widget(tui.paragraph(text: display_value, style: value_style), value_area)
 
-          if active && col.type != :text
+          if in_edit && !(col.type == :text && state.values[i].length > 40)
             cursor_x = value_area.x + [state.cursor_positions[i], value_area.width - 1].min
             frame.set_cursor_position(cursor_x, value_area.y)
           end
         else
+          frame.render_widget(tui.paragraph(text: "  ", style: {fg: :dark_gray}), marker_area)
           frame.render_widget(tui.paragraph(text: "#{col.label}: ", style: {fg: :dark_gray}), label_area)
           frame.render_widget(tui.paragraph(text: state.values[i], style: {fg: :dark_gray, modifiers: [:dim]}), value_area)
         end
       end
 
-      help_area = regions[region_idx + columns.length]
-      help = tui.paragraph(
-        text: " Tab:next  Shift+Tab:prev  Enter:save  Esc:cancel  e:editor(text) ",
-        style: {fg: :dark_gray}
+      render_confirm_dialog(tui, frame, area) if state.mode == :confirm_exit
+    end
+
+    private
+
+    def render_confirm_dialog(tui, frame, area)
+      # Clear overlay area
+      dialog_w = [36, area.width - 4].min
+      dialog_h = 5
+      dialog_x = area.x + (area.width - dialog_w) / 2
+      dialog_y = area.y + (area.height - dialog_h) / 2
+
+      dialog_area = RatatuiRuby::Layout::Rect.new(x: dialog_x, y: dialog_y, width: dialog_w, height: dialog_h)
+      frame.render_widget(tui.clear, dialog_area)
+
+      dialog_block = tui.block(
+        title: " Unsaved changes ",
+        borders: [:all],
+        border_type: :rounded,
+        border_style: {fg: :yellow}
+      )
+      inner = dialog_block.inner(dialog_area)
+      frame.render_widget(dialog_block, dialog_area)
+
+      # Prompt line
+      prompt_area, buttons_area = RatatuiRuby::Layout::Layout.split(
+        inner,
+        direction: :vertical,
+        constraints: [
+          RatatuiRuby::Layout::Constraint.length(1),
+          RatatuiRuby::Layout::Constraint.fill(1)
+        ]
       )
-      frame.render_widget(help, help_area)
+
+      frame.render_widget(
+        tui.paragraph(text: "Save changes before leaving?", style: {fg: :white}),
+        prompt_area
+      )
+
+      # Buttons
+      sel = state.confirm_selection
+      save_style = sel == 0 ? {fg: :black, bg: :yellow, modifiers: [:bold]} : {fg: :dark_gray}
+      discard_style = sel == 1 ? {fg: :black, bg: :yellow, modifiers: [:bold]} : {fg: :dark_gray}
+
+      save_label = sel == 0 ? " [Save] " : "  Save  "
+      discard_label = sel == 1 ? " [Discard] " : "  Discard  "
+
+      btn_save, btn_discard, _ = RatatuiRuby::Layout::Layout.split(
+        buttons_area,
+        direction: :horizontal,
+        constraints: [
+          RatatuiRuby::Layout::Constraint.length(save_label.length),
+          RatatuiRuby::Layout::Constraint.length(discard_label.length),
+          RatatuiRuby::Layout::Constraint.fill(1)
+        ]
+      )
+
+      frame.render_widget(tui.paragraph(text: save_label, style: save_style), btn_save)
+      frame.render_widget(tui.paragraph(text: discard_label, style: discard_style), btn_discard)
     end
   end
 end

data/lib/ratamin/railtie.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require "ratamin"
-require "rails"
-
 module Ratamin
   class Railtie < Rails::Railtie
     initializer "ratamin.extend_active_record" do

data/lib/ratamin/scope_data_source.rb

@@ -50,6 +50,20 @@ module Ratamin
       @records.length
     end
 
+    def create_row(attributes)
+      record = @scope.klass.new
+      cast_attrs = attributes.transform_keys(&:to_s)
+      record.assign_attributes(cast_attrs)
+
+      if record.save
+        UpdateResult.success
+      else
+        UpdateResult.failure(record.errors.full_messages)
+      end
+    rescue => e
+      UpdateResult.failure("#{e.class}: #{e.message}")
+    end
+
     def update_row(index, changes)
       record = @records[index]
       cast_changes = changes.transform_keys(&:to_s)
@@ -58,8 +72,21 @@ module Ratamin
       if record.save
         UpdateResult.success
       else
-        UpdateResult.failure(record.errors.full_messages)
+        errors = record.errors.full_messages
+        record.reload
+        UpdateResult.failure(errors)
       end
+    rescue => e
+      record&.reload rescue nil
+      UpdateResult.failure("#{e.class}: #{e.message}")
+    end
+
+    def with_silenced_output
+      old_logger = ActiveRecord::Base.logger
+      ActiveRecord::Base.logger = nil
+      yield
+    ensure
+      ActiveRecord::Base.logger = old_logger
     end
 
     def reload!

data/lib/ratamin/table_view.rb

@@ -97,10 +97,6 @@ module Ratamin
     end
 
     def compute_widths(columns, available_width)
-      # Reserve space for borders (2) + highlight symbol (2) + column spacing
-      usable = available_width - 4
-      total_spacing = [columns.length - 1, 0].max
-
       columns.map do |col|
         if col.width
           RatatuiRuby::Layout::Constraint.length(col.width)

data/lib/ratamin/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ratamin
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

data/lib/ratamin.rb

@@ -9,3 +9,5 @@ loader.setup
 module Ratamin
   class Error < StandardError; end
 end
+
+require "ratamin/railtie" if defined?(Rails::Railtie)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ratamin
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - merely