charming 0.1.3 → 0.2.0

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

@@ -1,72 +1,58 @@
 # frozen_string_literal: true
 
-require "kramdown"
+require "commonmarker"
+require "uri"
 
 module Charming
   module Markdown
-    # Renderer is the top-level Markdown-to-ANSI renderer. Parses the *content* with
-    # Kramdown, then walks the document's block and inline trees to produce styled
-    # terminal output. Code blocks are highlighted via Rouge when `syntax_highlighting`
-    # is enabled.
+    # Renderer parses CommonMark/GFM with Commonmarker and renders it as ANSI text.
     class Renderer
-      # Wrap width used by `render_rule` when no width is otherwise specified.
       DEFAULT_RULE_WIDTH = 40
 
-      # The Markdown source, configured wrap width, theme, and syntax-highlighting flag.
-      attr_reader :content, :width, :theme, :syntax_highlighting
+      attr_reader :content, :width, :theme, :syntax_highlighting, :style, :base_url
 
-      # *content* is the Markdown source string. *width* optionally wraps paragraphs to that
-      # many display columns. *theme* is the Charming theme used to style blocks/inlines.
-      # *syntax_highlighting* enables Rouge-backed code block highlighting (default true).
-      def initialize(content:, width: nil, theme: UI::Theme.default, syntax_highlighting: true)
+      def initialize(content:, width: nil, theme: UI::Theme.default, syntax_highlighting: true, style: :dark, base_url: nil)
         @content = content
         @width = width
         @theme = theme || UI::Theme.default
         @syntax_highlighting = syntax_highlighting
+        @style = StyleConfig.from(style)
+        @base_url = base_url
       end
 
-      # Parses the content and returns the fully-rendered Markdown as a single string.
       def render
-        document = Kramdown::Document.new(content.to_s)
-        render_blocks(document.root.children)
+        context = RenderContext.from(
+          width: width,
+          style: style,
+          base_url: base_url,
+          source_lines: content.to_s.lines(chomp: true)
+        )
+        render_document(parse_document, context: context)
       end
 
-      # Renders a list of Kramdown block *elements* into a string, joined by blank lines.
-      # *list_depth* is forwarded to the render context for list indentation. *width*
-      # defaults to the renderer's configured width.
-      def render_blocks(elements, list_depth: 0, width: @width)
-        context = RenderContext.from(width: width, list_depth: list_depth)
+      def render_blocks(elements, context:)
         elements.filter_map do |element|
-          rendered = block_renderer.render(element, context: context)
+          rendered = render_block(element, context: context)
           rendered unless rendered.to_s.empty?
         end.join("\n\n")
       end
 
-      # Renders a list of Kramdown inline *elements* into a single concatenated string.
-      # *width* defaults to the renderer's configured width.
-      def render_inlines(elements, width: @width)
-        context = RenderContext.from(width: width)
-        elements.map { |element| inline_renderer.render(element, context: context) }.join
+      def render_inlines(elements, context:)
+        elements.map { |element| render_inline(element, context: context) }.join
       end
 
-      # Word-wraps *value* to *width* display columns (when *width* is given), preserving
-      # any ANSI styling on each line. Returns *value* unchanged when *width* is nil.
       def wrap(value, width:)
         return value unless width
 
         value.to_s.lines(chomp: true).map { |line| wrap_line(line, width) }.join("\n")
       end
 
-      # Returns the theme's style for *name* if the theme defines it, otherwise returns
-      # *fallback*. Lets views override markdown-specific theme tokens.
       def style_for(name, fallback:)
         return theme.public_send(name) if theme.respond_to?(name)
 
         fallback
       end
 
-      # Returns the theme's style for *name*, building a one-token default theme when
-      # the active theme doesn't define it. Used as a final fallback for markdown styling.
       def theme_style(name)
         return theme.public_send(name) if theme.respond_to?(name)
 
@@ -75,17 +61,256 @@ module Charming
 
       private
 
-      # The BlockRenderer instance, lazily built.
-      def block_renderer
-        @block_renderer ||= BlockRenderer.new(renderer: self)
+      def parse_document
+        Commonmarker.parse(
+          content.to_s,
+          options: {
+            extension: {
+              autolink: true,
+              description_lists: true,
+              footnotes: true,
+              strikethrough: true,
+              table: true,
+              tasklist: true
+            }
+          }
+        )
       end
 
