ruflet_rails 0.0.15 → 0.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb81df616c3834d41ea9599f851ea1bc30457e7102ee1eb55e23d17b5afc5a79
-  data.tar.gz: 8f4e10fb6d907f9095ebac09c2c4496b5267c5c4d0ae79d95d7a429b7e6f33ea
+  metadata.gz: 6868764b9b4a6920b449c8b46bc937558c97edcafc76b361a8e6873b93b3188b
+  data.tar.gz: 00ab29dcc01cb4e21dee34946c6a42dd7293f1053eb1abc71207f9dcffdf780e
 SHA512:
-  metadata.gz: c5d92c8138d67b554a8cba1522a46135dc01188454b182fb242a59ec06472da1c0ccc6ed76064ee96432bb51833342b3236607b61ebb9e115fbcaa535ca94341
-  data.tar.gz: ab2163eb77d3608ca0e933f9a3ca6eee1f369fc5e08e03927d3099c58de81e0da4df6e18519c87fbae0da1b93bf9bb1abfc6bc711bab03837bb15347ab05f6fe
+  metadata.gz: 2ed38b850ec571aadda2fc52f41309dc869e7484bee93a6b3ef2d0fce222aa11d872e63eb97e6beec9f2b6142eeebd244e183b434585d8daf6f66938603e3eb2
+  data.tar.gz: bab03d623d130b47169cb9fa098edba6f7f9cea739f50e8156e142fd1d033577d6ae4e28412003a6dd128ca706bba66ac5fe3608ef4b1ce9d8a00ae6811b5cb8

data/README.md

@@ -3,8 +3,8 @@
 `ruflet_rails` is the Rails-first integration package for Ruflet.
 
 It mounts Ruby-driven Ruflet interfaces in a Rails application, makes Rails
-views able to opt into native WebView chrome, and connects web, mobile, and
-desktop clients to the same application entrypoint.
+views able to opt into native WebView chrome, and connects Ruflet clients to
+the same application entrypoint.
 
 ## Add The Gem
 
@@ -17,18 +17,15 @@ gem "ruflet_rails"
 
 ```bash
 bin/rails generate ruflet:install
-bin/rails generate ruflet:install --web
 bin/rails generate ruflet:install --desktop
-bin/rails generate ruflet:install --web --desktop
 ```
 
 This generator will:
 - create `app/views/ruflet/main.rb`
 - create `config/initializers/ruflet.rb`
 - add the Ruflet WebSocket route to `config/routes.rb`
-- add a `/ruflet` web mount when `--web` is used
-- download prebuilt clients from GitHub releases when `--web`, `--desktop`, or
-  `--client=web|desktop|all` is used
+- download the prebuilt desktop client when `--desktop` or
+  `--client=desktop` is used
 
 Generated `config/initializers/ruflet.rb`:
 
@@ -48,24 +45,17 @@ At build time `ruflet_rails` serializes this Rails config into the Ruflet CLI
 config shape, so the initializer remains the source of truth for app name,
 backend URL, services, assets, and build colors.
 
-## Web client
+## Connect a Ruflet client
 
-Rails installs the prebuilt web client into `frontend/`; it does not need
-Flutter source or a Flutter web build:
-
-```bash
-bundle exec rake ruflet:web
-```
-
-Mount the installed client and a developer-owned Ruflet entrypoint:
+The generator adds an explicit WebSocket endpoint backed by the application
+entrypoint:
 
 ```ruby
-mount Ruflet::Rails.web_app(app_file: Rails.root.join("app/views/ruflet/main.rb")), at: "/app"
+match "/ws", to: Ruflet::Rails.native(Rails.root.join("app/views/ruflet/main.rb")), via: :all
 ```
 
-The install generator adds the same mount at `/ruflet` when `--web` is used.
-The mount serves the static client and its WebSocket endpoint together. The
-same `main.rb` also drives native clients through the generated `/ws` route.
+Start Rails, then connect a Ruflet mobile or desktop client to that endpoint.
+The Rails gem does not install or serve a second static web application.
 
 ## Build native clients from Rails
 
@@ -100,12 +90,11 @@ bin/rails server --desktop
 bin/rails s --desktop
 ```
 
-## Update prebuilt clients
+## Update the prebuilt desktop client
 
-Reinstall web or update native desktop clients:
+Update the native desktop client:
 
 ```bash
