charming 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc7f17fae2c6012942e00a20986ee7928b3f1a71e9d6fcb4a9855439e1281fd3
-  data.tar.gz: 63d288c1cbecc5830b2c1d3cfece4d0a15a58241ee9b6e130d6ea13c9256767f
+  metadata.gz: 63a0e6137fddcdcd90ebeb7f64a4a5d8b7d24bce082a87f27273eadc3d20a3e7
+  data.tar.gz: 925a673a508c582bb259da12794653b65ac30d6184e9b48f586db0ae3d0de7ba
 SHA512:
-  metadata.gz: 374717171efb3639c11cd96748fb41e02a9bff74ec3c7e2325770d90f5b5db193df8c7ebaca1e73dffcf597f1e14fc3af6971d8cf9780026dbe5b3db6513cebd
-  data.tar.gz: 1870fb231844e57394d0412de0a752d1927a8bf6c4347daff86d26bed96c4226744f9cc26a9fe8ce0992b7bb604e87a4763b3747ad0ea58a56876cf59f2692bf
+  metadata.gz: 18cc22164930e56efe5c768fd947c7dd23009b49d2266b5d849b71dedae30202a4b32540a9c595ec5490ae4b5ee7a6f0bf167796fcbd5fb41e674db312696840
+  data.tar.gz: 4b2ed08745f24cc99082d604247e1cf1e501f2188f217ed70ced49065c22587e59c335ce11aede01a47ba2626de78b9cccb2fafa50abea8273b86eda779f0736

data/lib/charming/application.rb

@@ -5,6 +5,7 @@ module Charming
   # terminal-based apps. It provides routing (via a DSL), session storage, and
   # task execution for managing async operations.
   class Application
+    LOGGER_READER = Object.new.freeze
     THEME_READER = Object.new.freeze
 
     class << self
@@ -19,7 +20,15 @@ module Charming
       # Derives the module namespace from the class name — e.g., Admin::HomeController
       # yields "Admin". Mirrors Rails' engine-style namespacing.
       def namespace
-        name&.split("::")&.then { |parts| parts[0...-1].join("::") }
+        ActiveSupport::Inflector.deconstantize(name.to_s)
+      end
+
+      # Returns or sets the app logger. Defaults to a null-device logger so app and framework code
+      # can safely call logging methods without writing into the terminal UI.
+      def logger(value = LOGGER_READER)
+        return configured_logger if value == LOGGER_READER
+
+        @logger = value
       end
 
       # Returns the app's filesystem root, used to resolve relative theme and template paths.
@@ -67,6 +76,13 @@ module Charming
 
       private
 
+      def configured_logger
+        return @logger if instance_variable_defined?(:@logger)
+        return superclass.logger if superclass.respond_to?(:logger)
+
+        @logger = Logger.new(File::NULL)
+      end
+
       # Expands a relative theme path against the app root (or the current working directory
       # when no root is configured). Returns *path* unchanged when it is already absolute.
       def resolve_theme_path(path)
@@ -76,11 +92,12 @@ module Charming
       end
     end
 
-    attr_accessor :task_executor
+    attr_accessor :logger, :task_executor
     attr_reader :session
 
     # Initializes an empty session hash for per-request state storage.
     def initialize
+      @logger = self.class.logger
       @session = {}
     end
 

data/lib/charming/cli.rb

@@ -75,17 +75,17 @@ module Charming
     end
 
     # Routes `db:*` commands to either the install path (db:install) or the generic
-    # DatabaseCommands dispatcher.
+    # Database::Commands dispatcher.
     def database(command, args)
       if command == "db:install"
         database = args.shift || raise(Generators::Error, "Usage: charming db:install sqlite3")
         raise Generators::Error, "Usage: charming db:install sqlite3" if args.any?
 
-        DatabaseInstaller.new(database, out: out, destination: pwd).install
+        Generators::DatabaseInstaller.new(database, out: out, destination: pwd).install
       else
         raise Generators::Error, "Usage: charming #{command}" if args.any?
 
-        DatabaseCommands.new(command, out: out, destination: pwd).run
+        Database::Commands.new(command, out: out, destination: pwd).run
       end
       0
     end

data/lib/charming/controller/component_dispatching.rb