-      # The InlineRenderer instance, lazily built.
-      def inline_renderer
-        @inline_renderer ||= InlineRenderer.new(renderer: self)
+      def render_document(node, context:)
+        document_style = context.style[:document]
+        body = render_blocks(children_of(node), context: context.with(current_style: document_style))
+        document_style.render(document_style.apply_block_layout(body))
+      end
+
+      def render_block(node, context:)
+        case node.type
+        when :paragraph
+          render_paragraph(node, context: context)
+        when :heading
+          render_heading(node, context: context)
+        when :block_quote
+          render_block_quote(node, context: context)
+        when :list
+          render_list(node, context: context)
+        when :code_block
+          render_code_block(node, context: context)
+        when :thematic_break
+          render_rule(context: context)
+        when :table
+          render_table(node, context: context)
+        when :html_block
+          render_html_block(node, context: context)
+        else
+          render_blocks(children_of(node), context: context)
+        end
+      end
+
+      def render_inline(node, context:)
+        case node.type
+        when :text
+          context.current_style.inherit_visual(context.style[:text]).render(node.string_content)
+        when :softbreak
+          " "
+        when :linebreak
+          "\n"
+        when :code
+          context.inherit(:code).render(node.string_content)
+        when :emph
+          render_styled_inline(node, :emph, context: context)
+        when :strong
+          render_styled_inline(node, :strong, context: context)
+        when :strikethrough
+          render_styled_inline(node, :strikethrough, context: context)
+        when :link
+          render_link(node, context: context)
+        when :image
+          render_image(node, context: context)
+        when :html_inline
+          ""
+        else
+          render_inlines(children_of(node), context: context)
+        end
+      end
+
+      def render_paragraph(node, context:)
+        paragraph_style = context.current_style.inherit_visual(context.style[:paragraph])
+        body = render_inlines(children_of(node), context: context.with(current_style: paragraph_style))
+        render_block_with_style(paragraph_style, wrap(body, width: context.width))
+      end
+
+      def render_heading(node, context:)
+        heading_style = context.current_style.inherit_visual(context.style.heading(node.header_level))
+        body = render_inlines(children_of(node), context: context.with(current_style: heading_style))
+        render_block_with_style(heading_style, wrap(body, width: context.width))
+      end
+
+      def render_block_quote(node, context:)
+        quote_style = context.current_style.inherit_visual(context.style[:block_quote])
+        quote_width = context.width ? [context.width - quote_indent_width(quote_style), 1].max : nil
+        body = render_blocks(children_of(node), context: context.with(width: quote_width, current_style: quote_style))
+        render_block_with_style(quote_style, body)
+      end
+
+      def render_list(node, context:)
+        list_style = context.current_style.inherit_visual(context.style[:list])
+        children_of(node).each_with_index.map do |item, index|
+          render_list_item(item, index: index, ordered: node.list_type == :ordered, list: node, context: context.with(current_style: list_style))
+        end.join("\n")
+      end
+
+      def render_list_item(node, index:, ordered:, list:, context:)
+        marker_style = context.current_style.inherit_visual(context.style[ordered ? :enumeration : :item])
+        marker = if node.type == :taskitem
+          task_marker(node, context: context)
+        elsif ordered
+          "#{list.list_start.to_i + index}. "
+        else
+          marker_style.block_prefix.empty? ? "- " : marker_style.block_prefix
+        end
+
+        indent = " " * (context.style[:list].level_indent || 2) * context.list_depth
+        first_prefix = "#{indent}#{marker}"
+        rest_prefix = "#{indent}#{" " * UI::Width.measure(marker)}"
+        item_width = context.width ? [context.width - UI::Width.measure(first_prefix), 1].max : nil
+        body = render_blocks(children_of(node), context: context.nested_list(width: item_width))
+
+        body.lines(chomp: true).each_with_index.map do |line, line_index|
+          "#{line_index.zero? ? first_prefix : rest_prefix}#{line}"
+        end.join("\n")
+      end
+
+      def task_marker(node, context:)
+        task_style = context.current_style.inherit_visual(context.style[:task])
+        checked_task?(node, context: context) ? (task_style.ticked || "[x] ") : (task_style.unticked || "[ ] ")
+      end
+
+      def checked_task?(node, context:)
+        line = context.source_lines[node.source_position[:start_line].to_i - 1].to_s
+        line.match?(/\[[xX]\]/)
+      end
+
+      def render_code_block(node, context:)
+        code_style = context.current_style.inherit_visual(context.style[:code_block])
+        code = node.string_content.to_s.chomp
+        rendered = if syntax_highlighting
+          SyntaxHighlighter.new(theme: theme, style: style).render(code, language: node.fence_info.to_s.split.first)
+        else
+          code_style.render(code)
+        end
+
+        body = rendered.lines(chomp: true).map { |line| "  #{line}" }.join("\n")
+        syntax_highlighting ? code_style.apply_block_layout(body) : render_block_with_style(code_style, body)
+      end
+
+      def render_rule(context:)
+        rule_style = context.current_style.inherit_visual(context.style[:hr])
+        body = rule_style.format.empty? ? "-" * (context.width || DEFAULT_RULE_WIDTH) : rule_style.format
+        render_block_with_style(rule_style, body)
+      end
+
+      def render_table(node, context:)
+        table_style = context.current_style.inherit_visual(context.style[:table])
+        rows = children_of(node).map do |row|
+          children_of(row).map { |cell| render_inlines(children_of(cell), context: context.with(current_style: table_style)) }
+        end
+        return "" if rows.empty?
+
+        widths = table_widths(rows)
+        rendered_rows = rows.each_with_index.map do |row, index|
+          line = table_row(row, widths, table_style)
+          index.zero? ? [line, table_separator(widths, table_style)].join("\n") : line
+        end
+
+        render_block_with_style(table_style, rendered_rows.join("\n"))
+      end
+
+      def render_html_block(_node, context:)
+        html_style = context.current_style.inherit_visual(context.style[:html_block])
+        return "" if html_style.format.empty?
+
+        render_block_with_style(html_style, html_style.format)
+      end
+
+      def render_styled_inline(node, style_name, context:)
+        inline_style = context.inherit(style_name)
+        inline_style.render(render_inlines(children_of(node), context: context.with(current_style: inline_style)))
+      end
+
+      def render_link(node, context:)
+        href = resolve_url(node.url.to_s, context: context)
+        text_style = context.inherit(:link_text)
+        link_style = context.inherit(:link)
+        label = render_inlines(children_of(node), context: context.with(current_style: text_style))
+        rendered = if href.empty? || UI::Width.strip_ansi(label) == href
+          label
+        else
+          "#{label} <#{href}>"
+        end
+        link_style.render(rendered)
+      end
+
+      def render_image(node, context:)
+        href = resolve_url(node.url.to_s, context: context)
+        image_style = context.inherit(:image)
+        text_style = context.inherit(:image_text)
+        alt = render_inlines(children_of(node), context: context.with(current_style: text_style))
+        label = if text_style.format.empty?
+          "Image: #{UI::Width.strip_ansi(alt)} ->"
+        else
+          text_style.format.gsub("{{text}}", UI::Width.strip_ansi(alt))
+        end
+
+        image_style.render([label, href].reject(&:empty?).join(" "))
+      end
+
+      def render_block_with_style(style, body)
+        style.render(style.apply_block_layout(body))
+      end
+
+      def table_widths(rows)
+        column_count = rows.map(&:length).max || 0
+        Array.new(column_count) do |index|
+          rows.map { |row| UI::Width.measure(row[index].to_s) }.max || 0
+        end
+      end
+
+      def table_row(row, widths, style)
+        separator = style.column_separator || "|"
+        cells = widths.each_with_index.map do |width, index|
+          value = row[index].to_s
+          " #{value}#{" " * [width - UI::Width.measure(value), 0].max} "
+        end
+        "#{separator}#{cells.join(separator)}#{separator}"
+      end
+
+      def table_separator(widths, style)
+        separator = style.column_separator || "|"
+        row = style.row_separator || "-"
+        "#{separator}#{widths.map { |table_width| row * (table_width + 2) }.join(separator)}#{separator}"
+      end
+
+      def quote_indent_width(style)
+        return 0 unless style.indent&.positive?
+
+        UI::Width.measure((style.indent_token || " ") * style.indent)
+      end
+
+      def resolve_url(value, context:)
+        return value if context.base_url.to_s.empty? || value.empty?
+
+        uri = URI.parse(value)
+        return value if uri.absolute?
+
+        URI.join(context.base_url, value).to_s
+      rescue URI::InvalidURIError
+        value
+      end
+
+      def children_of(node)
+        node.each.to_a
       end
 