-bundle exec rake ruflet:web
 bundle exec rake ruflet:update[desktop]
 ```
 
@@ -120,11 +109,214 @@ bundle exec rake ruflet:install
 bundle exec rake ruflet:install[DEVICE_ID]
 ```
 
+## HTML as the UI DSL (no WebView)
+
+Beyond the WebView shell, Ruflet can treat HTML itself as the UI language:
+Rails views describe screens with markup, and `Ruflet::Rails.erb_to_native`
+compiles each page into **real native Ruflet controls** — no WebView anywhere.
+This is HTML-over-the-wire for native UI: state lives in Rails, every
+interaction is a request, and the response markup re-renders the screen.
+
+```ruby
+# app/views/ruflet/main.rb
+Ruflet.run do |page|
+  Ruflet::Rails.erb_to_native(page, start_url: "/native")
+end
+```
+
+Screens are ordinary Rails views (ERB, controllers, sessions, and redirects
+all work — requests carry the Rails session cookie and CSRF token, plus an
+`X-Ruflet-Native: 1` header so a controller can render native markup and a
+browser page from the same action):
+
+```erb
+<%# app/views/counters/show.html.erb %>
+<appbar title="Counter"></appbar>
+
+<column class="p-6 gap-4 items-center justify-center flex-1">
+  <text class="text-5xl font-bold text-slate-900"><%= @count %></text>
+  <row class="gap-3">
+    <button variant="outlined" icon="remove" on-click="<%= counter_decrement_path %>">Down</button>
+    <button variant="filled" icon="add" on-click="<%= counter_increment_path %>">Up</button>
+  </row>
+  <a href="<%= settings_path %>">Settings</a>
+</column>
+```
+
+- **Layout** — `<column>`, `<row>`, `<stack>`, `<div>`/`<section>` (container),
+  `<card>`, `<center>`, `<spacer>`, `<list>`, `<grid>`.
+- **Content** — `<text>`, `<h1>`–`<h6>`, `<p>`, `<markdown>`, `<img>`, `<icon>`,
+  `<hr>`, `<ul>`/`<li>`.
+- **Styling** — a broad Tailwind-flavored `class` vocabulary that maps onto
+  each control's real props (only the ones a control accepts are applied):
+  - spacing & size: `p-4`, `px-6`, `m-2`, `-mt-2`, `gap-3`, `w-64`, `h-full`,
+    `flex-1`, `aspect-video`, `aspect-[4/3]`
+  - color: `bg-slate-100`, `text-emerald-600`, `bg-[#123456]`, theme tokens
+    (`bg-primary`, `text-on-surface`), gradients
+    (`bg-gradient-to-r from-blue-500 via-sky-400 to-cyan-300`)
+  - typography: `text-xl`, `text-[42]`, `font-bold`, `font-mono`, `italic`,
+    `text-center`, `tracking-wide`, `leading-relaxed`, `underline`,
+    `line-through`, `uppercase`/`lowercase`/`capitalize`, `truncate`,
+    `line-clamp-2`, `whitespace-nowrap`, `select-none`, `text-ellipsis`
+  - shape & borders: `rounded-2xl`, `rounded-t-lg`, `rounded-br-sm`, `border`,
+    `border-2`, `border-t`, `border-red-500`, `shadow-lg`, `opacity-75`, `blur-md`
+  - transforms & position: `rotate-45`, `-rotate-12`, `scale-95`, `top-4`,
+    `left-2`, `inset-0`/`inset-x-4` (Stack children)
+  - transitions: `transition`, `duration-300`, `ease-in-out` (implicit animation)
+  - layout & display: `items-center`, `justify-between`, `place-center`,
+    `flex-wrap`, `gap-x-3`/`gap-y-2`, `size-12`, `w-screen`, `min-h-screen`,
+    `scroll`, `overflow-hidden`, `object-cover` (image fit), `hidden`/`invisible`
+  Anything not mapped is ignored; the full native prop is always available as
+  an explicit attribute (`gradient='{…}'`, `blur="8"`, …).
+- **Navigation** — `<a href>` pushes a native screen; `nav="replace|root|back"`
+  change the mode. The native back button/gesture pops.
+- **Actions** — `on-click="/counter/increment"` posts to Rails and re-renders
+  the current screen in place with the response (`redirect_to` is followed).
+  Prefix a verb for other methods: `on-click="delete:/items/3"`.
+- **Forms** — `<form action method>` with named `<input>`, `<textarea>`,
+  `<select>` fields tracks values natively and submits them like a normal
+  Rails form, then renders the response.
+- **App chrome** — `<appbar title="Inbox" leading-icon="menu">` with
+  `<action icon="search" href="/search"/>` children becomes the native AppBar.
+- **The whole widget catalog** — any other tag falls through to the ruflet_core
+  control registry with its attributes as props:
+  `<progress-bar value="0.4">`, `<switch label="Dark mode">`,
+  `<chip label="New">`… kebab-case maps to the control name.
+
+**First-class components** — these have dedicated tags/helpers that map to the
+right native shape (some Ruflet "components" are *props* on another control,
+not controls of their own — the DSL handles that for you):
+
+| Tag | Helper | Notes |
+| --- | --- | --- |
+| `<badge label="3">…</badge>` | `badge` | wraps its child; badge is a prop on it |
+| `<tooltip message="…">…</tooltip>` | `tooltip` | prop on its child |
+| `<chip label="Ruby" icon="star">` | `chip` | text → `label`; `on-click`/`href` supported |
+| `<avatar src>` / `<avatar>AM</avatar>` | `avatar` | image or initials |
+| `<list-tile title subtitle leading href>` | `list_tile` | taps navigate/act natively |
+| `<expansion-tile title>…</expansion-tile>` | `expansion_tile` | collapsible section |
+| `<switch>` `<checkbox>` `<slider>` `<radio>` | same | standalone; `name` makes them form fields |
+| `<radio-group name value>…radios…</radio-group>` | `radio_group` | |
+| `<segmented-button name value>…<segment>…</segmented-button>` | `segmented_button` | |
+| `<tabs><tab label icon>…</tab></tabs>` | `tabs` / `tab` | native TabBar + panes |
+| `<table><thead><tr><th>…` | — | plain HTML tables → native `DataTable` |
+| `<fab icon href>` | `fab` | mounts as the screen's FloatingActionButton |
+| `<bottom-nav><nav-item icon label href selected>…` | `bottom_nav` / `nav_item` | screen's NavigationBar; a tab resets to that URL as root |
+
+**Every Ruflet control is reachable.** Any tag without a dedicated builder
+maps straight onto the ruflet_core control registry — the entire catalog
+(charts, canvas, cupertino_*, maps, sensors, list/menu/expansion controls, …)
+works from markup. The passthrough is schema-aware: a control's text and child
+elements are routed into whichever prop it actually accepts (`content`,
+`controls`, `label`, `title`), so `<filled-button>Save</filled-button>`,
+`<banner><text>…</text></banner>`, and `<responsive-row>…</responsive-row>`
+all build correctly. Use the raw tag (kebab-case → control name) or the
+`widget` helper:
+
+```erb
+<%= widget "bar-chart", expand: true do %>
+  <%= widget "bar-chart-group", x: 0 do %>
+    <%= widget "bar-chart-rod", from_y: 0, to_y: 10 %>
+  <% end %>
+<% end %>
+
+<cupertino-activity-indicator animating="true"></cupertino-activity-indicator>
+```
+
+**Services and extensions.** Non-visual platform services (`<geolocator>`,
+`<battery>`, `<clipboard>`, `<flashlight>`, `<permission-handler>`,
+`<secure-storage>`, `<shared-preferences>`, `<file-picker>`, `<wakelock>`,
+`<share>`, `<url-launcher>`, the sensors, …) are non-visual: declaring one
+mounts it on the screen's service registry rather than in the layout. Extension
+controls that *do* render (`<camera>`, `<audio>`, `<video>`, `<lottie>`,
+`<rive>`, `<map>`, `<code-editor>`, `<web-view>`, `<spinkit>`,
+`<color-picker>`, the charts) render inline like any other control. Each has a
+matching helper:
+
+```erb
+<%= geolocator %>
+<%= camera id: "camera-preview", preview_enabled: true %>
+<%= video src: "clip.mp4" %>
+<%= lottie src: "loader.json" %>
+<%= map do %><%= widget "tile-layer", url_template: "…" %><% end %>
+```
+
+Buttons can invoke native services without a request back to Rails. Common
+operations have short names, and the open-ended `method`/`args` form exposes
+new service methods without waiting for another `ruflet_rails` release:
+
+```erb
+<%= button "Copy", service: "copy", text: "Hello from Rails" %>
+<%= button "Locate", service: "location" %>
+<%= button "Allow camera",
+           service: "permission-handler",
+           method: "request",
+           args: { permission: "camera" } %>
+```
+
+An inline extension can also be controlled by its native ID:
+
+```erb
+<%= audio id: "player", src: "https://example.com/song.mp3" %>
+<%= button "Play", service: "control", target: "player", method: "play" %>
+<%= button "Seek", service: "control", target: "player",
+                   method: "seek", position: 2_000 %>
+```
+
+Service results and errors are reported in a native dialog by default. For a
+stream such as an accelerometer, pass `result_target: "status-control-id"` to
+update an inline Text control instead.
+
+```erb
+<%# a form, natively rendered %>
+<form action="<%= session_path %>" method="post">
+  <column class="p-6 gap-4">
+    <h2>Sign in</h2>
+    <input type="email" name="email" label="Email" placeholder="you@example.com">
+    <input type="password" name="password" label="Password">
+    <input type="checkbox" name="remember" label="Remember me" checked>
+    <input type="submit" value="Sign in">
+  </column>
+</form>
+```
+
+### Ruby helper DSL
+
+The same markup can be authored with Ruby helpers (auto-included into
+ActionView), and both styles mix freely in one template. Attribute keys are
+snake_case and become kebab-case attributes (`on_click:` → `on-click`);
+Hash/Array values serialize as JSON:
+
+```erb
+<%= appbar "Counter" %>
+
+<%= column class: "p-6 gap-6 items-center justify-center flex-1" do %>
+  <%= text @count, class: "text-[96] font-bold" %>
+  <%= row class: "gap-3" do %>
+    <%= button "Down", variant: "outlined", icon: "remove",
+               on_click: counter_decrement_path %>
+    <%= button "Up", variant: "filled", icon: "add",
+               on_click: counter_increment_path %>
+  <% end %>
+  <%= link "Settings", settings_path %>
+<% end %>
+```
+
+Available helpers: layout (`column`, `row`, `stack`, `card`, `center`,
+`list`, `grid`, `spacer`, `divider`), content (`text`, `h1`–`h6`/`heading`,
+`markdown`, `image`, `icon`), interaction (`button`, `link`), chrome
+(`appbar`, `appbar_action`), forms (`form`, `input`, `textarea`, `dropdown`,
+`submit`), and `widget("progress-bar", value: 0.4)` for anything else in the
+control registry.
+
+Pick the mode per app: `erb_to_native` when HTML should *become* native controls,
+`native_shell` when you want the real web page in a WebView with native chrome.
+
 ## Native WebView shell
 
 Beyond the server-driven UI, Ruflet can wrap an existing Rails HTML app in a
 managed native WebView. This is an opt-in shell: calling
