ratatui_ruby 0.3.1 → 0.4.0

data/lib/ratatui_ruby/schema/text.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  # Namespace for rich text components (Span and Line).
+  # Distinct from canvas shapes and other Line usages.
+  module Text
+    # A styled string fragment.
+    #
+    # Text is rarely uniform. You need to bold a keyword, colorize an error, or dim a timestamp.
+    #
+    # This class attaches style to content. It pairs a string with visual attributes.
+    #
+    # combine spans into a {Line} to create rich text.
+    #
+    # === Examples
+    #
+    #   Text::Span.new(content: "Error", style: Style.new(fg: :red, modifiers: [:bold]))
+    class Span < Data.define(:content, :style)
+      ##
+      # :attr_reader: content
+      # The text content.
+
+      ##
+      # :attr_reader: style
+      # The style to apply.
+
+      # Creates a new Span.
+      #
+      # [content] String.
+      # [style] Style object (optional).
+      def initialize(content:, style: nil)
+        super
+      end
+
+      # Concise helper for styling.
+      #
+      #   Text::Span.styled("Bold", Style.new(modifiers: [:bold]))
+      def self.styled(content, style = nil)
+        new(content:, style:)
+      end
+    end
+
+    # A sequence of styled spans.
+    #
+    # Words form sentences. Spans form lines.
+    #
+    # This class composes multiple {Span} objects into a single horizontal row of text.
+    # It handles the layout of rich text fragments within the flow of a paragraph.
+    #
+    # Use it to build multi-colored headers, status messages, or log entries.
+    #
+    # === Examples
+    #
+    #   Text::Line.new(
+    #     spans: [
+    #       Text::Span.styled("User: ", Style.new(modifiers: [:bold])),
+    #       Text::Span.styled("kerrick", Style.new(fg: :blue))
+    #     ]
+    #   )
+    class Line < Data.define(:spans, :alignment)
+      ##
+      # :attr_reader: spans
+      # Array of Span objects.
+
+      ##
+      # :attr_reader: alignment
+      # Alignment within the container.
+      #
+      # <tt>:left</tt>, <tt>:center</tt>, or <tt>:right</tt>.
+
+      # Creates a new Line.
+      #
+      # [spans] Array of Span objects (or Strings).
+      # [alignment] Symbol (optional).
+      def initialize(spans: [], alignment: nil)
+        super
+      end
+
+      # Creates a simple line from a string.
+      #
+      #   Text::Line.from_string("Hello")
+      def self.from_string(content, alignment: nil)
+        new(spans: [Span.new(content:, style: nil)], alignment:)
+      end
+    end
+  end
+end