-      # Word-wraps a single *line* to *width* display columns using greedy space-splitting.
       def wrap_line(line, width)
         return line if UI::Width.measure(line) <= width
 

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

@@ -0,0 +1,215 @@
+# frozen_string_literal: true
+
+module Charming
+  module Markdown
+    class StyleConfig
+      ELEMENTS = %i[
+        document paragraph block_quote list heading h1 h2 h3 h4 h5 h6 text
+        strikethrough emph strong hr item enumeration task link link_text image
+        image_text code code_block table definition_list definition_term
+        definition_description html_block html_span
+      ].freeze
+
+      BUILT_INS = {
+        notty: {
+          block_quote: {indent: 1, indent_token: "| "},
+          list: {level_indent: 2},
+          h1: {prefix: "# "},
+          h2: {prefix: "## "},
+          h3: {prefix: "### "},
+          h4: {prefix: "#### "},
+          h5: {prefix: "##### "},
+          h6: {prefix: "###### "},
+          emph: {block_prefix: "*", block_suffix: "*"},
+          strong: {block_prefix: "**", block_suffix: "**"},
+          strikethrough: {block_prefix: "~~", block_suffix: "~~"},
+          hr: {format: "--------"},
+          item: {block_prefix: "- "},
+          enumeration: {block_prefix: ". "},
+          task: {ticked: "[x] ", unticked: "[ ] "},
+          code: {block_prefix: "`", block_suffix: "`"},
+          code_block: {margin: 1},
+          table: {column_separator: "|", row_separator: "-"},
+          image_text: {format: "Image: {{text}} ->"}
+        },
+        dark: {
+          document: {color: "252"},
+          block_quote: {color: "244", indent: 1, indent_token: "│ "},
+          list: {level_indent: 2},
+          heading: {color: "39", bold: true},
+          h1: {prefix: " ", suffix: " ", color: "228", background_color: "63", bold: true},
+          h2: {prefix: "## "},
+          h3: {prefix: "### "},
+          h4: {prefix: "#### "},
+          h5: {prefix: "##### "},
+          h6: {prefix: "###### ", color: "35", bold: false},
+          strikethrough: {crossed_out: true},
+          emph: {italic: true},
+          strong: {bold: true},
+          hr: {color: "240", format: "--------"},
+          item: {block_prefix: "• "},
+          enumeration: {block_prefix: ". "},
+          task: {ticked: "[✓] ", unticked: "[ ] "},
+          link: {color: "30", underline: true},
+          link_text: {color: "35", bold: true},
+          image: {color: "212", underline: true},
+          image_text: {color: "243", format: "Image: {{text}} ->"},
+          code: {prefix: " ", suffix: " ", color: "203", background_color: "236"},
+          code_block: {color: "244", margin: 1},
+          table: {column_separator: "|", row_separator: "-"}
+        },
+        light: {
+          document: {color: "236"},
+          block_quote: {color: "244", indent: 1, indent_token: "│ "},
+          list: {level_indent: 2},
+          heading: {color: "25", bold: true},
+          h1: {prefix: " ", suffix: " ", color: "255", background_color: "33", bold: true},
+          h2: {prefix: "## "},
+          h3: {prefix: "### "},
+          h4: {prefix: "#### "},
+          h5: {prefix: "##### "},
+          h6: {prefix: "###### ", color: "30", bold: false},
+          strikethrough: {crossed_out: true},
+          emph: {italic: true},
+          strong: {bold: true},
+          hr: {color: "250", format: "--------"},
+          item: {block_prefix: "• "},
+          enumeration: {block_prefix: ". "},
+          task: {ticked: "[✓] ", unticked: "[ ] "},
+          link: {color: "25", underline: true},
+          link_text: {color: "90", bold: true},
+          image: {color: "162", underline: true},
+          image_text: {color: "244", format: "Image: {{text}} ->"},
+          code: {prefix: " ", suffix: " ", color: "161", background_color: "255"},
+          code_block: {color: "244", margin: 1},
+          table: {column_separator: "|", row_separator: "-"}
+        }
+      }.freeze
+
+      ATTRIBUTES = %i[bold faint italic underline reverse strikethrough].freeze
+
+      Style = Data.define(
+        :block_prefix, :block_suffix, :prefix, :suffix, :color, :background_color,
+        :bold, :faint, :italic, :underline, :reverse, :strikethrough, :format,
+        :indent, :indent_token, :margin, :level_indent, :ticked, :unticked,
+        :column_separator, :row_separator
+      ) do
+        def self.from(value)
+          value = symbolize_keys(value || {})
+          new(
+            block_prefix: value[:block_prefix].to_s,
+            block_suffix: value[:block_suffix].to_s,
+            prefix: value[:prefix].to_s,
+            suffix: value[:suffix].to_s,
+            color: normalize_color(value[:color] || value[:foreground] || value[:fg]),
+            background_color: normalize_color(value[:background_color] || value[:background] || value[:bg]),
+            bold: value[:bold],
+            faint: value[:faint],
+            italic: value[:italic],
+            underline: value[:underline],
+            reverse: value[:reverse] || value[:inverse],
+            strikethrough: value[:strikethrough] || value[:crossed_out],
+            format: value[:format].to_s,
+            indent: value[:indent]&.to_i,
+            indent_token: value[:indent_token]&.to_s,
+            margin: value[:margin]&.to_i,
+            level_indent: value[:level_indent]&.to_i,
+            ticked: value[:ticked]&.to_s,
+            unticked: value[:unticked]&.to_s,
+            column_separator: value[:column_separator]&.to_s,
+            row_separator: value[:row_separator]&.to_s
+          )
+        end
+
+        def inherit_visual(child)
+          child = self.class.from(child) unless child.is_a?(self.class)
+          self.class.new(**child.to_h.merge(
+            color: child.color || color,
+            background_color: child.background_color || background_color,
+            bold: child.bold.nil? ? bold : child.bold,
+            faint: child.faint.nil? ? faint : child.faint,
+            italic: child.italic.nil? ? italic : child.italic,
+            underline: child.underline.nil? ? underline : child.underline,
+            reverse: child.reverse.nil? ? reverse : child.reverse,
+            strikethrough: child.strikethrough.nil? ? strikethrough : child.strikethrough
+          ))
+        end
+
+        def render(value)
+          ansi_codes.apply("#{block_prefix}#{prefix}#{value}#{suffix}#{block_suffix}")
+        end
+
+        def apply_block_layout(value)
+          lines = value.to_s.lines(chomp: true)
+          lines = [""] if lines.empty?
+
+          if indent&.positive?
+            indentation = (indent_token || " ") * indent
+            lines = lines.map { |line| "#{indentation}#{line}" }
+          end
+
+          rendered = lines.join("\n")
+          return rendered unless margin.to_i.positive?
+
+          blank = Array.new(margin.to_i, "").join("\n")
+          "#{blank}\n#{rendered}\n#{blank}"
+        end
+
+        private
+
+        def ansi_codes
+          UI::ANSICodes.new(
+            attributes: ATTRIBUTES.select { |attribute| public_send(attribute) },
+            foreground: color,
+            background: background_color
+          )
+        end
+
+        def self.symbolize_keys(value)
+          value.to_h.each_with_object({}) { |(key, item), result| result[key.to_sym] = item }
+        end
+
+        def self.normalize_color(value)
+          return if value.nil?
+          return value if value.is_a?(Integer)
+          return value.to_i if value.to_s.match?(/\A\d+\z/)
+
+          value
+        end
+      end
+
+      def self.builtin(name)
+        key = name.to_s.tr("-", "_").to_sym
+        raise ArgumentError, "unknown markdown style: #{name.inspect}" unless BUILT_INS.key?(key)
+
+        from_hash(BUILT_INS.fetch(key))
+      end
+
+      def self.from(value)
+        return value if value.is_a?(self)
+        return builtin(value) if value.is_a?(String) || value.is_a?(Symbol)
+
+        from_hash(value || BUILT_INS.fetch(:dark))
+      end
+
+      def self.from_hash(value)
+        new(value.to_h)
+      end
+
+      def initialize(styles = {})
+        styles = styles.transform_keys(&:to_sym)
+        @styles = ELEMENTS.each_with_object({}) do |element, result|
+          result[element] = Style.from(styles[element] || {})
+        end.freeze
+      end
+
+      def [](name)
+        @styles.fetch(name.to_sym) { Style.from({}) }
+      end
+
+      def heading(level)
+        self[:heading].inherit_visual(self[:"h#{level}"])
+      end
+    end
+  end
+end

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