-`Ruflet::Rails.native_app` wraps web pages in a native Ruflet shell whose body is
+`Ruflet::Rails.native_shell` wraps web pages in a native Ruflet shell whose body is
 a WebView. Plain `Ruflet.run { |page| ... }` remains a normal Ruflet app with no
 WebView wrapper or HTML adapter.
 
@@ -136,7 +328,7 @@ promote page chrome.
 ```ruby
 # app/views/ruflet/main.rb
 Ruflet.run do |page|
-  Ruflet::Rails.native_app(
+  Ruflet::Rails.native_shell(
     page,
     start_url: "https://myapp.com",
     title: "My App",                       # opt into a native AppBar (tracks <title>)
@@ -290,13 +482,13 @@ Add `data-ruflet-close="false"` when a sheet link should not dismiss:
 <%= ruflet_haptic_button "Tap", style: "light" %>
 ```
 
-For a Fizzy-style web app, keep `Ruflet::Rails.native_app` simple and opt in from
+For a Fizzy-style web app, keep `Ruflet::Rails.native_shell` simple and opt in from
 the views that need native treatment:
 
 ```ruby
 # app/views/ruflet/main.rb
 Ruflet.run do |page|
-  Ruflet::Rails.native_app(page, start_url: "#{Ruflet::Rails.backend_url}/")
+  Ruflet::Rails.native_shell(page, start_url: "#{Ruflet::Rails.backend_url}/")
 end
 ```
 