@@ -71,10 +71,54 @@ module Charming
         :handled
       end
 
-      # Default mouse dispatch hook: subclasses/components may override by including their own
-      # mouse logic via the controller's `dispatch_component_mouse` override.
+      # Hit-tests the current mouse event against named layout panes from the latest render.
+      # Clicks move focus to matching slots; components in clicked panes receive local coordinates.
       def dispatch_component_mouse
-        nil
+        target = mouse_target_for_event
+        return nil unless target
+
+        slot = target.fetch(:name)
+        previous_focus = focus.current
+        focus.focus(slot) if focusable_click?(slot)
+
+        result = dispatch_mouse_to_target_component(slot, target)
+        return response if result.nil? && previous_focus == focus.current
+
+        result ? dispatch_component_result(slot, result) : render_default_action
+        response
+      end
+
+      def mouse_target_for_event
+        mouse_targets.rfind { |target| target.fetch(:rect).cover?(event.x, event.y) }
+      end
+
+      def focusable_click?(slot)
+        event.respond_to?(:click?) && event.click? && focus.ring.include?(slot)
+      end
+
+      def dispatch_mouse_to_target_component(slot, target)
+        return nil unless respond_to?(slot, true)
+
+        component = send(slot)
+        return nil unless component.respond_to?(:handle_mouse)
+
+        local_event = local_mouse_event(target.fetch(:inner_rect))
+        return nil unless local_event
+
+        component.handle_mouse(local_event)
+      end
+
+      def local_mouse_event(rect)
+        return nil unless rect.cover?(event.x, event.y)
+
+        Events::MouseEvent.new(
+          button: event.button,
+          x: event.x - rect.x,
+          y: event.y - rect.y,
+          ctrl: event.ctrl,
+          alt: event.alt,
+          shift: event.shift
+        )
       end
     end
   end

data/lib/charming/controller/focus.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module Charming
+  class Controller
+    # Focus manages a stack of focus scopes (rings) for a single controller class. Each scope has
+    # a slot ring (a fixed list of named slots) and a current slot within that ring. Multiple
+    # scopes can be stacked so the command palette, modals, and layouts can each have their own
+    # focus contexts without interfering with one another.
+    #
+    # State lives under `session[:focus_state][controller_class_name]` so focus persists across
+    # controller dispatches within the same session.
+    class Focus
+      # Returns the Focus object for *controller_class* under the given *session*, creating the
+      # underlying session hash if absent.
+      def self.for(session, controller_class)
+        session[:focus_state] ||= {}
+        key = controller_class.name
+        session[:focus_state][key] ||= {scopes: []}
+        new(session[:focus_state][key])
+      end
+
+      def initialize(state)
+        @state = state
+      end
+
+      # Defines the primary focus ring for the controller with the given *slots*. Only effective
+      # the first time it is called; subsequent calls are no-ops.
+      def define(slots)
+        return if @state[:scopes].any? { |scope| scope[:origin] == :ring }
+
+        @state[:scopes] << build_scope(slots, :ring)
+      end
+
+      # Defines a layout scope (inserted after the primary ring and before modal scopes). *slots*
+      # is the list of pane names; the previously-focused layout slot is preserved when it is still
+      # part of the new ring.
+      def define_layout(slots)
+        current = current_layout_slot(slots)
+        remove_scope(:layout)
+        return if slots.empty?
+
+        @state[:scopes].insert(layout_scope_index, build_scope(slots, :layout, current))
+      end
+
+      # Pushes a new focus scope with the given *slots* onto the stack. Used by modals, palettes,
+      # and other overlays. *origin* is a label for the scope kind.
+      def push_scope(slots, origin: :modal)
+        @state[:scopes] << build_scope(slots, origin)
+      end
+
+      # Pops the topmost focus scope from the stack.
+      def pop_scope
+        @state[:scopes].pop
+      end
+
+      # Returns the currently focused slot, or nil when no scope is active.
+      def current
+        top && top[:current]
+      end
+
+      # Returns the slot ring of the topmost scope (an array of slot names). Empty when no scope.
+      def ring
+        top ? top[:ring] : []
+      end
+
+      # Sets the current slot within the topmost scope to *slot*. No-op when *slot* is not in the ring.
+      def focus(slot)
+        return unless ring.include?(slot)
+
+        top[:current] = slot
+      end
+
+      # Cycles focus by *direction* (default +1 forward) within the topmost ring. No-op on an empty ring.
+      def cycle(direction = +1)
+        return if ring.empty?
+
+        index = ring.index(current) || 0
+        top[:current] = ring[(index + direction) % ring.length]
+      end
+
+      # True when *slot* is the current focus slot.
+      def focused?(slot)
+        current == slot
+      end
+
+      private
+
+      # Returns the topmost scope hash (the last entry pushed onto `@state[:scopes]`).
+      def top
+        @state[:scopes].last
+      end
+
+      # Removes every scope whose origin equals *origin* (in place).
+      def remove_scope(origin)
+        @state[:scopes].reject! { |scope| scope[:origin] == origin }
+      end
+
+      # Returns the index in the scope stack where a layout scope belongs: just before the first
+      # non-ring, non-layout scope (i.e., at the end of the "structural" stack).
+      def layout_scope_index
+        index = @state[:scopes].index { |scope| !%i[ring layout].include?(scope[:origin]) }
+        index || @state[:scopes].length
+      end
+
+      # Returns the current layout scope's current slot, but only when it is still part of *slots*.
+      # Otherwise returns the first slot in *slots* (so a new layout reverts to its first pane).
+      def current_layout_slot(slots)
+        current_slot = current_layout_scope&.fetch(:current)
+        slots.include?(current_slot) ? current_slot : slots.first
+      end
+
+      # Returns the layout scope, or nil when no layout scope is present.
+      def current_layout_scope
+        @state[:scopes].find { |scope| scope[:origin] == :layout }
+      end
+
+      # Builds an immutable scope hash with the given *slots*, *origin*, and starting *current* slot.
+      def build_scope(slots, origin, current = slots.first)
+        {ring: slots.dup.freeze, current: current, origin: origin}
+      end
+    end
+  end
+end