@@ -10,8 +10,9 @@ module Charming
     # base style (muted italic for comments, title for keywords, etc.).
     class SyntaxHighlighter
       # *theme* is the active Charming theme. Defaults to UI::Theme.default.
-      def initialize(theme: UI::Theme.default)
+      def initialize(theme: UI::Theme.default, style: nil)
         @theme = theme || UI::Theme.default
+        @style = style
       end
 
       # Highlights *code* (using Rouge) for the given *language* (auto-detected when nil)
@@ -27,7 +28,7 @@ module Charming
       private
 
       # The Charming theme used for token styling.
-      attr_reader :theme
+      attr_reader :theme, :style
 
       # Picks a Rouge lexer for *language* and *code*, falling back to plain text.
       def lexer_for(language, code)

data/lib/charming/presentation/markdown.rb

@@ -2,8 +2,8 @@
 
 module Charming
   # Markdown is the namespace for the Markdown rendering pipeline. Parsing is delegated to
-  # Kramdown; per-block and per-inline element rendering is handled by `BlockRenderer`
-  # and `InlineRenderer`; code blocks are highlighted by `SyntaxHighlighter` (Rouge-backed).
+  # Commonmarker; `Renderer` renders the AST, and code blocks are highlighted by
+  # `SyntaxHighlighter` (Rouge-backed).
   module Markdown
   end
 end