data/lib/ratatui_ruby/session.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+# SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
+# SPDX-License-Identifier: AGPL-3.0-or-later
+
+module RatatuiRuby
+  # Manages the terminal lifecycle and provides a concise API for the render loop.
+  #
+  # Writing a TUI loop involves repetitive boilerplate. You constantly instantiate widgets (<tt>RatatuiRuby::Paragraph.new</tt>) and call global methods (<tt>RatatuiRuby.draw</tt>). This is verbose and hard to read.
+  #
+  # The Session object simplifies this. It acts as a factory and a facade. It provides short helper methods for every widget and delegates core commands to the main module.
+  #
+  # Use it within <tt>RatatuiRuby.run</tt> to build your interface cleanly.
+  #
+  # == Available Methods
+  #
+  # The session dynamically defines factory methods for all RatatuiRuby constants.
+  #
+  # *   <tt>draw(node)</tt> -> Delegates to <tt>RatatuiRuby.draw</tt>
+  # *   <tt>poll_event</tt> -> Delegates to <tt>RatatuiRuby.poll_event</tt>
+  #
+  # === Widget Factories
+  #
+  # The session acts as a dynamic factory. It creates a helper method for **every** class defined in the `RatatuiRuby` module.
+  #
+  # **The Rule:**
+  # To instantiate a class like `RatatuiRuby::SomeWidget`, call `tui.some_widget(...)`.
+  #
+  # **Common Examples:**
+  # *   <tt>paragraph(...)</tt> -> <tt>RatatuiRuby::Paragraph.new(...)</tt>
+  # *   <tt>block(...)</tt> -> <tt>RatatuiRuby::Block.new(...)</tt>
+  # *   <tt>layout(...)</tt> -> <tt>RatatuiRuby::Layout.new(...)</tt>
+  # *   <tt>list(...)</tt> -> <tt>RatatuiRuby::List.new(...)</tt>
+  # *   <tt>table(...)</tt> -> <tt>RatatuiRuby::Table.new(...)</tt>
+  # *   <tt>style(...)</tt> -> <tt>RatatuiRuby::Style.new(...)</tt>
+  #
+  # If a new class is added to the library, it is automatically available here.
+  #
+  # === Nested Helpers
+  #
+  # *   <tt>text_span(...)</tt> -> <tt>RatatuiRuby::Text::Span.new(...)</tt>
+  # *   <tt>text_line(...)</tt> -> <tt>RatatuiRuby::Text::Line.new(...)</tt>
+  #
+  # === Examples
+  #
+  # ==== Basic Usage (Recommended)
+  #
+  #   RatatuiRuby.run do |tui|
+  #     loop do
+  #       tui.draw \
+  #         tui.paragraph \
+  #             text: "Hello, Ratatui! Press 'q' to quit.",
+  #             alignment: :center,
+  #             block: tui.block(
+  #               title: "My Ruby TUI App",
+  #               borders: [:all],
+  #               border_color: "cyan"
+  #             )
+  #       event = tui.poll_event
+  #       break if event == "q" || event == :ctrl_c
+  #     end
+  #   end
+  #
+  # ==== Raw API (Verbose)
+  #
+  #   RatatuiRuby.run do
+  #     loop do
+  #       RatatuiRuby.draw \
+  #         RatatuiRuby::Paragraph.new(
+  #             text: "Hello, Ratatui! Press 'q' to quit.",
+  #             alignment: :center,
+  #             block: RatatuiRuby::Block.new(
+  #               title: "My Ruby TUI App",
+  #               borders: [:all],
+  #               border_color: "cyan"
+  #             )
+  #         )
+  #       event = RatatuiRuby.poll_event
+  #       break if event == "q" || event == :ctrl_c
+  #     end
+  #   end
+  #
+  # ==== Mixed Usage (Flexible)
+  #
+  #   RatatuiRuby.run do |tui|
+  #     loop do
+  #       RatatuiRuby.draw \
+  #         tui.paragraph \
+  #             text: "Hello, Ratatui! Press 'q' to quit.",
+  #             alignment: :center,
+  #             block: tui.block(
+  #               title: "My Ruby TUI App",
+  #               borders: [:all],
+  #               border_color: "cyan"
+  #             )
+  #       event = RatatuiRuby.poll_event
+  #       break if event == "q" || event == :ctrl_c
+  #     end
+  #   end
+  class Session
+    # Wrap methods directly
+    RatatuiRuby.singleton_methods(false).each do |method_name|
+      define_method(method_name) do |*args, **kwargs, &block|
+        RatatuiRuby.public_send(method_name, *args, **kwargs, &block)
+      end
+    end
+
+    # Wrap classes as snake_case factories
+    RatatuiRuby.constants.each do |const_name|
+      next if const_name == :Buffer
+
+      klass = RatatuiRuby.const_get(const_name)
+      next unless klass.is_a?(Class)
+
+      method_name = const_name.to_s
+                              .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                              .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                              .downcase
+
+      define_method(method_name) do |*args, **kwargs, &block|
+        klass.new(*args, **kwargs, &block)
+      end
+    end
+
+    # Wrap nested module classes with prefixed names (e.g., shape_line, text_span)
+    { Shape: :shape, Text: :text }.each do |mod_name, prefix|
+      next unless RatatuiRuby.const_defined?(mod_name)
+
+      mod = RatatuiRuby.const_get(mod_name)
+      mod.constants.each do |const_name|
+        klass = mod.const_get(const_name)
+        next unless klass.is_a?(Class)
+
+        class_snake = const_name.to_s
+                                .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+                                .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                                .downcase
+        method_name = "#{prefix}_#{class_snake}"
+
+        define_method(method_name) do |*args, **kwargs, &block|
+          klass.new(*args, **kwargs, &block)
+        end
+      end
+    end
+  end
+end