data/lib/charming/controller/focus_management.rb

@@ -9,7 +9,7 @@ module Charming
       # Returns the per-controller Focus object, defining the focus ring from class-level DSL
       # declarations on first access.
       def focus
-        @focus ||= Focus.for(session, self.class).tap do |f|
+        @focus ||= Controller::Focus.for(session, self.class).tap do |f|
           f.define(self.class.focus_ring_slots) unless self.class.focus_ring_slots.empty?
         end
       end

data/lib/charming/controller/rendering.rb

@@ -96,12 +96,9 @@ module Charming
       def conventional_view_constant_path(name)
         parts = name.to_s.split("/")
         action = parts.pop
-        parts.map { |part| camelize(part) } + ["#{camelize(action)}View"]
-      end
+        view_name = "#{ActiveSupport::Inflector.camelize(action.to_s)}View"
 
-      # Converts a snake_case string to CamelCase. Used to build conventional view constant names.
-      def camelize(value)
-        value.to_s.split("_").map(&:capitalize).join
+        parts.map { |part| ActiveSupport::Inflector.camelize(part) } + [view_name]
       end
 
       # Returns the default template path for a given *action* (e.g., "home/show" for HomeController#show).
@@ -111,16 +108,8 @@ module Charming
 
       # Returns the underscored controller path (e.g., "home" for HomeController) used for view lookup.
       def controller_template_path
-        underscore(self.class.name.split("::").last.delete_suffix("Controller"))
-      end
-
-      # Converts CamelCase to snake_case.
-      def underscore(value)
-        value
-          .gsub(/([A-Z]+)([A-Z][a-z])/, "\\1_\\2")
-          .gsub(/([a-z\d])([A-Z])/, "\\1_\\2")
-          .tr("-", "_")
-          .downcase
+        controller_name = ActiveSupport::Inflector.demodulize(self.class.name).delete_suffix("Controller")
+        ActiveSupport::Inflector.underscore(controller_name)
       end
     end
   end

data/lib/charming/controller/session_state.rb

@@ -11,6 +11,17 @@ module Charming
         application.session
       end
 