@@ -315,7 +507,7 @@ end
 Mount it in Rails:
 
 ```ruby
-match "/ws", to: Ruflet::Rails.app(Rails.root.join("app/views/ruflet/main.rb")), via: :all
+match "/ws", to: Ruflet::Rails.native(Rails.root.join("app/views/ruflet/main.rb")), via: :all
 ```
 
 The same mounted Ruby entrypoint drives mobile, web, and desktop clients.

data/lib/generators/ruflet/install/install_generator.rb

@@ -6,9 +6,8 @@ require "ruflet/rails/install_support"
 module Ruflet
   module Generators
     class InstallGenerator < ::Rails::Generators::Base
-      class_option :web, type: :boolean, default: false, desc: "Install the prebuilt Ruflet web client"
       class_option :desktop, type: :boolean, default: false, desc: "Download the server-driven desktop Ruflet client"
-      class_option :client, type: :string, default: nil, desc: "Install prebuilt clients: web, desktop, all, or none"
+      class_option :client, type: :string, default: nil, desc: "Install prebuilt clients: desktop or none"
 
       desc "Install Ruflet into a Rails app."
 
@@ -31,21 +30,11 @@ module Ruflet
       def mount_websocket
         routes = File.join(destination_root, "config", "routes.rb")
         return unless File.file?(routes)