data/lib/ratatui_ruby/test_helper.rb

@@ -1,4 +1,8 @@
 # frozen_string_literal: true
+require "timeout"
+require "minitest/mock"
+
+
 
 # SPDX-FileCopyrightText: 2025 Kerrick Long <me@kerricklong.com>
 # SPDX-License-Identifier: AGPL-3.0-or-later
@@ -8,7 +12,7 @@ module RatatuiRuby
   # Helpers for testing RatatuiRuby applications.
   #
   # This module provides methods to set up a test terminal, capture buffer content,
-  # and check cursor position, making it easier to write unit tests for your TUI apps.
+  # and inject events, making it easier to write unit tests for your TUI apps.
   #
   # == Usage
   #
@@ -18,24 +22,50 @@ module RatatuiRuby
   #     include RatatuiRuby::TestHelper
   #
   #     def test_rendering
-  #       with_test_terminal(width: 80, height: 24) do
+  #       with_test_terminal(80, 24) do
   #         # ... render your app ...
   #         assert_includes buffer_content, "Hello World"
   #       end
   #     end
+  #
+  #     def test_key_handling
+  #       inject_event(RatatuiRuby::Event::Key.new(code: "q"))
+  #       result = @app.handle_input
+  #       assert_equal :quit, result
+  #     end
   #   end
   module TestHelper
     ##
     # Initializes a test terminal context with specified dimensions.
     # Restores the original terminal state after the block executes.
     #
-    # +width+:: width of the test terminal (default: 20)
-    # +height+:: height of the test terminal (default: 10)
+    # +width+:: width of the test terminal (default: 80)
+    # +height+:: height of the test terminal (default: 24)
+    #
+    # +timeout+:: maximum execution time in seconds (default: 2). Pass nil to disable.
     #
     # If a block is given, it is executed within the test terminal context.
-    def with_test_terminal(width = 20, height = 10)
+    def with_test_terminal(width = 80, height = 24, timeout: 2)
       RatatuiRuby.init_test_terminal(width, height)
-      yield
+      # Flush any lingering events from previous tests
+      while RatatuiRuby.poll_event; end
+
+      RatatuiRuby.stub :init_terminal, nil do
+        RatatuiRuby.stub :restore_terminal, nil do
+          begin
+            @_ratatui_test_terminal_active = true
+            if timeout
+              Timeout.timeout(timeout) do
+                yield
+              end
+            else
+              yield
+            end
+          ensure
+            @_ratatui_test_terminal_active = false
+          end
+        end
+      end
     ensure
       RatatuiRuby.restore_terminal
     end
@@ -61,15 +91,128 @@ module RatatuiRuby
     end
 
     ##
-    # Injects a mock event into the event queue for testing purposes.
+    # Injects an event into the event queue for testing.
+    #
+    # Pass any RatatuiRuby::Event object. The event will be returned by
+    # the next call to RatatuiRuby.poll_event.
+    #
+    # Raises a +RuntimeError+ if called outside of a +with_test_terminal+ block.
     #
-    # +event_type+:: "key" or "mouse"
-    # +data+:: a Hash containing event data
+    # == Examples
     #