+      # Stores the named layout panes from the latest render so mouse events can be hit-tested
+      # against the same focus slots used by Tab traversal.
+      def register_mouse_targets(targets)
+        session[:mouse_targets] = targets
+      end
+
+      # Returns the named layout panes from the latest render.
+      def mouse_targets
+        session.fetch(:mouse_targets, [])
+      end
+
       # Returns the named session-backed state object, creating it on first access. *name* is a
       # symbol key under `session[:states]`. *state_class* is an ApplicationState subclass whose
       # constructor receives *attributes* on first creation. Subsequent calls return the same object.

data/lib/charming/controller.rb

@@ -67,8 +67,11 @@ module Charming
     # Mouse event dispatcher: checks command palette (if open), sidebar (if focused).
     def dispatch_mouse
       return dispatch_command_palette_mouse if command_palette_open?
-      return dispatch_sidebar_mouse if sidebar_focused?
-      dispatch_component_mouse
+
+      mouse_response = dispatch_component_mouse
+      return mouse_response if mouse_response
+
+      dispatch_sidebar_mouse if sidebar_focused?
     end
 
     # Renders a body or template wrapped in the controller's layout.
@@ -97,6 +100,12 @@ module Charming
       application.use_theme(name)
     end
 
+    # Returns the application logger. The default logger writes to File::NULL, so logging calls are
+    # safe in TUI code unless the app explicitly configures a file or custom logger.
+    def logger
+      application.logger
+    end
+
     # Opens the theme picker (a CommandPalette populated with the registered themes) and renders.
     def open_theme_palette
       session[:command_palette] = command_palette_state(:themes)

data/lib/charming/database/commands.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Charming
+  module Database
+    # Commands implements the runtime side of `charming db:COMMAND` (other than
+    # `db:install`, which lives in Generators::DatabaseInstaller). It loads the app's
+    # `config/database.rb`, delegates the actual work to ActiveRecord, and prints a short
+    # status line on success.
+    class Commands
+      # *command* is the subcommand string (e.g., "db:create"). *out* is the status-output
+      # stream. *destination* is the app root for resolving `config/database.rb` and `db/`.
+      def initialize(command, out:, destination:)
+        @command = command
+        @out = out
+        @destination = destination
+      end
+
+      # Dispatches the configured command. Raises Generators::Error for unknown commands.
+      def run
+        case command
+        when "db:create" then create
+        when "db:migrate" then migrate
+        when "db:rollback" then rollback
+        when "db:drop" then drop
+        when "db:seed" then seed
+        else raise Generators::Error, "Unknown database command: #{command}"
+        end
+      end
+
+      private
+
+      # The subcommand, output stream, and app destination.
+      attr_reader :command, :out, :destination
+
+      # Creates the SQLite database file (touch) and establishes the connection.
+      def create
+        load_database
+        FileUtils.mkdir_p(File.dirname(database_path)) if database_path
+        FileUtils.touch(database_path) if database_path
+        ActiveRecord::Base.connection
+        out.puts "create #{relative_database_path}"
+      end
+
+      # Runs all pending migrations from `db/migrate`.
+      def migrate
+        load_database
+        migration_context.migrate
+        out.puts "migrate db/migrate"
+      end
+
+      # Rolls back the most recent migration.
+      def rollback
+        load_database
+        migration_context.rollback(1)
+        out.puts "rollback db/migrate"
+      end
+
+      # Disconnects ActiveRecord, then deletes the database file.
+      def drop
+        load_database
+        ActiveRecord::Base.connection.disconnect!
+        File.delete(database_path) if database_path && File.exist?(database_path)
+        out.puts "drop #{relative_database_path}"
+      end
+
+      # Loads `db/seeds.rb` (raises if missing).
+      def seed
+        load_database
+        seed_path = File.join(destination, "db", "seeds.rb")
+        raise Generators::Error, "Missing file: db/seeds.rb" unless File.exist?(seed_path)
+
+        load seed_path
+        out.puts "seed db/seeds.rb"
+      end
+
+      # Loads the app's `config/database.rb` (raises if missing) which establishes the connection.
+      def load_database
+        database_config = File.join(destination, "config", "database.rb")
+        raise Generators::Error, "Database support is not configured. Missing config/database.rb." unless File.exist?(database_config)
+
+        require database_config
+      end
+
+      # The ActiveRecord migration context rooted at `db/migrate` inside the app.
+      def migration_context
+        ActiveRecord::MigrationContext.new(File.join(destination, "db", "migrate"))
+      end
+
+      # The configured database file path (nil when ActiveRecord isn't connected to a file).
+      def database_path
+        ActiveRecord::Base.connection_db_config.database
+      end
+
+      # The database path relative to the app root, used for human-friendly status output.
+      def relative_database_path
+        return "database" unless database_path
+
+        base = File.realpath(destination)
+        path = File.expand_path(database_path)
+        path.start_with?("#{base}/") ? path.delete_prefix("#{base}/") : path
+      end
+    end
+  end
+end

