mdphlex 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 30fde45581cd7d2edeada97dd0c281cbf4bf6447e6938f5002ad99231c4ac2f0
+  data.tar.gz: 1168f4d22457f7965160e4248f468d7bce4e0a45eb56a44b6285cb3aebe94d83
+SHA512:
+  metadata.gz: 8aab63e64b863d0fdba508d8e9d2a570eb7b8bc8d9c11081cf4b8718a9c06365a6069df65024a2c868efd6bc60e1163f4adf20251f220f7c63d0d6d4b4ffd05b
+  data.tar.gz: 66efd4524781b9fcc52568879f352285db7477f078039c40f1c209c09e13d63c3dc0c24f95c20876839203a68982d79166bf125d54abe4017dc6c9c3c2008e69

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-09-03
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Martin Emde
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,123 @@
+# MDPhlex
+
+MDPhlex is a Phlex component for rendering Markdown. Write your Markdown in Ruby with Phlex's familiar syntax and render it as a Markdown string.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'mdphlex'
+```
+
+## Basic Usage
+
+Create an MDPhlex::MD component just like you would create a Phlex component:
+
+```ruby
+class HelloWorld < MDPhlex::MD
+  def view_template
+    h1 "Hello, World!"
+
+    p "Welcome to MDPhlex - writing Markdown with Phlex syntax!"
+
+    h2 "Features"
+
+    ul do
+      li "Write Markdown using Ruby"
+      li do
+        plain "Support for "
+        strong "bold"
+        plain ", "
+        em "italic"
+        plain ", and "
+        code "inline code"
+      end
+      li "Full Phlex component composition"
+    end
+
+    p do
+      plain "Check out the "
+      a(href: "https://github.com/martinemde/mdphlex") { "MDPhlex repository" }
+      plain " for more information."
+    end
+  end
+end
+
+# Render the component
+puts HelloWorld.new.call
+```
+
+This outputs the following Markdown:
+
+```markdown
+# Hello, World!
+
+Welcome to MDPhlex - writing Markdown with Phlex syntax!
+
+## Features
+
+- Write Markdown using Ruby
+- Support for **bold**, *italic*, and `inline code`
+- Full Phlex component composition
+
+Check out the [MDPhlex repository](https://github.com/martinemde/mdphlex) for more information.
+```
+
+## Rendering MDPhlex inside Phlex::HTML
+
+MDPhlex components can be seamlessly integrated into your Phlex::HTML views:
+
+```ruby
+class ArticlePage < Phlex::HTML
+  def initialize(article)
+    @article = article
+  end
+
+  def view_template
+    html do
+      head do
+        title { @article.title }
+      end
+      body do
+        article do
+          # Render MDPhlex component inside HTML
+          div(class: "markdown-content") do
+            plain render(ArticleContent.new(@article))
+          end
+        end
+      end
+    end
+  end
+end
+
+class ArticleContent < MDPhlex::MD
+  def initialize(article)
+    @article = article
+  end
+
+  def view_template
+    h1 @article.title
+
+    p @article.summary
+
+    h2 "Contents"
+
+    @article.sections.each do |section|
+      h3 section.title
+      p section.content
+    end
+  end
+end
+```
+
+## Why MDPhlex?
+
+- **Component-based**: Build reusable Markdown components
+- **Type-safe**: Get Ruby's type checking and IDE support
+- **Composable**: Mix Phlex::HTML and MDPhlex components freely
+- **Familiar**: Uses the same syntax as Phlex
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+
+require "rubocop/rake_task"
+
+RuboCop::RakeTask.new
+
+task default: %i[rubocop]

data/config/quickdraw.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+Bundler.require :test
+
+require "mdphlex"

data/lib/mdphlex/md.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require "phlex"
+
+module MDPhlex
+  class MD < Phlex::SGML
+    extend Phlex::SGML::Elements
+
+    # Register a block-level custom element that ensures proper newlines
+    def self.register_block_element(method_name, tag: method_name.to_s.tr("_", "-"))
+      define_method(method_name) do |**attributes, &block|
+        state = @_state
+        buffer = state.buffer
+
+        unless state.should_render?
+          __yield_content__(&block) if block
+          return nil
+        end
+
+        # Render the opening tag - always followed by newline
+        buffer << "<#{tag}"
+
+        if attributes.length > 0
+          attributes.each do |key, value|
+            buffer << " #{key}=\"#{Phlex::Escape.html_escape(value.to_s)}\""
+          end
+        end
+
+        buffer << ">\n"
+
+        # Render content if block given
+        if block
+          __yield_content__(&block)
+        end
+
+        # Render closing tag - always followed by newline for block elements
+        buffer << "</#{tag}>\n"
+
+        nil
+      end
+    end
+
+    def h1(content = nil, &)
+      heading(1, content, &)
+    end
+
+    def h2(content = nil, &)
+      heading(2, content, &)
+    end
+
+    def h3(content = nil, &)
+      heading(3, content, &)
+    end
+
+    def h4(content = nil, &)
+      heading(4, content, &)
+    end
+
+    def h5(content = nil, &)
+      heading(5, content, &)
+    end
+
+    def h6(content = nil, &)
+      heading(6, content, &)
+    end
+
+    def p(content = nil, &)
+      state = @_state
+      return unless state.should_render?
+
+      buffer = state.buffer
+
+      if block_given?
+        __yield_content__(&)
+      elsif content
+        buffer << content.to_s
+      end
+
+      buffer << "\n\n"
+      nil
+    end
+
+    def strong(content = nil, &)
+      wrap_inline("**", content, &)
+    end
+
+    def em(content = nil, &)
+      wrap_inline("*", content, &)
+    end
+
+    def code(content = nil, &)
+      wrap_inline("`", content, &)
+    end
+
+    def a(href: nil, **attributes, &)
+      state = @_state
+      return unless state.should_render?
+
+      buffer = state.buffer
+      buffer << "["
+
+      __yield_content__(&) if block_given?
+
+      buffer << "]("
+      buffer << href.to_s if href
+      buffer << ")"
+      nil
+    end
+
+    def plain(content)
+      state = @_state
+      return unless state.should_render?
+
+      state.buffer << content.to_s
+      nil
+    end
+
+    def blockquote(content = nil, &)
+      state = @_state
+      return unless state.should_render?
+
+      buffer = state.buffer
+
+      if block_given?
+        # Save current position to capture content
+        start_pos = buffer.length
+        __yield_content__(&)
+        # Extract the content that was added
+        captured = buffer[start_pos..]
+        # Remove it from buffer to re-add with > prefix
+        buffer.slice!(start_pos..)
+
+        # Add > prefix to each line
+        captured.lines.each do |line|
+          buffer << "> " << line
+        end
+      else
+        content.to_s.lines.each do |line|
+          buffer << "> " << line
+        end
+      end
+
+      buffer << "\n\n"
+      nil
+    end
+
+    def pre(language: nil, &)
+      state = @_state
+      return unless state.should_render?
+
+      buffer = state.buffer
+      buffer << "```"
+      buffer << language.to_s if language
+      buffer << "\n"
+
+      __yield_content__(&) if block_given?
+
+      buffer << "\n```\n\n"
+      nil
+    end
+
+    def ul(&)
+      state = @_state
+      return unless state.should_render?
+
+      buffer = state.buffer
+      @_list_type ||= []
+
+      # If we're in a list item and there's already content, add a newline
+      buffer << "\n" if @_list_type.length > 0 && buffer.length > 0 && !buffer.end_with?("\n")
+
+      @_list_type.push(:ul)
+
+      __yield_content__(&) if block_given?
+
+      @_list_type.pop
+      # Only add extra newline at the end of top-level lists
+      buffer << "\n" if @_list_type.empty?
+      nil
+    end
+
+    def ol(&)
+      state = @_state
+      return unless state.should_render?
+
+      buffer = state.buffer
+      @_list_type ||= []
+
+      # If we're in a list item and there's already content, add a newline
+      buffer << "\n" if @_list_type.length > 0 && buffer.length > 0 && !buffer.end_with?("\n")
+
+      @_list_type.push(:ol)
+      @_ol_counter ||= []
+      @_ol_counter.push(0)
+
+      __yield_content__(&) if block_given?
+
+      @_list_type.pop
+      @_ol_counter.pop
+      # Only add extra newline at the end of top-level lists
+      buffer << "\n" if @_list_type.empty?
+      nil
+    end
+
+    def li(content = nil, &)
+      state = @_state
+      return unless state.should_render?
+
+      buffer = state.buffer
+      @_list_type ||= []
+      list_depth = @_list_type.length
+
+      # Add indentation for nested lists
+      buffer << ("  " * [list_depth - 1, 0].max)
+
+      # Add list marker
+      if @_list_type.last == :ol
+        @_ol_counter ||= []
+        @_ol_counter[-1] += 1
+        buffer << "#{@_ol_counter.last}. "
+      else
+        buffer << "- "
+      end
+
+      if block_given?
+        # Mark position before yielding content
+        start_pos = buffer.length
+        __yield_content__(&)
+        # Only add newline if we haven't already ended with one
+        # (nested lists already add their trailing newline)
+        buffer << "\n" unless buffer.end_with?("\n")
+      else
+        buffer << content.to_s if content
+        buffer << "\n"
+      end
+
+      nil
+    end
+
+    def img(src: nil, alt: nil, **attributes)
+      state = @_state
+      return unless state.should_render?
+
+      buffer = state.buffer
+      buffer << "!["
+      buffer << alt.to_s if alt
+      buffer << "]("
+      buffer << src.to_s if src
+      buffer << ")"
+      nil
+    end
+
+    def hr(**attributes)
+      state = @_state
+      return unless state.should_render?
+
+      state.buffer << "---\n\n"
+      nil
+    end
+
+    def br
+      state = @_state
+      return unless state.should_render?
+
+      state.buffer << "  \n"
+      nil
+    end
+
+    private def heading(level, content = nil, &)
+      state = @_state
+      return unless state.should_render?
+
+      buffer = state.buffer
+      buffer << ("#" * level) << " "
+
+      if block_given?
+        __yield_content__(&)
+      elsif content
+        buffer << content.to_s
+      end
+
+      buffer << "\n"
+      nil
+    end
+
+    private def wrap_inline(marker, content = nil, &)
+      state = @_state
+      return unless state.should_render?
+
+      buffer = state.buffer
+      buffer << marker
+
+      if block_given?
+        __yield_content__(&)
+      elsif content
+        buffer << content.to_s
+      end
+
+      buffer << marker
+      nil
+    end
+  end
+end

data/lib/mdphlex/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MDPhlex
+  VERSION = "0.1.0"
+end

data/lib/mdphlex.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "phlex"
+require "zeitwerk"
+
+loader = Zeitwerk::Loader.for_gem
+loader.inflector.inflect("mdphlex" => "MDPhlex", "md" => "MD")
+loader.setup
+
+module MDPhlex
+end

data/quickdraw/interoperability.test.rb

@@ -0,0 +1,330 @@
+# frozen_string_literal: true
+
+require "phlex"
+
+test "MDPhlex::MD component rendered inside Phlex::HTML component" do
+  # Define a simple Markdown component
+  markdown_component = Class.new(MDPhlex::MD) do
+    def view_template
+      h2 "Markdown Section"
+      p "This is a paragraph with **bold** text."
+      ul do
+        li "First item"
+        li "Second item"
+      end
+    end
+  end
+
+  # Define an HTML component that renders the Markdown component
+  html_component = Class.new(Phlex::HTML) do
+    def initialize(markdown_component)
+      @markdown_component = markdown_component
+    end
+
+    def view_template
+      article do
+        h1 { "HTML Article" }
+        div(class: "markdown-content") do
+          plain render(@markdown_component.new)
+        end
+      end
+    end
+  end
+
+  # Render and test
+  output = html_component.new(markdown_component).call
+
+  assert output.include?("<article>")
+  assert output.include?("<h1>HTML Article</h1>")
+  assert output.include?('<div class="markdown-content">')
+  assert output.include?("## Markdown Section")
+  assert output.include?("This is a paragraph with **bold** text.")
+  assert output.include?("- First item")
+  assert output.include?("- Second item")
+  assert output.include?("</article>")
+end
+
+test "MDPhlex::MD component rendered inside Phlex::HTML without .new" do
+  # Define a Markdown component that doesn't need initialization
+  simple_markdown = Class.new(MDPhlex::MD) do
+    def view_template
+      h1 "About"
+      p "This component can be rendered without calling .new"
+    end
+  end
+
+  # HTML component that renders the class directly
+  html_wrapper = Class.new(Phlex::HTML) do
+    def initialize(markdown_class)
+      @markdown_class = markdown_class
+    end
+
+    def view_template
+      div(class: "wrapper") do
+        # Render without .new - Phlex should automatically initialize
+        plain render(@markdown_class)
+      end
+    end
+  end
+
+  output = html_wrapper.new(simple_markdown).call
+
+  assert output.include?('<div class="wrapper">')
+  assert output.include?("# About")
+  assert output.include?("This component can be rendered without calling .new")
+end
+
+test "Phlex::HTML component rendered inside MDPhlex::MD component" do
+  # Define an HTML component
+  button_component = Class.new(Phlex::HTML) do
+    def initialize(text:, variant: "primary")
+      @text = text
+      @variant = variant
+    end
+
+    def view_template
+      button(type: "button", class: "btn btn-#{@variant}") { @text }
+    end
+  end
+
+  # Define a Markdown component that renders HTML components
+  markdown_component = Class.new(MDPhlex::MD) do
+    def initialize(button_component)
+      @button_component = button_component
+    end
+
+    def view_template
+      h1 "Interactive Documentation"
+
+      p "Here's an example of a button component:"
+
+      # Render the HTML component directly
+      render @button_component.new(text: "Click me!", variant: "primary")
+
+      p "You can also use different variants:"
+
+      render @button_component.new(text: "Warning", variant: "warning")
+      render @button_component.new(text: "Danger", variant: "danger")
+    end
+  end
+
+  # Render and test
+  output = markdown_component.new(button_component).call
+
+  assert output.include?("# Interactive Documentation")
+  assert output.include?("Here's an example of a button component:")
+  assert output.include?('<button type="button" class="btn btn-primary">Click me!</button>')
+  assert output.include?("You can also use different variants:")
+  assert output.include?('<button type="button" class="btn btn-warning">Warning</button>')
+  assert output.include?('<button type="button" class="btn btn-danger">Danger</button>')
+end
+
+test "MDPhlex::MD component rendered inside another MDPhlex::MD component" do
+  # Define a reusable Markdown component for code examples
+  code_example = Class.new(MDPhlex::MD) do
+    def initialize(title:, code:, language: "ruby")
+      @title = title
+      @code = code
+      @language = language
+    end
+
+    def view_template
+      h3 @title
+      pre(language: @language) { plain @code }
+    end
+  end
+
+  # Define a parent Markdown component that uses the code example component
+  tutorial_component = Class.new(MDPhlex::MD) do
+    def initialize(code_example_component)
+      @code_example_component = code_example_component
+    end
+
+    def view_template
+      h1 "MDPhlex Tutorial"
+
+      p "Learn how to use MDPhlex for creating beautiful documentation."
+
+      h2 "Examples"
+
+      # Render child MDPhlex::MD components
+      render @code_example_component.new(
+        title: "Basic Usage",
+        code: <<~RUBY
+          class MyDoc < MDPhlex
+            def view_template
+              h1 "Hello World"
+              p "This is MDPhlex!"
+            end
+          end
+        RUBY
+      )
+
+      render @code_example_component.new(
+        title: "Lists and Formatting",
+        code: <<~RUBY
+          ul do
+            li "Item with **bold** text"
+            li "Item with `code`"
+          end
+        RUBY
+      )
+
+      p "These examples show the flexibility of component composition."
+    end
+  end
+
+  # Render and test
+  output = tutorial_component.new(code_example).call
+
+  assert output.include?("# MDPhlex Tutorial")
+  assert output.include?("Learn how to use MDPhlex for creating beautiful documentation.")
+  assert output.include?("## Examples")
+  assert output.include?("### Basic Usage")
+  assert output.include?("```ruby")
+  assert output.include?('h1 "Hello World"')
+  assert output.include?("### Lists and Formatting")
+  assert output.include?('li "Item with **bold** text"')
+  assert output.include?("These examples show the flexibility of component composition.")
+end
+
+test "Components yielding content blocks across Phlex::HTML and MDPhlex::MD" do
+  # Define a card component that yields content
+  card_component = Class.new(Phlex::HTML) do
+    def initialize(title:)
+      @title = title
+    end
+
+    def view_template
+      div(class: "card") do
+        h2(class: "card-title") { @title }
+        div(class: "card-content") do
+          yield
+        end
+      end
+    end
+  end
+
+  # MDPhlex::MD component that uses the card and passes content
+  markdown_component = Class.new(MDPhlex::MD) do
+    def initialize(card_class)
+      @card_class = card_class
+    end
+
+    def view_template
+      h1 "Documentation with Cards"
+
+      # Render HTML component with a content block
+      render @card_class.new(title: "Important Note") do
+        p "This is **important** information inside a card."
+        ul do
+          li "First point"
+          li "Second point"
+        end
+      end
+    end
+  end
+
+  output = markdown_component.new(card_component).call
+
+  assert output.include?("# Documentation with Cards")
+  assert output.include?('<div class="card">')
+  assert output.include?('<h2 class="card-title">Important Note</h2>')
+  assert output.include?('<div class="card-content">')
+  assert output.include?("This is **important** information inside a card.")
+  assert output.include?("- First point")
+end
+
+test "Interface yielding pattern between MDPhlex::MD and Phlex::HTML" do
+  # Define a nav component with interface yielding
+  nav_component = Class.new(Phlex::HTML) do
+    def view_template(&)
+      nav(class: "special-nav", &)
+    end
+
+    def item(href, &)
+      a(class: "nav-item", href:, &)
+    end
+
+    def divider
+      span(class: "nav-divider") { "|" }
+    end
+  end
+
+  # MDPhlex::MD component that uses the nav interface
+  docs_layout = Class.new(MDPhlex::MD) do
+    def initialize(nav_class)
+      @nav_class = nav_class
+    end
+
+    def view_template
+      h1 "Site Navigation Example"
+
+      p "Here's how to use the nav component:"
+
+      # Use the yielded interface
+      render @nav_class.new do |nav|
+        nav.item("/") { "Home" }
+        nav.item("/docs") { "Documentation" }
+        nav.divider
+        nav.item("/about") { "About" }
+      end
+
+      p "The nav component yields an interface for building navigation."
+    end
+  end
+
+  output = docs_layout.new(nav_component).call
+
+  assert output.include?("# Site Navigation Example")
+  assert output.include?('<nav class="special-nav">')
+  assert output.include?('<a class="nav-item" href="/">Home</a>')
+  assert output.include?('<a class="nav-item" href="/docs">Documentation</a>')
+  assert output.include?('<span class="nav-divider">|</span>')
+  assert output.include?('<a class="nav-item" href="/about">About</a>')
+end
+
+test "Conditional rendering with render? method" do
+  # HTML component with conditional rendering
+  notification_badge = Class.new(Phlex::HTML) do
+    def initialize(count:)
+      @count = count
+    end
+
+    def view_template
+      span(class: "badge") { @count }
+    end
+
+    def render?
+      @count > 0
+    end
+  end
+
+  # MDPhlex::MD component that conditionally renders the badge
+  user_profile = Class.new(MDPhlex::MD) do
+    def initialize(badge_class, notifications_count)
+      @badge_class = badge_class
+      @notifications_count = notifications_count
+    end
+
+    def view_template
+      h1 "User Profile"
+
+      p do
+        plain "Notifications "
+        render @badge_class.new(count: @notifications_count)
+      end
+    end
+  end
+
+  # Test with notifications
+  output_with = user_profile.new(notification_badge, 5).call
+  assert output_with.include?("# User Profile")
+  assert output_with.include?("Notifications <span class=\"badge\">5</span>")
+
+  # Test without notifications
+  output_without = user_profile.new(notification_badge, 0).call
+  assert output_without.include?("# User Profile")
+  assert output_without.include?("Notifications ")
+  assert !output_without.include?("badge")
+end

data/quickdraw/mdphlex.test.rb

@@ -0,0 +1,423 @@
+# frozen_string_literal: true
+
+test "renders h1 heading" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      h1 "Hello World"
+    end
+  end
+
+  assert_equal example.new.call, "# Hello World\n"
+end
+
+test "renders h2 heading" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      h2 "Subheading"
+    end
+  end
+
+  assert_equal example.new.call, "## Subheading\n"
+end
+
+test "renders h3 heading" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      h3 "Section"
+    end
+  end
+
+  assert_equal example.new.call, "### Section\n"
+end
+
+test "renders h4-h6 headings" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      h4 "Level 4"
+      h5 "Level 5"
+      h6 "Level 6"
+    end
+  end
+
+  assert_equal example.new.call, "#### Level 4\n##### Level 5\n###### Level 6\n"
+end
+
+test "renders paragraph" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      p "This is a paragraph."
+    end
+  end
+
+  assert_equal example.new.call, "This is a paragraph.\n\n"
+end
+
+test "renders strong text" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      p do
+        plain "This is "
+        strong "bold"
+        plain " text."
+      end
+    end
+  end
+
+  assert_equal example.new.call, "This is **bold** text.\n\n"
+end
+
+test "renders emphasized text" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      p do
+        plain "This is "
+        em "italic"
+        plain " text."
+      end
+    end
+  end
+
+  assert_equal example.new.call, "This is *italic* text.\n\n"
+end
+
+test "renders inline code" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      p do
+        plain "Use "
+        code "puts 'hello'"
+        plain " to print."
+      end
+    end
+  end
+
+  assert_equal example.new.call, "Use `puts 'hello'` to print.\n\n"
+end
+
+test "renders links" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      p do
+        a(href: "https://example.com") { "Click here" }
+      end
+    end
+  end
+
+  assert_equal example.new.call, "[Click here](https://example.com)\n\n"
+end
+
+test "separates multiple paragraphs with blank line" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      p "First paragraph."
+      p "Second paragraph."
+    end
+  end
+
+  assert_equal example.new.call, "First paragraph.\n\nSecond paragraph.\n\n"
+end
+
+test "renders blockquotes" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      blockquote "This is a quote."
+    end
+  end
+
+  assert_equal example.new.call, "> This is a quote.\n\n"
+end
+
+test "renders blockquotes with block content" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      blockquote do
+        plain "This is a "
+        strong "quoted"
+        plain " text."
+      end
+    end
+  end
+
+  assert_equal example.new.call, "> This is a **quoted** text.\n\n"
+end
+
+test "renders multiline blockquotes" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      blockquote "Line 1\nLine 2\nLine 3"
+    end
+  end
+
+  assert_equal example.new.call, "> Line 1\n> Line 2\n> Line 3\n\n"
+end
+
+test "renders code blocks" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      pre do
+        plain "def hello\n  puts 'world'\nend"
+      end
+    end
+  end
+
+  assert_equal example.new.call, "```\ndef hello\n  puts 'world'\nend\n```\n\n"
+end
+
+test "renders code blocks with language" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      pre(language: "ruby") do
+        plain "def hello\n  puts 'world'\nend"
+      end
+    end
+  end
+
+  assert_equal example.new.call, "```ruby\ndef hello\n  puts 'world'\nend\n```\n\n"
+end
+
+test "renders unordered lists" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      ul do
+        li "First item"
+        li "Second item"
+        li "Third item"
+      end
+    end
+  end
+
+  assert_equal example.new.call, "- First item\n- Second item\n- Third item\n\n"
+end
+
+test "renders ordered lists" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      ol do
+        li "First item"
+        li "Second item"
+        li "Third item"
+      end
+    end
+  end
+
+  assert_equal example.new.call, "1. First item\n2. Second item\n3. Third item\n\n"
+end
+
+test "renders nested lists" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      ul do
+        li "Item 1"
+        li do
+          plain "Item 2"
+          ul do
+            li "Nested item 2.1"
+            li "Nested item 2.2"
+          end
+        end
+        li "Item 3"
+      end
+    end
+  end
+
+  assert_equal example.new.call, "- Item 1\n- Item 2\n  - Nested item 2.1\n  - Nested item 2.2\n- Item 3\n\n"
+end
+
+test "renders images" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      img(src: "https://example.com/image.jpg", alt: "Example image")
+    end
+  end
+
+  assert_equal example.new.call, "![Example image](https://example.com/image.jpg)"
+end
+
+test "renders images without alt text" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      img(src: "https://example.com/image.jpg")
+    end
+  end
+
+  assert_equal example.new.call, "![](https://example.com/image.jpg)"
+end
+
+test "renders horizontal rules" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      p "Above the line"
+      hr
+      p "Below the line"
+    end
+  end
+
+  assert_equal example.new.call, "Above the line\n\n---\n\nBelow the line\n\n"
+end
+
+test "renders line breaks" do
+  example = Class.new(MDPhlex::MD) do
+    def view_template
+      p do
+        plain "Line 1"
+        br
+        plain "Line 2"
+      end
+    end
+  end
+
+  assert_equal example.new.call, "Line 1  \nLine 2\n\n"
+end
+
+test "renders custom element registered with register_element" do
+  example = Class.new(MDPhlex::MD) do
+    register_element :system
+
+    def view_template
+      system { "System message" }
+    end
+  end
+
+  assert_equal example.new.call, "<system>System message</system>"
+end
+
+test "renders custom element with attributes" do
+  example = Class.new(MDPhlex::MD) do
+    register_element :system
+
+    def view_template
+      system(type: "warning", level: "high") { "Alert!" }
+    end
+  end
+
+  assert_equal example.new.call, '<system type="warning" level="high">Alert!</system>'
+end
+
+test "renders custom element within markdown context" do
+  example = Class.new(MDPhlex::MD) do
+    register_element :system
+
+    def view_template
+      p do
+        plain "This is a "
+        system { "system message" }
+        plain " in a paragraph."
+      end
+    end
+  end
+
+  assert_equal example.new.call, "This is a <system>system message</system> in a paragraph.\n\n"
+end
+
+test "renders nested custom block elements" do
+  example = Class.new(MDPhlex::MD) do
+    register_block_element :system
+    register_block_element :tools
+
+    def view_template
+      system do
+        h1 "Main:"
+        tools do
+          ul do
+            li "nested content 1"
+            li "nested content 2"
+          end
+        end
+      end
+    end
+  end
+
+  assert_equal example.new.call, <<~XML
+    <system>
+    # Main:
+    <tools>
+    - nested content 1
+    - nested content 2
+
+    </tools>
+    </system>
+  XML
+end
+
+test "register_block_element vs register_element spacing" do
+  example = Class.new(MDPhlex::MD) do
+    register_element :inline_tag
+    register_block_element :block_tag
+
+    def view_template
+      p do
+        plain "Text with "
+        inline_tag { "inline" }
+        plain " content."
+      end
+
+      block_tag { p "Block content" }
+
+      p "After block"
+    end
+  end
+
+  assert_equal example.new.call, <<~MD
+    Text with <inline-tag>inline</inline-tag> content.
+
+    <block-tag>
+    Block content
+
+    </block-tag>
+    After block
+
+  MD
+end
+
+test "register_block_element with attributes" do
+  example = Class.new(MDPhlex::MD) do
+    register_block_element :section
+
+    def view_template
+      section(id: "main", class: "container") do
+        h2 "Section Title"
+        p "Section content"
+      end
+    end
+  end
+
+  assert_equal example.new.call, <<~MD
+    <section id="main" class="container">
+    ## Section Title
+    Section content
+
+    </section>
+  MD
+end
+
+test "multiple register_block_elements" do
+  example = Class.new(MDPhlex::MD) do
+    register_block_element :article
+    register_block_element :aside
+
+    def view_template
+      article do
+        h1 "Main Article"
+        p "Article content"
+      end
+
+      aside do
+        h2 "Related"
+        p "Sidebar content"
+      end
+    end
+  end
+
+  assert_equal example.new.call, <<~MD
+    <article>
+    # Main Article
+    Article content
+
+    </article>
+    <aside>
+    ## Related
+    Sidebar content
+
+    </aside>
+  MD
+end

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: mdphlex
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Martin Emde
+bindir: exe
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: phlex
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+description: A Phlex-based Markdown renderer that generates Markdown output
+email:
+- me@martinemde.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- config/quickdraw.rb
+- lib/mdphlex.rb
+- lib/mdphlex/md.rb
+- lib/mdphlex/version.rb
+- quickdraw/interoperability.test.rb
+- quickdraw/mdphlex.test.rb
+homepage: https://github.com/martinemde/mdphlex
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/martinemde/mdphlex
+  source_code_uri: https://github.com/martinemde/mdphlex
+  changelog_uri: https://github.com/martinemde/mdphlex/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.9
+specification_version: 4
+summary: Markdown renderer for Phlex
+test_files: []