-    #   inject_event("key", { code: "a" })
-    #   inject_event("mouse", { kind: "down", x: 0, y: 0 })
-    def inject_event(event_type, data)
-      RatatuiRuby.inject_test_event(event_type, data)
+    #   with_test_terminal do
+    #     # Key events
+    #     inject_event(RatatuiRuby::Event::Key.new(code: "q"))
+    #     inject_event(RatatuiRuby::Event::Key.new(code: "s", modifiers: ["ctrl"]))
+    #
+    #     # Mouse events
+    #     inject_event(RatatuiRuby::Event::Mouse.new(kind: "down", button: "left", x: 10, y: 5))
+    #
+    #     # Resize events
+    #     inject_event(RatatuiRuby::Event::Resize.new(width: 120, height: 40))
+    #
+    #     # Paste events
+    #     inject_event(RatatuiRuby::Event::Paste.new(content: "Hello"))
+    #
+    #     # Focus events
+    #     inject_event(RatatuiRuby::Event::FocusGained.new)
+    #     inject_event(RatatuiRuby::Event::FocusLost.new)
+    #   end
+    def inject_event(event)
+      unless @_ratatui_test_terminal_active
+        raise "Events must be injected inside a `with_test_terminal` block. " \
+              "Calling this method outside the block causes a race condition where the event " \
+              "is flushed before the application starts."
+      end
+
+      case event
+      when RatatuiRuby::Event::Key
+        RatatuiRuby.inject_test_event("key", { code: event.code, modifiers: event.modifiers })
+      when RatatuiRuby::Event::Mouse
+        RatatuiRuby.inject_test_event("mouse", {
+          kind: event.kind,
+          button: event.button,
+          x: event.x,
+          y: event.y,
+          modifiers: event.modifiers
+        })
+      when RatatuiRuby::Event::Resize
+        RatatuiRuby.inject_test_event("resize", { width: event.width, height: event.height })
+      when RatatuiRuby::Event::Paste
+        RatatuiRuby.inject_test_event("paste", { content: event.content })
+      when RatatuiRuby::Event::FocusGained
+        RatatuiRuby.inject_test_event("focus_gained", {})
+      when RatatuiRuby::Event::FocusLost
+        RatatuiRuby.inject_test_event("focus_lost", {})
+      else
+        raise ArgumentError, "Unknown event type: #{event.class}"
+      end
+    end
+
+    ##
+    # Injects multiple Key events into the queue.
+    #
+    # Supports multiple formats for convenience:
+    #
+    # * String: Converted to a Key event with that code.
+    # * Symbol: Parsed as modifier_code (e.g., <tt>:ctrl_c</tt>, <tt>:enter</tt>).
+    # * Hash: Passed to Key.new constructor.
+    # * Key: Passed directly.
+    #
+    # == Examples
+    #
+    #   with_test_terminal do
+    #     inject_keys("a", "b", "c")
+    #     inject_keys(:enter, :esc)
+    #     inject_keys(:ctrl_c, :alt_shift_left)
+    #     inject_keys("j", { code: "k", modifiers: ["ctrl"] })
+    #   end
+    def inject_keys(*args)
+      args.each do |arg|
+        event = case arg
+                when String
+                  RatatuiRuby::Event::Key.new(code: arg)
+                when Symbol
+                  parts = arg.to_s.split("_")
+                  code = parts.pop
+                  modifiers = parts
+                  RatatuiRuby::Event::Key.new(code: code, modifiers: modifiers)
+                when Hash
+                  RatatuiRuby::Event::Key.new(**arg)
+                when RatatuiRuby::Event::Key
+                  arg
+                else
+                  raise ArgumentError, "Invalid key argument: #{arg.inspect}. Expected String, Symbol, Hash, or Key event."
+                end
+        inject_event(event)
+      end
+    end
+    alias inject_key inject_keys
+
+    ##
+    # Returns the cell attributes at the given coordinates.
+    #
+    #   get_cell(0, 0)
+    #   # => { "symbol" => "H", "fg" => :red, "bg" => nil }
+    def get_cell(x, y)
+      RatatuiRuby.get_cell_at(x, y)
+    end
+
+    ##
+    # Asserts that the cell at the given coordinates has the expected attributes.
+    #
+    #   assert_cell_style(0, 0, char: "H", fg: :red)
+    def assert_cell_style(x, y, **expected_attributes)
+      cell = get_cell(x, y)
+      expected_attributes.each do |key, value|
+        actual_value = cell.public_send(key)
+        if value.nil?
+          assert_nil actual_value, "Expected cell at (#{x}, #{y}) to have #{key}=nil, but got #{actual_value.inspect}"
+        else
+          assert_equal value, actual_value, "Expected cell at (#{x}, #{y}) to have #{key}=#{value.inspect}, but got #{actual_value.inspect}"
+        end
+      end
     end
   end
 end
+

data/lib/ratatui_ruby/version.rb

@@ -6,5 +6,5 @@
 module RatatuiRuby
   # The version of the ratatui_ruby gem.
   # See https://semver.org/spec/v2.0.0.html
-  VERSION = "0.3.1"
+  VERSION = "0.4.0"
 end

data/lib/ratatui_ruby.rb