data/lib/charming/presentation/view.rb

@@ -81,6 +81,7 @@ module Charming
     def screen_layout(background: nil, &)
       layout = Layout::Builder.build(screen: layout_screen, view: self, background: background, &)
       register_layout_focus(layout)
+      register_layout_mouse_targets(layout)
       layout.render
     end
 
@@ -129,5 +130,11 @@ module Charming
 
       assigns[:controller].focus.define_layout(layout.focusable_names)
     end
+
+    def register_layout_mouse_targets(layout)
+      return unless assigns[:controller]
+
+      assigns[:controller].register_mouse_targets(layout.mouse_targets)
+    end
   end
 end

data/lib/charming/router.rb

@@ -108,20 +108,15 @@ module Charming
       end
     end
 
-    # Splits a camel-case string into words for title derivation (e.g., "my_route" → ["my", "route"]).
-    def camelize(value)
-      value.split("_").map(&:capitalize).join
-    end
-
     # Looks up a constant by name in Object. Used to resolve controller strings from route definitions.
     def constantize(name)
-      Object.const_get(name)
+      ActiveSupport::Inflector.constantize(name)
     end
 
     # Builds the full controller constant name, prepending the namespace if present.
-    # For example: "HomeController" with namespace "Admin" → "Admin::HomeController".
+    # For example: "home" with namespace "Admin" → "Admin::HomeController".
     def controller_constant_name(controller_name)
-      name = "#{camelize(controller_name)}Controller"
+      name = "#{ActiveSupport::Inflector.camelize(controller_name)}Controller"
       @namespace.to_s.empty? ? name : "#{@namespace}::#{name}"
     end
 

data/lib/charming/runtime.rb

@@ -186,6 +186,7 @@ module Charming
     def setup_terminal
       @backend.enter_alt_screen
       @backend.hide_cursor
+      @backend.enable_mouse_tracking if @backend.respond_to?(:enable_mouse_tracking)
       @backend.install_resize_handler if @backend.respond_to?(:install_resize_handler)
     end
 
@@ -200,6 +201,7 @@ module Charming
     # the cursor, and leaves the alternative screen buffer.
     def restore_terminal
       @backend.restore_resize_handler if @backend.respond_to?(:restore_resize_handler)
+      @backend.disable_mouse_tracking if @backend.respond_to?(:disable_mouse_tracking)
       @backend.show_cursor
       @backend.leave_alt_screen
     end

data/lib/charming/version.rb

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