-        return if File.read(routes).include?("Ruflet::Rails.app(")
+        return if File.read(routes).include?("Ruflet::Rails.native(")
 
         route Ruflet::Rails::InstallSupport.route_snippet(entrypoint: entrypoint_path)
       end
 
-      def mount_web_app
-        return unless web_requested?
-
-        routes = File.join(destination_root, "config", "routes.rb")
-        return unless File.file?(routes)
-        return if File.read(routes).include?("Ruflet::Rails.web_app(")
-
-        route Ruflet::Rails::InstallSupport.web_route_snippet(entrypoint: entrypoint_path)
-      end
-
       def add_desktop_flag_to_binstubs
         return unless desktop_requested?
 
@@ -57,7 +46,6 @@ module Ruflet
         client = requested_client
         return if client == "none"
 
-        install_web_client if %w[web all].include?(client)
         install_desktop_client if %w[desktop all].include?(client)
       rescue StandardError => e
         @client_download_failed = true
@@ -66,7 +54,6 @@ module Ruflet
 
       def print_install_status
         Ruflet::Rails::InstallSupport.install_next_steps(
-          target: install_target,
           entrypoint: entrypoint_path,
           client: requested_client
         ).each { |line| say line }
@@ -85,13 +72,11 @@ module Ruflet
       def requested_client
         explicit = options[:client].to_s.strip.downcase
         unless explicit.empty?
-          raise Thor::Error, "--client must be web, desktop, all, or none" unless %w[web desktop all none].include?(explicit)
+          raise Thor::Error, "--client must be desktop or none" unless %w[desktop none].include?(explicit)
 
           return explicit
         end
 
-        return "all" if options[:web] && options[:desktop]
-        return "web" if options[:web]
         return "desktop" if options[:desktop]
 
         "none"
@@ -101,19 +86,6 @@ module Ruflet
         %w[desktop all].include?(requested_client)
       end
 
-      def web_requested?
-        %w[web all].include?(requested_client)
-      end
-
-      def install_target
-        "ruflet"
-      end
-
-      def install_web_client
-        return if Ruflet::Rails::WebInstaller.install!(root: destination_root)
-
-        client_download_failed("web")
-      end
 
       def install_desktop_client
         require "ruflet/cli"

data/lib/ruflet/rails/desktop_launcher.rb

@@ -8,7 +8,7 @@ module Ruflet
       module_function
 
       def launch_once(root:, argv: ARGV, env: ENV, wait: 1.0)
-        return false unless desktop_enabled?(root: root, argv: argv, env: env)
+        return false unless desktop_enabled?(argv: argv, env: env)
         return false unless env["RUFLET_RAILS_DESKTOP_SERVER"].to_s.downcase == "true" || rails_server_command?(argv)
         return false if env["RUFLET_RAILS_DESKTOP"].to_s.downcase == "false"
         return false if launched?