@@ -12,9 +12,12 @@ require_relative "ratatui_ruby/schema/constraint"
 require_relative "ratatui_ruby/schema/list"
 require_relative "ratatui_ruby/schema/style"
 require_relative "ratatui_ruby/schema/gauge"
+require_relative "ratatui_ruby/schema/line_gauge"
 require_relative "ratatui_ruby/schema/table"
 require_relative "ratatui_ruby/schema/tabs"
 require_relative "ratatui_ruby/schema/bar_chart"
+require_relative "ratatui_ruby/schema/bar_chart/bar"
+require_relative "ratatui_ruby/schema/bar_chart/bar_group"
 require_relative "ratatui_ruby/schema/sparkline"
 require_relative "ratatui_ruby/schema/chart"
 require_relative "ratatui_ruby/schema/clear"
@@ -23,7 +26,14 @@ require_relative "ratatui_ruby/schema/overlay"
 require_relative "ratatui_ruby/schema/center"
 require_relative "ratatui_ruby/schema/scrollbar"
 require_relative "ratatui_ruby/schema/canvas"
+require_relative "ratatui_ruby/schema/shape/label"
 require_relative "ratatui_ruby/schema/calendar"
+require_relative "ratatui_ruby/schema/ratatui_logo"
+require_relative "ratatui_ruby/schema/ratatui_mascot"
+require_relative "ratatui_ruby/schema/text"
+require_relative "ratatui_ruby/schema/draw"
+require_relative "ratatui_ruby/event"
+require_relative "ratatui_ruby/cell"
 
 begin
   require "ratatui_ruby/ratatui_ruby"
@@ -32,20 +42,53 @@ rescue LoadError
   require_relative "ratatui_ruby/ratatui_ruby"
 end
 
-# The RatatuiRuby module acts as a namespace for the entire gem.
-# It provides the main entry points for initializing the terminal and drawing the UI.
+# Main entry point for the library.
+#
+# Terminal UIs require low-level control using C/Rust and high-level abstraction in Ruby.
+#
+# This module bridges the gap. It provides the native methods to initialize the terminal, handle raw mode, and render the widget tree.
+#
+# Use `RatatuiRuby.run` to start your application.
 module RatatuiRuby
   # Generic error class for RatatuiRuby.
   class Error < StandardError; end
 
   ##
-  # :method: init_terminal
-  # :call-seq: init_terminal() -> nil
-  #
   # Initializes the terminal for TUI mode.
   # Enters alternate screen and enables raw mode.
   #
-  # (Native method implemented in Rust)
+  # [focus_events] whether to enable focus gain/loss events (default: true).
+  # [bracketed_paste] whether to enable bracketed paste mode (default: true).
+  def self.init_terminal(focus_events: true, bracketed_paste: true)
+    _init_terminal(focus_events, bracketed_paste)
+  end
+
+  @experimental_warnings = true
+  class << self
+    ##
+    # :attr_accessor: experimental_warnings
+    # Whether to show warnings when using experimental features (default: true).
+    attr_accessor :experimental_warnings
+  end
+
+  ##
+  # Warns about usage of an experimental feature unless warnings are suppressed.
+  #
+  # [feature_name] String name of the feature (e.g., "Paragraph#line_count")
+  #
+  # This warns only once per feature name per session.
+  def self.warn_experimental_feature(feature_name)
+    return unless experimental_warnings
+
+    @warned_features ||= {}
+    return if @warned_features[feature_name]
+
+    warn "WARNING: #{feature_name} is an experimental feature and may change in future versions. Disable this warning with RatatuiRuby.experimental_warnings = false."
+    @warned_features[feature_name] = true
+  end
+
+  # (Native method _init_terminal implemented in Rust)
+  private_class_method :_init_terminal
 
   ##
   # :method: restore_terminal
@@ -67,14 +110,49 @@ module RatatuiRuby
 
   ##
   # :method: poll_event
-  # :call-seq: poll_event() -> Hash, nil
+  # :call-seq: poll_event() -> Event, nil
   #
-  # Polls for a keyboard event.
+  # Checks for user input.
   #