data/lib/charming/generators/database_installer.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Charming
+  module Generators
+    # DatabaseInstaller implements `charming db:install sqlite3`. It adds database support
+    # to an existing Charming app by creating `config/database.rb`, `app/models/application_record.rb`,
+    # `db/migrate/`, and `db/seeds.rb`, and patching the gemspec and root loader to include
+    # the new dependencies and the `app/models` autoload directory.
+    class DatabaseInstaller
+      # *database* is the adapter name (only "sqlite3" is currently supported). *out* is the
+      # status-output stream. *destination* is the app root.
+      def initialize(database, out:, destination:)
+        @database = database
+        @out = out
+        @destination = destination
+        @app_name = Name.new(app_name_from_gemspec)
+      end
+
+      # Performs the install: writes the database config, application record, migrate directory,
+      # seeds file, and patches the gemspec + root loader. Idempotent: existing files are
+      # reported with "exist <path>" instead of being overwritten.
+      def install
+        raise Error, "Unsupported database: #{database.inspect}" unless database == "sqlite3"
+
+        create_file("config/database.rb", database_config)
+        create_file("app/models/application_record.rb", application_record)
+        create_file("db/migrate/.keep", "")
+        create_file("db/seeds.rb", %(# frozen_string_literal: true
+))
+        update_gemspec
+        update_root_file
+      end
+
+      private
+
+      # The database adapter, status stream, app destination, and derived app name.
+      attr_reader :database, :out, :destination, :app_name
+
+      # Writes *content* to *path* (relative to the app root), creating intermediate directories.
+      # Reports "exist <path>" without overwriting when the file already exists.
+      def create_file(path, content)
+        absolute_path = File.join(destination, path)
+        if File.exist?(absolute_path)
+          out.puts "exist #{path}"
+          return
+        end
+
+        FileUtils.mkdir_p(File.dirname(absolute_path))
+        File.write(absolute_path, content)
+        out.puts "create #{path}"
+      end
+
+      # Patches the gemspec to include the `db` directory in the gem files glob and to add
+      # activerecord + sqlite3 dependencies.
+      def update_gemspec
+        update_file(gemspec_path) do |current|
+          updated = current.sub('Dir.glob("{app,config,exe,lib}/**/*")', 'Dir.glob("{app,config,db,exe,lib}/**/*")')
+          updated = insert_dependency(updated, "activerecord", "~> 8.1")
+          insert_dependency(updated, "sqlite3", "~> 2.0")
+        end
+      end
+
+      # Patches the root loader file (`lib/<app>.rb`) to require `config/database` and to push
+      # the `app/models` autoload directory. Both edits are no-ops when already applied.
+      def update_root_file
+        update_file(root_file_path) do |current|
+          updated = current
+          updated = updated.sub(%(require "zeitwerk"\n), %(require "zeitwerk"\nrequire_relative "../config/database"\n)) unless updated.include?(%(require_relative "../config/database"))
+          unless updated.include?(%[loader.push_dir(File.expand_path("../app/models", __dir__), namespace: #{app_name.class_name})])
+            updated = updated.sub(
+              %[loader.push_dir(File.expand_path("../app/state", __dir__), namespace: #{app_name.class_name})\n],
+              %[loader.push_dir(File.expand_path("../app/models", __dir__), namespace: #{app_name.class_name})\nloader.push_dir(File.expand_path("../app/state", __dir__), namespace: #{app_name.class_name})\n]
+            )
+          end
+          updated
+        end
+      end
+
+      # Reads *path*, yields its contents to the block, and writes the result back when it
+      # differs. Raises Error when the file is missing.
+      def update_file(path)
+        raise Error, "Missing file: #{relative_path(path)}" unless File.exist?(path)
+
+        current = File.read(path)
+        updated = yield current
+        return if updated == current
+
+        File.write(path, updated)
+        out.puts "update #{relative_path(path)}"
+      end
+
+      # Inserts a `spec.add_dependency "name", "version"` line after the `charming` dependency
+      # when it's not already present.
+      def insert_dependency(content, gem_name, version)
+        return content if content.include?(%(spec.add_dependency "#{gem_name}"))
+
+        dependency = %(  spec.add_dependency "#{gem_name}", "#{version}")
+        content.sub(%(  spec.add_dependency "charming"\n), %(  spec.add_dependency "charming"\n#{dependency}\n))
+      end
+
+      # The contents of the new `config/database.rb` (establishes an SQLite connection to
+      # `db/development.sqlite3`).
+      def database_config
+        %(# frozen_string_literal: true
+
+require "active_record"
+require "fileutils"
+
+database_path = File.expand_path("../db/development.sqlite3", __dir__)
+FileUtils.mkdir_p(File.dirname(database_path))
+
+ActiveRecord::Base.establish_connection(
+  adapter: "sqlite3",
+  database: database_path
+)
+)
+      end
+
+      # The contents of the new `app/models/application_record.rb` (abstract ActiveRecord base).
+      def application_record
+        %(# frozen_string_literal: true
+
+module #{app_name.class_name}
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end
+)
+      end
+
+      # Reads the app's gemspec filename to derive the app name.
+      def app_name_from_gemspec
+        File.basename(gemspec_path, ".gemspec")
+      end
+
+      # The path to the app's gemspec (raises when not found).
+      def gemspec_path
+        @gemspec_path ||= Dir.glob(File.join(destination, "*.gemspec")).first || raise(Error, "Run this command from a Charming app root")
+      end
+
+      # The path to the app's root loader file (`lib/<app_name>.rb`).
+      def root_file_path
+        File.join(destination, "lib", "#{app_name.snake_name}.rb")
+      end
+
+      # Strips the app destination prefix from *path* for human-friendly status output.
+      def relative_path(path)
+        path.delete_prefix("#{destination}/")
+      end
+    end
+  end
+end

data/lib/charming/generators/model_generator.rb

@@ -103,20 +103,12 @@ module Charming
 
       # The pluralized table name (e.g., "user" → "users", "category" → "categories").
       def table_name
-        pluralize(name.snake_name)
+        ActiveSupport::Inflector.pluralize(name.snake_name)
       end
 
       # The CamelCase migration class name (e.g., "users" → "Users").
       def table_class_name
-        table_name.split("_").map(&:capitalize).join
-      end
-
-      # Minimal English pluralization for the model name (covers the common -y, -s/x/z/ch/sh cases).
-      def pluralize(value)
-        return value.sub(/y\z/, "ies") if value.end_with?("y")
-        return "#{value}es" if value.match?(/(?:s|x|z|ch|sh)\z/)
-
-        "#{value}s"
+        ActiveSupport::Inflector.camelize(table_name)
       end
 
       # The current UTC timestamp in the format ActiveRecord uses for migration filenames.

data/lib/charming/generators/name.rb

@@ -21,7 +21,7 @@ module Charming
 
       # The CamelCase class name (e.g., "user" → "User").
       def class_name
-        snake_name.split("_").map(&:capitalize).join
+        ActiveSupport::Inflector.camelize(snake_name)
       end
 
       # The controller class name (e.g., "user" → "UserController").

data/lib/charming/generators/view_generator.rb

@@ -40,7 +40,7 @@ module Charming
 
       # CamelCase rendering of the action name (e.g., "user_settings" → "UserSettings").
       def action_class_name
-        action.split("_").map(&:capitalize).join
+        ActiveSupport::Inflector.camelize(action)
       end
     end
   end

data/lib/charming/presentation/components/form/field.rb

@@ -111,7 +111,7 @@ module Charming
 
         # Converts a snake_case symbol/string to a humanized "Capitalized" string.
         def humanize(value)
-          value.to_s.tr("_", " ").capitalize
+          ActiveSupport::Inflector.humanize(value)
         end
       end
     end