@@ -51,7 +51,7 @@ module Ruflet
         "http://localhost:#{env["PORT"].to_s.empty? ? 3000 : env["PORT"]}"
       end
 
-      def desktop_enabled?(root:, argv: ARGV, env: ENV)
+      def desktop_enabled?(argv: ARGV, env: ENV)
         return true if env["RUFLET_RAILS_DESKTOP_SERVER"].to_s.downcase == "true"
         return true if env["RUFLET_RAILS_DESKTOP"].to_s.downcase == "true"
         return true if Array(argv).map(&:to_s).include?("--desktop")

data/lib/ruflet/rails/html_dsl/control_diff.rb

@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+module Ruflet
+  module Rails
+    module HtmlDsl
+      # Compares the control tree already mounted on a screen with the one just
+      # built from fresh markup, and reports the minimum set of prop updates
+      # that turns the first into the second.
+      #
+      # Re-rendering a screen in place otherwise means shipping every control
+      # on it to change one value — a counter tick re-sends the heading, both
+      # buttons and the caption to move a single digit, and the client rebuilds
+      # that subtree (losing scroll position and any transient widget state).
+      #
+      # The diff is deliberately conservative: it only reports updates when the
+      # two trees have exactly the same shape (same control types, same number
+      # of children, same prop-held controls, in the same order). Any structural
+      # difference returns nil, and the caller replaces the body wholesale as
+      # before. Shape changes are where a diff would be subtly wrong, and they
+      # are also the case where a full replace costs what it should.
+      class ControlDiff
+        # Props whose values are server-side plumbing, never wire state.
+        SKIPPED_PROPS = %w[key].freeze
+
+        def initialize(old_tree, new_tree)
+          @old_tree = old_tree
+          @new_tree = new_tree
+        end
+
+        # [[mounted_control, {prop => value}], …], or nil when the shape moved.
+        def updates
+          @updates = []
+          return nil unless walk(@old_tree, @new_tree)
+
+          @updates
+        end
+
+        private
+
+        def walk(old_node, new_node)
+          return true if old_node.nil? && new_node.nil?
+          return false if old_node.nil? || new_node.nil?
+
+          if old_node.is_a?(Array) || new_node.is_a?(Array)
+            return false unless old_node.is_a?(Array) && new_node.is_a?(Array)
+            return false unless old_node.length == new_node.length
+
+            return old_node.each_with_index.all? { |item, i| walk(item, new_node[i]) }
+          end
+
+          return old_node == new_node unless control?(old_node) || control?(new_node)
+          return false unless control?(old_node) && control?(new_node)
+          return false unless old_node.type == new_node.type
+          return false unless old_node.children.length == new_node.children.length
+
+          return false unless compare_props(old_node, new_node)
+
+          old_node.children.each_with_index.all? { |child, i| walk(child, new_node.children[i]) }
+        end
+
+        def compare_props(old_node, new_node)
+          keys = (old_node.props.keys | new_node.props.keys) - SKIPPED_PROPS
+          changed = {}
+
+          keys.each do |key|
+            old_value = old_node.props[key]
+            new_value = new_node.props[key]
+
+            # A prop holding controls is structure: recurse instead of comparing.
+            if holds_controls?(old_value) || holds_controls?(new_value)
+              return false unless walk(old_value, new_value)
+
+              next
+            end
+
+            changed[key.to_sym] = new_value unless old_value == new_value
+          end
+
+          # The fresh tree carries handlers bound to this render (a button's
+          # on-click closes over the screen it was built for). Move them onto
+          # the mounted control so taps keep working after a patch; handlers
+          # live server-side, so this costs nothing on the wire.
+          rebind_handlers(old_node, new_node)
+
+          @updates << [old_node, changed] unless changed.empty?
+          true
+        end
+
+        def rebind_handlers(old_node, new_node)
+          handlers = new_node.instance_variable_get(:@handlers)
+          return if handlers.nil? || handlers.empty?
+
+          old_node.instance_variable_set(:@handlers, handlers)
+        end
+
+        def control?(node)
+          node.is_a?(Ruflet::Control)
+        end
+
+        def holds_controls?(value)
+          return true if control?(value)
+          return value.any? { |item| control?(item) } if value.is_a?(Array)
+
+          false
+        end
+      end
+    end
+  end
+end