charming 0.1.3 → 0.1.4

data/lib/charming/database_installer.rb

@@ -1,152 +0,0 @@
-# frozen_string_literal: true
-
-require "fileutils"
-
-module Charming
-  # 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 = Generators::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 Generators::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 Generators::Error when the file is missing.
-    def update_file(path)
-      raise Generators::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(Generators::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

data/lib/charming/focus.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  # 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

data/lib/charming/presentation/markdown/block_renderers.rb

@@ -1,118 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  module Markdown
-    # BlockRenderer dispatches Kramdown block-level elements (paragraph, header, list,
-    # code block, etc.) to their individual rendering handlers. Handlers are built once
-    # at construction time as a frozen hash of element-type symbols to callables.
-    class BlockRenderer
-      # *renderer* is the parent Renderer (used to wrap text, render inlines, and look up styles).
-      def initialize(renderer:)
-        @renderer = renderer
-        build_handlers
-      end
-
-      # Renders *element* using the handler registered for `element.type`. Unknown types
-      # fall through to `render_unknown`.
-      def render(element, context:)
-        handler = @handlers[element.type] || method(:render_unknown)
-        handler.call(element, context)
-      end
-
-      private
-
-      # The frozen hash of element-type → handler mapping.
-      attr_reader :handlers
-
-      # Builds the handler hash. Each handler is a small lambda that calls back into the
-      # parent renderer (or one of the private render_* methods below).
-      def build_handlers
-        r = @renderer
-        @handlers = {
-          p: ->(element, context) { r.wrap(r.render_inlines(element.children), width: context.width) },
-          header: ->(element, context) { send(:render_header, element, context) },
-          blockquote: ->(element, context) { send(:render_blockquote, element, context) },
-          ul: ->(element, context) { send(:render_list, element, ordered: false, context: context) },
-          ol: ->(element, context) { send(:render_list, element, ordered: true, context: context) },
-          li: ->(element, context) { r.render_blocks(element.children, list_depth: context.list_depth, width: context.width) },
-          codeblock: ->(element, _context) { send(:render_codeblock, element) },
-          hr: ->(element, context) { send(:render_rule, width: context.width) },
-          blank: ->(_element, _context) {}
-        }.freeze
-      end
-
-      # Fallback for unknown block types: wraps the raw value when there are no children,
-      # otherwise recurses into the children.
-      def render_unknown(element, context)
-        return @renderer.wrap(element.value.to_s, width: context.width) if element.children.empty?
-
-        @renderer.render_blocks(element.children, list_depth: context.list_depth, width: context.width)
-      end
-
-      # Renders a header element, using the `markdown_heading` style for h1 and the
-      # `markdown_subheading` style for h2+.
-      def render_header(element, context)
-        rendered = @renderer.wrap(@renderer.render_inlines(element.children), width: context.width)
-        style = if element.options[:level].to_i == 1
-          @renderer.style_for(:markdown_heading, fallback: @renderer.theme_style(:title))
-        else
-          @renderer.style_for(:markdown_subheading, fallback: @renderer.theme_style(:title))
-        end
-        style.render(rendered)
-      end
-
-      def render_blockquote(element, context)
-        quote_width = context.width ? [context.width - 2, 1].max : nil
-        rendered = @renderer.render_blocks(element.children, list_depth: context.list_depth, width: quote_width)
-        border = @renderer.style_for(:markdown_quote_border, fallback: @renderer.theme_style(:border)).render("|")
-        quote_style = @renderer.style_for(:markdown_quote, fallback: @renderer.theme_style(:muted))
-
-        rendered.lines(chomp: true).map { |line| "#{border} #{quote_style.render(line)}" }.join("\n")
-      end
-
-      def render_list(element, ordered:, context:)
-        element.children.each_with_index.map do |item, index|
-          marker = ordered ? "#{ordered_start(element) + index}." : "-"
-          render_list_item(item, marker: marker, context: context)
-        end.join("\n")
-      end
-
-      def render_list_item(element, marker:, context:)
-        indent = "  " * context.list_depth
-        first_prefix = "#{indent}#{marker} "
-        rest_prefix = "#{indent}#{" " * (marker.length + 1)}"
-        item_width = context.width ? [context.width - UI::Width.measure(first_prefix), 1].max : nil
-        body = @renderer.render_blocks(element.children, list_depth: context.list_depth + 1, width: item_width)
-
-        body.lines(chomp: true).each_with_index.map do |line, index|
-          "#{index.zero? ? first_prefix : rest_prefix}#{line}"
-        end.join("\n")
-      end
-
-      def ordered_start(element)
-        element.options.fetch(:start, 1).to_i
-      end
-
-      def render_codeblock(element)
-        code = element.value.to_s
-        rendered = if @renderer.syntax_highlighting
-          SyntaxHighlighter.new(theme: @renderer.theme).render(code, language: code_language(element))
-        else
-          @renderer.style_for(:markdown_code, fallback: @renderer.theme_style(:warn)).render(code)
-        end
-
-        rendered.lines(chomp: true).map { |line| "  #{line}" }.join("\n")
-      end
-
-      def render_rule(width:)
-        @renderer.style_for(:markdown_rule, fallback: @renderer.theme_style(:border)).render("-" * (width || Renderer::DEFAULT_RULE_WIDTH))
-      end
-
-      def code_language(element)
-        return element.options[:lang] if element.options[:lang]
-
-        element.attr["class"].to_s[/language-([^\s]+)/, 1]
-      end
-    end
-  end
-end

data/lib/charming/presentation/markdown/inline_renderers.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module Charming
-  module Markdown
-    # InlineRenderer dispatches Kramdown inline-level elements (text, strong, em,
-    # codespan, link, line break, HTML entity) to their individual rendering handlers.
-    # Handlers are built once at construction as a frozen hash of element-type symbols
-    # to callables.
-    class InlineRenderer
-      # *renderer* is the parent Renderer (used to render nested inlines and look up styles).
-      def initialize(renderer:)
-        @renderer = renderer
-        build_handlers
-      end
-
-      # Renders *element* using the handler registered for `element.type`. Unknown types
-      # fall through to `render_unknown`.
-      def render(element, context:)
-        handler = @handlers[element.type] || method(:render_unknown)
-        handler.call(element, context)
-      end
-
-      private
-
-      # The frozen hash of element-type → handler mapping.
-      attr_reader :handlers
-
-      # Builds the handler hash for text, strong, em, codespan, link, br, and entity.
-      def build_handlers
-        r = @renderer
-        @handlers = {
-          text: ->(element, _context) { element.value.to_s },
-          strong: ->(element, context) { render_styled(element, context, :markdown_strong) { |s| s.bold } },
-          em: ->(element, context) { render_styled(element, context, :markdown_emphasis) { |s| s.italic } },
-          codespan: ->(element, _context) { r.style_for(:markdown_inline_code, fallback: r.theme_style(:warn)).render(element.value.to_s) },
-          a: ->(element, context) { send(:render_link, element, context) },
-          br: ->(_element, _context) { "\n" },
-          entity: ->(element, _context) { element.value.respond_to?(:char) ? element.value.char : element.value.to_s }
-        }.freeze
-      end
-
-      # Renders a styled inline (strong/em) by first rendering children, then applying
-      # the theme style and the block-form (e.g., `bold`/`italic`) decoration.
-      def render_styled(element, context, style_name)
-        rendered = @renderer.render_inlines(element.children, width: context.width)
-        style = @renderer.style_for(style_name, fallback: yield(@renderer.theme_style(:text)))
-        style.render(rendered)
-      end
-
-      # Renders a Markdown link as "label <href>" (URL omitted when empty), styled with
-      # the markdown_link theme token or the info+underline fallback.
-      def render_link(element, context)
-        label = @renderer.render_inlines(element.children, width: context.width)
-        href = element.attr["href"].to_s
-        rendered = href.empty? ? label : "#{label} <#{href}>"
-        @renderer.style_for(:markdown_link, fallback: @renderer.theme_style(:info).underline).render(rendered)
-      end
-
-      # Fallback for unknown inline types: returns the value when there are no children,
-      # otherwise recurses into the children.
-      def render_unknown(element, context)
-        element.children.empty? ? element.value.to_s : @renderer.render_inlines(element.children, width: context.width)
-      end
-    end
-  end
-end