-  #   poll_event
-  #   # => { type: :key, code: "a", modifiers: ["ctrl"] }
+  # Returns a discrete event (Key, Mouse, Resize) if one is available in the queue.
+  # Returns nil immediately if the queue is empty (non-blocking).
   #
-  # (Native method implemented in Rust)
+  # === Example
+  #
+  #   event = RatatuiRuby.poll_event
+  #   puts "Key pressed" if event.is_a?(RatatuiRuby::Event::Key)
+  #
+  def self.poll_event
+    raw = _poll_event
+    return nil if raw.nil?
+
+    case raw[:type]
+    when :key
+      Event::Key.new(code: raw[:code], modifiers: raw[:modifiers] || [])
+    when :mouse
+      Event::Mouse.new(
+        kind: raw[:kind].to_s,
+        x: raw[:x],
+        y: raw[:y],
+        button: raw[:button].to_s,
+        modifiers: raw[:modifiers] || []
+      )
+    when :resize
+      Event::Resize.new(width: raw[:width], height: raw[:height])
+    when :paste
+      Event::Paste.new(content: raw[:content])
+    when :focus_gained
+      Event::FocusGained.new
+    when :focus_lost
+      Event::FocusLost.new
+    else
+      # Fallback for unknown events, though ideally we cover them all
+      nil
+    end
+  end
+
+  # (Native method _poll_event implemented in Rust)
+  private_class_method :_poll_event
 
   ##
   # :method: inject_test_event
@@ -89,21 +167,63 @@ module RatatuiRuby
   # (Native method implemented in Rust)
 
   ##
-  # Provides a convenience wrapper for the main TUI loop.
-  # Initializes the terminal, runs the loop, and ensures the terminal is restored.
+  # :method: run
+  # :call-seq: run { |session| ... } -> Object
+  #
+  # Starts the TUI application lifecycle.
+  #
+  # Managing generic setup/teardown (raw mode, alternate screen) manualy is error-prone. If your app crashes, the terminal might be left in a broken state.
+  #
+  # This method handles the safety net. It initializes the terminal, yields a {Session}, and ensures the terminal state is restored even if exceptions occur.
+  #
+  # === Example
   #
-  #   RatatuiRuby.main_loop do
-  #     draw RatatuiRuby::Paragraph.new(text: "Hello")
-  #     event = RatatuiRuby::poll_event
-  #     break if event && event[:type] == :key && event[:code] == "q"
+  #   RatatuiRuby.run(focus_events: false) do |tui|
+  #     tui.draw(tui.paragraph(text: "Hi"))
+  #     sleep 1
   #   end
-  def self.main_loop
-    require_relative "ratatui_ruby/dsl"
-    init_terminal
-    loop do
-      yield DSL.new
-    end
+  def self.run(focus_events: true, bracketed_paste: true)
+    require_relative "ratatui_ruby/session"
+    init_terminal(focus_events: focus_events, bracketed_paste: bracketed_paste)
+    yield Session.new
   ensure
     restore_terminal
   end
+
+  ##
+  # :method: get_cell_at
+  # :call-seq: get_cell_at(x, y) -> Cell
+  #
+  # Inspects the terminal buffer at specific coordinates.
+  #
+  # When writing tests, you need to verify that your widget drew the correct characters and styles.
+  # This method provides deep inspection of the cell's state (symbol, colors, modifiers).
+  #
+  # Returns a {Cell} object.
+  #
+  # Values depend on what the backend has rendered. If nothing has been rendered to a cell, it may contain defaults (empty symbol, nil colors).
+  #
+  # === Example
+  #
+  #   cell = RatatuiRuby.get_cell_at(10, 5)
+  #   expect(cell.symbol).to eq("X")
+  #   expect(cell.fg).to eq(:red)
+  #   expect(cell).to be_bold
+  #
+  def self.get_cell_at(x, y)
+    raw = _get_cell_at(x, y)
+    Cell.new(
+      char: raw["char"],
+      fg: raw["fg"],
+      bg: raw["bg"],
+      modifiers: raw["modifiers"] || []
+    )
+  end
+
+  # (Native method _get_cell_at implemented in Rust)
+  private_class_method :_get_cell_at
+
+  # Hide native Layout._split helper
+  Layout.singleton_class.send(:private, :_split)
+
 end