jekyll-webawesome 0.1.0

data/lib/jekyll/webawesome/transformers/base_transformer.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'English'
+require 'jekyll'
+require 'kramdown'
+
+module Jekyll
+  module WebAwesome
+    # Base class for all Web Awesome component transformers
+    # Each transformer should implement the transform method
+    class BaseTransformer
+      def self.transform(content)
+        raise NotImplementedError, 'Subclasses must implement the transform method'
+      end
+
+      class << self
+        protected
+
+        # Helper method to convert markdown content to HTML
+        def markdown_to_html(content)
+          Kramdown::Document.new(content).to_html
+        end
+
+        # Helper method to apply multiple regex patterns with the same transformation logic
+        # @param content [String] The content to transform
+        # @param patterns [Array<Hash>] Array of pattern hashes with :regex and :block
+        # @return [String] The transformed content
+        def apply_multiple_patterns(content, patterns)
+          patterns.each do |pattern|
+            content = content.gsub(pattern[:regex]) do |match|
+              pattern[:block].call(match, $LAST_MATCH_INFO)
+            end
+          end
+          content
+        end
+
+        # Helper method to create both primary and alternative syntax patterns
+        # @param primary_regex [Regexp] The primary syntax regex
+        # @param alternative_regex [Regexp] The alternative syntax regex
+        # @param transform_proc [Proc] The proc that takes captured groups and returns HTML
+        # @return [Array<Hash>] Array of pattern hashes
+        def dual_syntax_patterns(primary_regex, alternative_regex, transform_proc)
+          [
+            {
+              regex: primary_regex,
+              block: proc do |_match, matchdata|
+                # Get all captured groups from the matchdata
+                captures = matchdata.captures
+                transform_proc.call(*captures)
+              end
+            },
+            {
+              regex: alternative_regex,
+              block: proc do |_match, matchdata|
+                # Get all captured groups from the matchdata
+                captures = matchdata.captures
+                transform_proc.call(*captures)
+              end
+            }
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/webawesome/transformers/button_transformer.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require_relative 'base_transformer'
+
+module Jekyll
+  module WebAwesome
+    # Transforms button syntax into wa-button elements
+    # Primary syntax: %%%variant?\ncontent\n%%%
+    # Alternative syntax: :::wa-button variant?\ncontent\n:::
+    # Variants: brand, success, neutral, warning, danger
+    #
+    # Link buttons: %%%brand\n[Text](url)\n%%%
+    # Regular buttons: %%%brand\nText\n%%%
+    class ButtonTransformer < BaseTransformer
+      def self.transform(content)
+        # Define both regex patterns
+        primary_regex = /^%%%(brand|success|neutral|warning|danger)?\n(.*?)\n%%%/m
+        alternative_regex = /^:::wa-button\s*(brand|success|neutral|warning|danger)?\n(.*?)\n:::/m
+
+        # Define shared transformation logic
+        transform_proc = proc do |variant, button_content|
+          button_content = button_content.strip
+
+          build_button_html(button_content, variant)
+        end
+
+        # Apply both patterns
+        patterns = dual_syntax_patterns(primary_regex, alternative_regex, transform_proc)
+        apply_multiple_patterns(content, patterns)
+      end
+
+      class << self
+        private
+
+        def build_button_html(content, variant)
+          variant_attr = variant ? " variant=\"#{variant}\"" : ''
+
+          # Check if content contains a markdown link
+          link_match = content.match(/^\[([^\]]+)\]\(([^)]+)\)$/)
+
+          if link_match
+            # It's a link button
+            link_text = link_match[1]
+            link_url = link_match[2]
+
+            # Process any markdown in the link text (bold, italic, etc.)
+            button_html = markdown_to_html(link_text).strip
+            button_html = button_html.gsub(%r{^<p>(.*)</p>$}m, '\1')
+
+            # Fix whitespace issues like in badges
+            button_html = button_html.gsub(%r{(</\w+>)\s+}, '\1&nbsp;')
+
+            "<wa-button#{variant_attr} href=\"#{link_url}\">#{button_html}</wa-button>"
+          else
+            # It's a regular button
+            button_html = markdown_to_html(content).strip
+            button_html = button_html.gsub(%r{^<p>(.*)</p>$}m, '\1')
+
+            # Fix whitespace issues like in badges
+            button_html = button_html.gsub(%r{(</\w+>)\s+}, '\1&nbsp;')
+
+            "<wa-button#{variant_attr}>#{button_html}</wa-button>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/webawesome/transformers/callout_transformer.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative 'base_transformer'
+
+module Jekyll
+  module WebAwesome
+    # Transforms callout syntax into wa-callout elements
+    # Primary syntax: :::variant\ncontent\n:::
+    # Alternative syntax: :::wa-callout variant\ncontent\n:::
+    # Variants: info, success, neutral, warning, danger
+    class CalloutTransformer < BaseTransformer
+      def self.transform(content)
+        # Define both regex patterns
+        primary_regex = /^:::(info|success|neutral|warning|danger)\n(.*?)\n:::/m
+        alternative_regex = /^:::wa-callout\s+(info|success|neutral|warning|danger)\n(.*?)\n:::/m
+
+        # Define shared transformation logic
+        transform_proc = proc do |variant, inner_content|
+          attrs = callout_attributes(variant)
+
+          element_tag = "wa-callout#{attrs[:additional_params]}"
+          html_content = "#{attrs[:inner_prepend]}#{markdown_to_html(inner_content)}"
+
+          "<#{element_tag}>#{html_content}</wa-callout>"
+        end
+
+        # Apply both patterns
+        patterns = dual_syntax_patterns(primary_regex, alternative_regex, transform_proc)
+        apply_multiple_patterns(content, patterns)
+      end
+
+      class << self
+        private
+
+        def callout_attributes(variant)
+          case variant
+          when 'info'
+            {
+              additional_params: ' variant="brand"',
+              inner_prepend: '<wa-icon slot="icon" name="circle-info" variant="regular"></wa-icon>'
+            }
+          when 'success'
+            {
+              additional_params: ' variant="success"',
+              inner_prepend: '<wa-icon slot="icon" name="circle-check" variant="regular"></wa-icon>'
+            }
+          when 'neutral'
+            {
+              additional_params: ' variant="neutral"',
+              inner_prepend: '<wa-icon slot="icon" name="gear" variant="regular"></wa-icon>'
+            }
+          when 'warning'
+            {
+              additional_params: ' variant="warning"',
+              inner_prepend: '<wa-icon slot="icon" name="triangle-exclamation" variant="regular"></wa-icon>'
+            }
+          when 'danger'
+            {
+              additional_params: ' variant="danger"',
+              inner_prepend: '<wa-icon slot="icon" name="circle-exclamation" variant="regular"></wa-icon>'
+            }
+          else
+            {
+              additional_params: '',
+              inner_prepend: ''
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/webawesome/transformers/card_transformer.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require_relative 'base_transformer'
+
+module Jekyll
+  module WebAwesome
+    # Transforms card syntax into wa-card elements
+    # Primary syntax: ===appearance?\ncontent\n===
+    # Alternative syntax: :::wa-card appearance?\ncontent\n:::
+    # Appearances: outlined (default), filled, filled-outlined, plain, accent
+    class CardTransformer < BaseTransformer
+      def self.transform(content)
+        # Define both regex patterns
+        primary_regex = /^===(outlined|filled|filled-outlined|plain|accent)?\n(.*?)\n===/m
+        alternative_regex = /^:::wa-card\s*(outlined|filled|filled-outlined|plain|accent)?\n(.*?)\n:::/m
+
+        # Define shared transformation logic
+        transform_proc = proc do |appearance_param, card_content|
+          card_content = card_content.strip
+
+          appearance = normalize_appearance(appearance_param)
+          card_parts = parse_card_content(card_content)
+
+          build_card_html(card_parts, appearance)
+        end
+
+        # Apply both patterns
+        patterns = dual_syntax_patterns(primary_regex, alternative_regex, transform_proc)
+        apply_multiple_patterns(content, patterns)
+      end
+
+      class << self
+        private
+
+        def normalize_appearance(appearance_param)
+          case appearance_param
+          when 'filled', 'filled-outlined', 'plain', 'accent'
+            appearance_param
+          else
+            'outlined' # default
+          end
+        end
+
+        def parse_card_content(content)
+          parts = {
+            media: nil,
+            header: nil,
+            content: content,
+            footer: nil
+          }
+
+          # Extract first image as media
+          if content.match(/^!\[([^\]]*)\]\(([^)]+)\)/)
+            parts[:media] = {
+              alt: ::Regexp.last_match(1),
+              src: ::Regexp.last_match(2)
+            }
+            # Remove the image from content
+            content = content.sub(/^!\[([^\]]*)\]\(([^)]+)\)\n?/, '')
+          end
+
+          # Extract first heading as header
+          if content.match(/^# (.+)$/)
+            parts[:header] = ::Regexp.last_match(1).strip
+            # Remove the heading from content
+            content = content.sub(/^# .+\n?/, '')
+          end
+
+          # Extract trailing buttons/links as footer
+          # Look for links or buttons at the end of the content
+          if content.match(/\n\[([^\]]+)\]\(([^)]+)\)\s*$/)
+            parts[:footer] = {
+              text: ::Regexp.last_match(1),
+              href: ::Regexp.last_match(2)
+            }
+            # Remove the footer link from content
+            content = content.sub(/\n\[([^\]]+)\]\(([^)]+)\)\s*$/, '')
+          end
+
+          # Update the main content after extractions
+          parts[:content] = content.strip
+          parts
+        end
+
+        def build_card_html(parts, appearance)
+          attributes = []
+          attributes << "appearance=\"#{appearance}\"" if appearance != 'outlined'
+
+          # Add SSR attributes if slots are present
+          attributes << 'with-media' if parts[:media]
+          attributes << 'with-header' if parts[:header]
+          attributes << 'with-footer' if parts[:footer]
+
+          attr_string = attributes.empty? ? '' : " #{attributes.join(' ')}"
+
+          html_parts = []
+
+          # Media slot
+          html_parts << "<img slot=\"media\" src=\"#{parts[:media][:src]}\" alt=\"#{parts[:media][:alt]}\">" if parts[:media]
+
+          # Header slot
+          if parts[:header]
+            header_html = markdown_to_html(parts[:header])
+            html_parts << "<div slot=\"header\">#{header_html}</div>"
+          end
+
+          # Main content
+          if parts[:content] && !parts[:content].empty?
+            content_html = markdown_to_html(parts[:content])
+            html_parts << content_html
+          end
+
+          # Footer slot
+          html_parts << "<div slot=\"footer\"><wa-button href=\"#{parts[:footer][:href]}\">#{parts[:footer][:text]}</wa-button></div>" if parts[:footer]
+
+          "<wa-card#{attr_string}>#{html_parts.join}</wa-card>"
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/webawesome/transformers/details_transformer.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'base_transformer'
+
+module Jekyll
+  module WebAwesome
+    # Transforms summary/details syntax into wa-details elements
+    # Primary syntax: ^^^appearance?\nsummary\n>>>\ndetails\n^^^
+    # Alternative syntax: :::wa-details appearance?\nsummary\n>>>\ndetails\n:::
+    # Appearances: outlined (default), filled, filled-outlined, plain
+    class DetailsTransformer < BaseTransformer
+      def self.transform(content)
+        # Define both regex patterns
+        primary_regex = /^\^\^\^?(outlined|filled|filled-outlined|plain)?\n(.*?)\n^>>>\n(.*?)\n^\^\^\^?/m
+        alternative_regex = /^:::wa-details\s*(outlined|filled|filled-outlined|plain)?\n(.*?)\n^>>>\n(.*?)\n:::/m
+
+        # Define shared transformation logic
+        transform_proc = proc do |appearance_param, summary_content, details_content|
+          summary_content = summary_content.strip
+          details_content = details_content.strip
+
+          appearance_class = normalize_appearance(appearance_param)
+          summary_html = markdown_to_html(summary_content)
+          details_html = markdown_to_html(details_content)
+
+          "<wa-details appearance='#{appearance_class}'>" \
+          "<span slot='summary'>#{summary_html}</span>" \
+          "#{details_html}</wa-details>"
+        end
+
+        # Apply both patterns
+        patterns = dual_syntax_patterns(primary_regex, alternative_regex, transform_proc)
+        apply_multiple_patterns(content, patterns)
+      end
+
+      class << self
+        private
+
+        def normalize_appearance(appearance_param)
+          case appearance_param
+          when 'filled'
+            'filled'
+          when 'filled-outlined'
+            'filled outlined'
+          when 'plain'
+            'plain'
+          else
+            'outlined'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/webawesome/transformers/icon_transformer.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require_relative 'base_transformer'
+
+module Jekyll
+  module WebAwesome
+    # Transforms icon syntax into wa-icon elements
+    # Primary syntax: $$$icon-name
+    # Alternative syntax: :::wa-icon icon-name
+    #
+    # Examples:
+    # $$$settings -> <wa-icon name="settings"></wa-icon>
+    # $$$home -> <wa-icon name="home"></wa-icon>
+    # $$$user-circle -> <wa-icon name="user-circle"></wa-icon>
+    class IconTransformer < BaseTransformer
+      def self.transform(content)
+        # Protect code blocks first
+        protected_content, code_blocks = protect_code_blocks(content)
+
+        # Apply primary syntax transformation
+        # Only block patterns that look like incomplete icon names:
+        # $$$icon name (where 'icon name' could be intended as one identifier)
+        result = protected_content.gsub(/\$\$\$([a-zA-Z0-9\-_]+)(?![a-zA-Z0-9\-_]|\s+name\b)/) do
+          icon_name = ::Regexp.last_match(1)
+          build_icon_html(icon_name)
+        end
+
+        # Apply alternative syntax transformation
+        result = result.gsub(/:::wa-icon\s+([a-zA-Z0-9\-_]+)\s*\n:::/m) do
+          icon_name = ::Regexp.last_match(1)
+          build_icon_html(icon_name)
+        end
+
+        # Restore code blocks
+        restore_code_blocks(result, code_blocks)
+      end
+
+      class << self
+        private
+
+        def build_icon_html(icon_name)
+          # Clean and validate icon name
+          clean_name = icon_name.strip
+
+          # Return the wa-icon element
+          "<wa-icon name=\"#{clean_name}\"></wa-icon>"
+        end
+
+        def protect_code_blocks(content)
+          code_blocks = {}
+          counter = 0
+
+          # Protect fenced code blocks
+          protected = content.gsub(/```.*?```/m) do |match|
+            placeholder = "ICON_PROTECTED_CODE_BLOCK_#{counter}"
+            code_blocks[placeholder] = match
+            counter += 1
+            placeholder
+          end
+
+          # Protect inline code
+          protected = protected.gsub(/`[^`]+`/) do |match|
+            placeholder = "ICON_PROTECTED_INLINE_CODE_#{counter}"
+            code_blocks[placeholder] = match
+            counter += 1
+            placeholder
+          end
+
+          [protected, code_blocks]
+        end
+
+        def restore_code_blocks(content, code_blocks)
+          result = content
+          code_blocks.each do |placeholder, original|
+            result = result.gsub(placeholder, original)
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/webawesome/transformers/tabs_transformer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative 'base_transformer'
+
+module Jekyll
+  module WebAwesome
+    # Transforms tabs syntax into wa-tab-group elements
+    # Primary syntax: ++++++placement?\n+++tab1\ncontent\n+++\n+++tab2\ncontent\n+++\n++++++
+    # Alternative syntax: :::wa-tabs placement?\n+++tab1\ncontent\n+++\n+++tab2\ncontent\n+++\n:::
+    # Placements: top (default), bottom, start, end
+    class TabsTransformer < BaseTransformer
+      def self.transform(content)
+        # Define both regex patterns
+        primary_regex = /^\+{6}(top|bottom|start|end)?\n((\+\+\+ [^\n]+\n.*?\n\+\+\+\n?)+)\+{6}/m
+        alternative_regex = /^:::wa-tabs\s*(top|bottom|start|end)?\n((\+\+\+ [^\n]+\n.*?\n\+\+\+\n?)+):::/m
+
+        # Define shared transformation logic
+        transform_proc = proc do |placement, tabs_block, _third_capture|
+          placement ||= 'top'
+
+          tabs, tab_panels = extract_tabs_and_panels(tabs_block)
+
+          "<wa-tab-group placement=\"#{placement}\">#{tabs.join}#{tab_panels.join}</wa-tab-group>"
+        end
+
+        # Apply both patterns
+        patterns = dual_syntax_patterns(primary_regex, alternative_regex, transform_proc)
+        apply_multiple_patterns(content, patterns)
+      end
+
+      class << self
+        private
+
+        def extract_tabs_and_panels(tabs_block)
+          # Extract individual tabs
+          tab_contents = tabs_block.scan(/^\+\+\+ ([^\n]+)\n(.*?)\n\+\+\+/m)
+          tabs = []
+          tab_panels = []
+
+          tab_contents.each_with_index do |(title, panel_content), index|
+            tab_id = "tab-#{index + 1}"
+            tabs << "<wa-tab panel=\"#{tab_id}\">#{title.strip}</wa-tab>"
+
+            panel_html = markdown_to_html(panel_content.strip)
+            tab_panels << "<wa-tab-panel name=\"#{tab_id}\">#{panel_html}</wa-tab-panel>"
+          end
+
+          [tabs, tab_panels]
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/webawesome/transformers/tag_transformer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'base_transformer'
+
+module Jekyll
+  module WebAwesome
+    # Transforms tag syntax into wa-tag elements
+    # Primary syntax: @@@variant?\ncontent\n@@@
+    # Alternative syntax: :::wa-tag variant?\ncontent\n:::
+    # Variants: brand, success, neutral, warning, danger
+    class TagTransformer < BaseTransformer
+      def self.transform(content)
+        # Define both regex patterns
+        primary_regex = /^@@@(brand|success|neutral|warning|danger)?\n(.*?)\n@@@/m
+        alternative_regex = /^:::wa-tag\s*(brand|success|neutral|warning|danger)?\n(.*?)\n:::/m
+
+        # Define shared transformation logic
+        transform_proc = proc do |variant, tag_content|
+          tag_content = tag_content.strip
+
+          build_tag_html(tag_content, variant)
+        end
+
+        # Apply both patterns
+        patterns = dual_syntax_patterns(primary_regex, alternative_regex, transform_proc)
+        apply_multiple_patterns(content, patterns)
+      end
+
+      class << self
+        private
+
+        def build_tag_html(content, variant)
+          variant_attr = variant ? " variant=\"#{variant}\"" : ''
+          tag_html = markdown_to_html(content).strip
+
+          # Remove paragraph tags if the content is just text
+          tag_html = tag_html.gsub(%r{^<p>(.*)</p>$}m, '\1')
+
+          "<wa-tag#{variant_attr}>#{tag_html}</wa-tag>"
+        end
+      end
+    end
+  end
+end

data/lib/jekyll/webawesome/transformers.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+# Index file for all Web Awesome transformers
+# This file makes it easy to require all transformers at once
+
+require_relative 'transformers/base_transformer'
+require_relative 'transformers/badge_transformer'
+require_relative 'transformers/button_transformer'
+require_relative 'transformers/callout_transformer'
+require_relative 'transformers/card_transformer'
+require_relative 'transformers/details_transformer'
+require_relative 'transformers/icon_transformer'
+require_relative 'transformers/tabs_transformer'
+require_relative 'transformers/tag_transformer'

data/lib/jekyll/webawesome/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Jekyll
+  module WebAwesome
+    VERSION = '0.1.0'
+  end
+end

data/lib/jekyll/webawesome.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'webawesome/version'
+require_relative 'webawesome/transformer'
+require_relative 'webawesome/code_block_transformer'
+require_relative 'webawesome/plugin'
+
+module Jekyll
+  # Main module for Jekyll WebAwesome plugin
+  module WebAwesome
+    class Error < StandardError; end
+
+    # Configuration options
+    class << self
+      attr_accessor :configuration
+
+      def configure
+        self.configuration ||= Configuration.new
+        yield(configuration) if block_given?
+        configuration
+      end
+    end
+
+    # Configuration class for future extensibility
+    class Configuration
+      attr_accessor :debug_mode, :callout_icons, :custom_components
+
+      def initialize
+        @debug_mode = false
+        @callout_icons = default_callout_icons
+        @custom_components = {}
+      end
+
+      private
+
+      def default_callout_icons
+        {
+          info: 'circle-info',
+          success: 'circle-check',
+          neutral: 'gear',
+          warning: 'triangle-exclamation',
+          danger: 'circle-exclamation'
+        }
+      end
+    end
+  end
+end

data/lib/jekyll-webawesome.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'jekyll_webawesome'

data/lib/jekyll_webawesome.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative 'jekyll/webawesome'