markawesome 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e7ee0dc5c92fb7e9774b22ff56152d96d47a5eaf16da5f5a0181eda5e61aae57
-  data.tar.gz: 321ab99ac9d4b1bc7355a898271bcaf14aa8edf7bbeeafebf3b307d2ce0dd041
+  metadata.gz: adad1d3e9850c4d1f82b4cbe73eb56ac9c82c413e66ea0adb1291794a3a9a25a
+  data.tar.gz: 07b7741a6e96f7031d38d1e10d6ca6a0314d5edd05341222f1f7d7964904d1c4
 SHA512:
-  metadata.gz: de9cc698634f6e9d741317fa48a98d46619869949ca4641615a08c55504e253ecd4c292e3cc4a6b89ff7c394f277b5671c22c58b38e1f5839b751147a2cc6c5a
-  data.tar.gz: 736f49201d6323f34cc9c4ca198db98a8cd34ff0c4ec891649aafce06360f497ea797a697f623ee93f23807461334e05fa5df1fe76b76d39019fdc363c3b109d
+  metadata.gz: b4af697c90bf1d4a0d7d10de6fac07f784319b01d45b58fdcfb190475e97f4e5164b7b5fe7e7fd7475aece2651c78cd31181059cb7a8c1ec01ea33c05a154f11
+  data.tar.gz: ecca3f31fb0b27db1572cea1c82a2989434948699fe2125f8020f0cdd04e39f03a7d2426fbacfff8d65eba0252e6cdf0056a05d93ff7587ae85d39652e076553

data/CHANGELOG.md

@@ -4,6 +4,30 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/) and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.3.0] - 2026-02-08
+
+### Added
+
+- **TagTransformer**: Comprehensive attribute support including variant, size, appearance, pill, and removable
+- **TabsTransformer**: Added activation, active, and no-scroll-controls attributes
+- **DetailsTransformer**: Added disabled, open, and name attributes
+- **CopyButtonTransformer**: Comprehensive attribute support including variant, size, appearance, and disabled
+- **CarouselTransformer**: Added autoplay-interval attribute support
+- **CardTransformer**: Added orientation support
+
+### Changed
+
+- **AttributeParser Refactoring**: Migrated DetailsTransformer and CarouselTransformer to use AttributeParser for consistent, flexible attribute handling
+- **DialogTransformer**: Refactored to use AttributeParser for improved attribute parsing
+- **CardTransformer**: Refactored to use AttributeParser
+- Added RuboCop configuration for better code quality management
+
+### Improved
+
+- Consistent attribute parsing across all major transformers
+- Better test coverage for all new attributes
+- More flexible, order-independent parameter syntax
+
 ## [0.2.0] - 2025-10-27
 
 ### Added

data/lib/markawesome/attribute_parser.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Markawesome
+  # Parses space-separated attributes from a parameter string
+  # Supports multiple values per attribute with rightmost-wins semantics
+  # Useful for flexible syntax like "pill pulse brand" where order doesn't matter
+  class AttributeParser
+    # Parse space-separated parameters into an attribute hash
+    # @param params_string [String] Space-separated parameter string
+    # @param attribute_schema [Hash] Schema defining attributes and allowed values
+    #   Example: { variant: %w[brand success], pill: [true], attention: %w[pulse bounce] }
+    # @return [Hash] Parsed attributes with resolved values
+    def self.parse(params_string, attribute_schema)
+      return {} if params_string.nil? || params_string.strip.empty?
+
+      parsed = {}
+      tokens = params_string.strip.split(/\s+/)
+
+      tokens.each do |token|
+        attribute_schema.each do |attr_name, allowed_values|
+          next unless allowed_values.include?(token)
+
+          # Rightmost-wins: latest value for this attribute wins
+          parsed[attr_name] = token
+          break # Move to next token once we've matched it
+        end
+        # Tokens that don't match any attribute are silently ignored
+      end
+
+      parsed
+    end
+
+    # Check if a token is valid for an attribute
+    # @param token [String] The token to check
+    # @param allowed_values [Array] Allowed values for the attribute
+    # @return [Boolean] True if token is in allowed values
+    def self.valid_token?(token, allowed_values)
+      allowed_values.include?(token)
+    end
+  end
+end

data/lib/markawesome/transformers/badge_transformer.rb

@@ -1,23 +1,39 @@
 # frozen_string_literal: true
 
 require_relative 'base_transformer'
+require_relative '../attribute_parser'
 
 module Markawesome
   # Transforms badge syntax into wa-badge elements
-  # Primary syntax: !!!variant?\ncontent\n!!!
-  # Alternative syntax: :::wa-badge variant?\ncontent\n:::
+  # Primary syntax: !!!params?\ncontent\n!!!
+  # Alternative syntax: :::wa-badge params?\ncontent\n:::
+  #
+  # Params: space-separated tokens, any order (rightmost-wins for conflicts)
   # Variants: brand, success, neutral, warning, danger
+  # Appearance: accent, filled, outlined, filled-outlined
+  # Attention: none, pulse, bounce
+  # Flags: pill
   class BadgeTransformer < BaseTransformer
+    BADGE_ATTRIBUTES = {
+      variant: %w[brand success neutral warning danger],
+      appearance: %w[accent filled outlined filled-outlined],
+      attention: %w[none pulse bounce],
+      pill: %w[pill]
+    }.freeze
+
     def self.transform(content)
-      # Define both regex patterns
-      primary_regex = /^!!!(brand|success|neutral|warning|danger)?\n(.*?)\n!!!/m
-      alternative_regex = /^:::wa-badge\s*(brand|success|neutral|warning|danger)?\n(.*?)\n:::/m
+      # Define both regex patterns - capture params as a single string
+      primary_regex = /^!!!(.*?)\n(.*?)\n!!!/m
+      alternative_regex = /^:::wa-badge\s*(.*?)\n(.*?)\n:::/m
 
       # Define shared transformation logic
-      transform_proc = proc do |variant, badge_content|
+      transform_proc = proc do |params_string, badge_content|
         badge_content = badge_content.strip
 
-        build_badge_html(badge_content, variant)
+        # Parse space-separated parameters
+        attributes = AttributeParser.parse(params_string, BADGE_ATTRIBUTES)
+
+        build_badge_html(badge_content, attributes)
       end
 
       # Apply both patterns
@@ -28,8 +44,7 @@ module Markawesome
     class << self
       private
 
-      def build_badge_html(content, variant)
-        variant_attr = variant ? " variant=\"#{variant}\"" : ''
+      def build_badge_html(content, attributes)
         badge_html = markdown_to_html(content).strip
 
         # Remove paragraph tags if the content is just text
@@ -39,7 +54,16 @@ module Markawesome
         # Replace spaces after closing tags with non-breaking spaces to prevent CSS collapse
         badge_html = badge_html.gsub(%r{(</\w+>)\s+}, '\1&nbsp;')
 
-        "<wa-badge#{variant_attr}>#{badge_html}</wa-badge>"
+        # Build HTML attributes
+        attr_parts = []
+        attr_parts << "variant=\"#{attributes[:variant]}\"" if attributes[:variant]
+        attr_parts << "appearance=\"#{attributes[:appearance]}\"" if attributes[:appearance]
+        attr_parts << "attention=\"#{attributes[:attention]}\"" if attributes[:attention]
+        attr_parts << 'pill' if attributes[:pill]
+
+        attrs_string = attr_parts.empty? ? '' : " #{attr_parts.join(' ')}"
+
+        "<wa-badge#{attrs_string}>#{badge_html}</wa-badge>"
       end
     end
   end

data/lib/markawesome/transformers/button_transformer.rb

@@ -1,26 +1,49 @@
 # frozen_string_literal: true
 
 require_relative 'base_transformer'
+require_relative '../attribute_parser'
 
 module Markawesome
   # 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
+  # Primary syntax: %%%attributes?\ncontent\n%%%
+  # Alternative syntax: :::wa-button attributes?\ncontent\n:::
+  #
+  # Attributes:
+  # - variant: brand, success, neutral, warning, danger
+  # - appearance: accent, filled, outlined, filled-outlined, plain
+  # - size: small, medium, large
+  # - pill: pill (rounded edges)
+  # - caret: caret (dropdown indicator)
+  # - loading: loading (loading state)
+  # - disabled: disabled (disabled state)
   #
   # Link buttons: %%%brand\n[Text](url)\n%%%
-  # Regular buttons: %%%brand\nText\n%%%
+  # Regular buttons: %%%brand large pill\nText\n%%%
   class ButtonTransformer < BaseTransformer
+    # Define the schema for button attributes
+    BUTTON_ATTRIBUTES = {
+      variant: %w[brand success neutral warning danger],
+      appearance: %w[accent filled outlined filled-outlined plain],
+      size: %w[small medium large],
+      pill: %w[pill],
+      caret: %w[caret],
+      loading: %w[loading],
+      disabled: %w[disabled]
+    }.freeze
+
     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 both regex patterns - capture all space-separated parameters
+      primary_regex = /^%%%([^\n]*)\n(.*?)\n%%%/m
+      alternative_regex = /^:::wa-button\s*([^\n]*)\n(.*?)\n:::/m
 
       # Define shared transformation logic
-      transform_proc = proc do |variant, button_content|
+      transform_proc = proc do |params_string, button_content|
         button_content = button_content.strip
 
-        build_button_html(button_content, variant)
+        # Parse attributes using AttributeParser
+        attributes = AttributeParser.parse(params_string, BUTTON_ATTRIBUTES)
+
+        build_button_html(button_content, attributes)
       end
 
       # Apply both patterns
@@ -31,8 +54,19 @@ module Markawesome
     class << self
       private
 
-      def build_button_html(content, variant)
-        variant_attr = variant ? " variant=\"#{variant}\"" : ''
+      def build_button_html(content, attributes)
+        # Build HTML attributes from parsed attributes
+        html_attrs = []
+
+        html_attrs << "variant=\"#{attributes[:variant]}\"" if attributes[:variant]
+        html_attrs << "appearance=\"#{attributes[:appearance]}\"" if attributes[:appearance]
+        html_attrs << "size=\"#{attributes[:size]}\"" if attributes[:size]
+        html_attrs << 'pill' if attributes[:pill]
+        html_attrs << 'with-caret' if attributes[:caret]
+        html_attrs << 'loading' if attributes[:loading]
+        html_attrs << 'disabled' if attributes[:disabled]
+
+        attrs_string = html_attrs.empty? ? '' : " #{html_attrs.join(' ')}"
 
         # Check if content contains a markdown link
         link_match = content.match(/^\[([^\]]+)\]\(([^)]+)\)$/)
@@ -49,7 +83,7 @@ module Markawesome
           # 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>"
+          "<wa-button#{attrs_string} href=\"#{link_url}\">#{button_html}</wa-button>"
         else
           # It's a regular button
           button_html = markdown_to_html(content).strip
@@ -58,7 +92,7 @@ module Markawesome
           # Fix whitespace issues like in badges
           button_html = button_html.gsub(%r{(</\w+>)\s+}, '\1&nbsp;')
 
-          "<wa-button#{variant_attr}>#{button_html}</wa-button>"
+          "<wa-button#{attrs_string}>#{button_html}</wa-button>"
         end
       end
     end

data/lib/markawesome/transformers/callout_transformer.rb

@@ -1,29 +1,42 @@
 # frozen_string_literal: true
 
 require_relative 'base_transformer'
+require_relative '../attribute_parser'
 
 module Markawesome
   # 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
+  # Primary syntax: :::variant [size] [appearance]\ncontent\n:::
+  # Alternative syntax: :::wa-callout variant [size] [appearance]\ncontent\n:::
+  # Variants: brand, info (alias for brand), success, neutral, warning, danger
+  # Size: small, medium, large
+  # Appearance: accent, filled, outlined, plain, filled-outlined
   class CalloutTransformer < BaseTransformer
+    VARIANTS = %w[info brand success neutral warning danger].freeze
+    CALLOUT_ATTRIBUTES = {
+      size: %w[small medium large],
+      appearance: %w[accent filled outlined plain filled-outlined]
+    }.freeze
+    VARIANT_ALIASES = { 'info' => 'brand' }.freeze
+
     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
+      variant_pattern = VARIANTS.join('|')
+      primary_regex = /^:::(#{variant_pattern})([^\n]*)\n(.*?)\n:::/m
+      alternative_regex = /^:::wa-callout\s+(#{variant_pattern})([^\n]*)\n(.*?)\n:::/m
+
+      transform_proc = proc do |variant, extra_params, inner_content|
+        actual_variant = VARIANT_ALIASES.fetch(variant, variant)
+        extra_attrs = AttributeParser.parse(extra_params, CALLOUT_ATTRIBUTES)
 
-      # Define shared transformation logic
-      transform_proc = proc do |variant, inner_content|
-        attrs = callout_attributes(variant)
+        attr_parts = ["variant=\"#{actual_variant}\""]
+        attr_parts << "appearance=\"#{extra_attrs[:appearance]}\"" if extra_attrs[:appearance]
+        attr_parts << "size=\"#{extra_attrs[:size]}\"" if extra_attrs[:size]
 
-        element_tag = "wa-callout#{attrs[:additional_params]}"
-        html_content = "#{attrs[:inner_prepend]}#{markdown_to_html(inner_content)}"
+        icon_html = icon_for(actual_variant)
+        html_content = "#{icon_html}#{markdown_to_html(inner_content)}"
 
-        "<#{element_tag}>#{html_content}</wa-callout>"
+        "<wa-callout #{attr_parts.join(' ')}>#{html_content}</wa-callout>"
       end
 
-      # Apply both patterns
       patterns = dual_syntax_patterns(primary_regex, alternative_regex, transform_proc)
       apply_multiple_patterns(content, patterns)
     end
@@ -31,48 +44,16 @@ module Markawesome
     class << self
       private
 
-      def callout_attributes(variant)
-        # Get icon from configuration if available
+      def icon_for(variant)
         config = Markawesome.configuration
         icons = config&.callout_icons || default_icons
-
-        case variant
-        when 'info'
-          {
-            additional_params: ' variant="brand"',
-            inner_prepend: "<wa-icon slot=\"icon\" name=\"#{icons[:info]}\" variant=\"solid\"></wa-icon>"
-          }
-        when 'success'
-          {
-            additional_params: ' variant="success"',
-            inner_prepend: "<wa-icon slot=\"icon\" name=\"#{icons[:success]}\" variant=\"solid\"></wa-icon>"
-          }
-        when 'neutral'
-          {
-            additional_params: ' variant="neutral"',
-            inner_prepend: "<wa-icon slot=\"icon\" name=\"#{icons[:neutral]}\" variant=\"solid\"></wa-icon>"
-          }
-        when 'warning'
-          {
-            additional_params: ' variant="warning"',
-            inner_prepend: "<wa-icon slot=\"icon\" name=\"#{icons[:warning]}\" variant=\"solid\"></wa-icon>"
-          }
-        when 'danger'
-          {
-            additional_params: ' variant="danger"',
-            inner_prepend: "<wa-icon slot=\"icon\" name=\"#{icons[:danger]}\" variant=\"solid\"></wa-icon>"
-          }
-        else
-          {
-            additional_params: '',
-            inner_prepend: ''
-          }
-        end
+        icon_name = icons[variant.to_sym]
+        "<wa-icon slot=\"icon\" name=\"#{icon_name}\" variant=\"solid\"></wa-icon>"
       end
 
       def default_icons
         {
-          info: 'circle-info',
+          brand: 'circle-info',
           success: 'circle-check',
           neutral: 'gear',
           warning: 'triangle-exclamation',

data/lib/markawesome/transformers/card_transformer.rb

@@ -1,26 +1,34 @@
 # frozen_string_literal: true
 
 require_relative 'base_transformer'
+require_relative '../attribute_parser'
 
 module Markawesome
   # 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
+  # Primary syntax: ===params?\ncontent\n===
+  # Alternative syntax: :::wa-card params?\ncontent\n:::
+  # Supported attributes:
+  #   appearance: outlined (default), filled, filled-outlined, plain, accent
+  #   orientation: vertical (default), horizontal
   class CardTransformer < BaseTransformer
+    CARD_ATTRIBUTES = {
+      appearance: %w[outlined filled filled-outlined plain accent],
+      orientation: %w[vertical horizontal]
+    }.freeze
+
     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 both regex patterns - capture any params
+      primary_regex = /^===([^\n]*)\n(.*?)\n===/m
+      alternative_regex = /^:::wa-card\s*([^\n]*)\n(.*?)\n:::/m
 
       # Define shared transformation logic
-      transform_proc = proc do |appearance_param, card_content|
+      transform_proc = proc do |params_string, card_content|
         card_content = card_content.strip
 
-        appearance = normalize_appearance(appearance_param)
+        attributes = AttributeParser.parse(params_string, CARD_ATTRIBUTES)
         card_parts = parse_card_content(card_content)
 
-        build_card_html(card_parts, appearance)
+        build_card_html(card_parts, attributes)
       end
 
       # Apply both patterns
@@ -31,15 +39,6 @@ module Markawesome
     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,
@@ -81,21 +80,28 @@ module Markawesome
         parts
       end
 
-      def build_card_html(parts, appearance)
-        attributes = []
-        attributes << "appearance=\"#{appearance}\"" if appearance != 'outlined'
+      def build_card_html(parts, attributes)
+        # Extract appearance and orientation from attributes
+        appearance = attributes[:appearance] || 'outlined'
+        orientation = attributes[:orientation] || 'vertical'
+
+        html_attrs = []
+        html_attrs << "appearance=\"#{appearance}\"" if appearance != 'outlined'
+        html_attrs << "orientation=\"#{orientation}\"" if orientation != 'vertical'
 
         # 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]
+        html_attrs << 'with-media' if parts[:media]
+        html_attrs << 'with-header' if parts[:header]
+        html_attrs << 'with-footer' if parts[:footer]
 
-        attr_string = attributes.empty? ? '' : " #{attributes.join(' ')}"
+        attr_string = html_attrs.empty? ? '' : " #{html_attrs.join(' ')}"
 
         html_parts = []
 
         # Media slot
-        html_parts << "<img slot=\"media\" src=\"#{parts[:media][:src]}\" alt=\"#{parts[:media][:alt]}\">" if parts[:media]
+        if parts[:media]
+          html_parts << "<img slot=\"media\" src=\"#{parts[:media][:src]}\" alt=\"#{parts[:media][:alt]}\">"
+        end
 
         # Header slot
         if parts[:header]
@@ -110,7 +116,9 @@ module Markawesome
         end
 
         # Footer slot
-        html_parts << "<div slot=\"footer\"><wa-button href=\"#{parts[:footer][:href]}\">#{parts[:footer][:text]}</wa-button></div>" if parts[:footer]
+        if parts[:footer]
+          html_parts << "<div slot=\"footer\"><wa-button href=\"#{parts[:footer][:href]}\">#{parts[:footer][:text]}</wa-button></div>"
+        end
 
         "<wa-card#{attr_string}>#{html_parts.join}</wa-card>"
       end

data/lib/markawesome/transformers/carousel_transformer.rb

@@ -1,14 +1,25 @@
 # frozen_string_literal: true
 
 require_relative 'base_transformer'
+require_relative '../attribute_parser'
 
 module Markawesome
   # Transforms carousel syntax into wa-carousel elements
   # Primary syntax: ~~~~~~params\n~~~ slide1\ncontent\n~~~\n~~~ slide2\ncontent\n~~~\n~~~~~~
   # Alternative syntax: :::wa-carousel params\n~~~ slide1\ncontent\n~~~\n~~~ slide2\ncontent\n~~~\n:::
   # Params can include: numbers (slides-per-page, slides-per-move), keywords (loop, navigation, pagination,
-  # autoplay, mouse-dragging, vertical), and CSS properties (scroll-hint:value, aspect-ratio:value, slide-gap:value)
+  # autoplay, mouse-dragging, vertical), key-value pairs (autoplay-interval:value), and CSS properties
+  # (scroll-hint:value, aspect-ratio:value, slide-gap:value)
   class CarouselTransformer < BaseTransformer
+    COMPONENT_ATTRIBUTES = {
+      loop: %w[loop],
+      navigation: %w[navigation],
+      pagination: %w[pagination],
+      autoplay: %w[autoplay],
+      'mouse-dragging': %w[mouse-dragging],
+      vertical: %w[vertical]
+    }.freeze
+
     def self.transform(content)
       # Define both regex patterns
       # Match: ~~~~~~params (optional)
@@ -44,14 +55,29 @@ module Markawesome
           css_vars: {}
         }
 
+        # Parse boolean flags using AttributeParser
+        attributes = AttributeParser.parse(params, COMPONENT_ATTRIBUTES)
+
+        # Convert boolean attributes to result format
+        attributes.each_key do |key|
+          if key == :vertical
+            result[:attributes]['orientation'] = 'vertical'
+          else
+            result[:attributes][key.to_s] = true
+          end
+        end
+
+        # Parse numeric and key:value tokens manually
         tokens = params.strip.split(/\s+/)
         numeric_count = 0
 
         tokens.each do |token|
-          # Check for CSS custom properties (key:value)
+          # Check for key:value pairs (attributes and CSS custom properties)
           if token.include?(':')
             key, value = token.split(':', 2)
             case key
+            when 'autoplay-interval'
+              result[:attributes]['autoplay-interval'] = value
             when 'scroll-hint'
               result[:css_vars]['--scroll-hint'] = value
             when 'aspect-ratio'
@@ -69,14 +95,6 @@ module Markawesome
             elsif numeric_count == 2
               result[:attributes]['slides-per-move'] = token
             end
-          # Check for boolean flags
-          elsif %w[loop navigation pagination autoplay mouse-dragging vertical].include?(token)
-            # For orientation, we need to handle it specially
-            if token == 'vertical'
-              result[:attributes]['orientation'] = 'vertical'
-            else
-              result[:attributes][token] = true
-            end
           end
         end
 

data/lib/markawesome/transformers/copy_button_transformer.rb

@@ -1,31 +1,64 @@
 # frozen_string_literal: true
 
 require_relative 'base_transformer'
+require_relative '../attribute_parser'
 
 module Markawesome
   # Transforms copy button syntax into wa-copy-button elements
-  # Primary syntax: <<<\ncontent\n<<<
-  # Alternative syntax: :::wa-copy-button\ncontent\n:::
+  # Primary syntax: <<<params?\ncontent\n<<<
+  # Alternative syntax: :::wa-copy-button params?\ncontent\n:::
+  #
+  # Params: space-separated tokens, any order (rightmost-wins for conflicts)
+  # Placement: top, right, bottom, left
+  # Duration: numeric value (feedback-duration in milliseconds)
+  # Flags: disabled
+  # Labels: copy-label="text", success-label="text", error-label="text"
+  # From: from="element-id" (copy from another element)
   #
   # Usage:
   # <<<
   # This text will be copied to clipboard
   # <<<
   #
-  # :::wa-copy-button
-  # Copy this text
+  # <<<disabled top 2000
+  # Disabled copy button with top tooltip and 2s feedback
+  # <<<
+  #
+  # <<<copy-label="Click to copy" success-label="Copied!"
+  # Custom labels
+  # <<<
+  #
+  # :::wa-copy-button right from="my-element"
+  # Copy from element with ID "my-element"
   # :::
   class CopyButtonTransformer < BaseTransformer
+    COPY_BUTTON_ATTRIBUTES = {
+      placement: %w[top right bottom left],
+      disabled: %w[disabled]
+    }.freeze
+
     def self.transform(content)
-      # Define both regex patterns
-      primary_regex = /^<<<\n(.*?)\n<<</m
-      alternative_regex = /^:::wa-copy-button\n(.*?)\n:::/m
+      # Define both regex patterns - capture params as a single string
+      primary_regex = /^<<<(.*?)\n(.*?)\n<<</m
+      alternative_regex = /^:::wa-copy-button\s*(.*?)\n(.*?)\n:::/m
 
       # Define shared transformation logic
-      transform_proc = proc do |copy_content|
+      transform_proc = proc do |params_string, copy_content|
         copy_content = copy_content.strip
 
-        build_copy_button_html(copy_content)
+        # Parse space-separated parameters
+        attributes = AttributeParser.parse(params_string, COPY_BUTTON_ATTRIBUTES)
+
+        # Extract quoted labels and from attribute
+        attributes[:copy_label] = extract_quoted_attribute(params_string, 'copy-label')
+        attributes[:success_label] = extract_quoted_attribute(params_string, 'success-label')
+        attributes[:error_label] = extract_quoted_attribute(params_string, 'error-label')
+        attributes[:from] = extract_quoted_attribute(params_string, 'from')
+
+        # Extract numeric feedback-duration
+        attributes[:feedback_duration] = ::Regexp.last_match(1) if params_string =~ /\b(\d+)\b/
+
+        build_copy_button_html(copy_content, attributes)
       end
 
       # Apply both patterns
@@ -36,11 +69,44 @@ module Markawesome
     class << self
       private
 
-      def build_copy_button_html(content)
+      def build_copy_button_html(content, attributes)
         # Escape the content for the value attribute
         escaped_content = content.gsub('"', '&quot;').gsub("'", '&#39;')
 
-        "<wa-copy-button value=\"#{escaped_content}\"></wa-copy-button>"
+        # Build HTML attributes
+        attr_parts = []
+
+        # Add value or from attribute
+        attr_parts << if attributes[:from]
+                        "from=\"#{attributes[:from]}\""
+                      else
+                        "value=\"#{escaped_content}\""
+                      end
+
+        # Add tooltip placement
+        attr_parts << "tooltip-placement=\"#{attributes[:placement]}\"" if attributes[:placement]
+
+        # Add custom labels
+        attr_parts << "copy-label=\"#{attributes[:copy_label]}\"" if attributes[:copy_label]
+        attr_parts << "success-label=\"#{attributes[:success_label]}\"" if attributes[:success_label]
+        attr_parts << "error-label=\"#{attributes[:error_label]}\"" if attributes[:error_label]
+
+        # Add feedback duration
+        attr_parts << "feedback-duration=\"#{attributes[:feedback_duration]}\"" if attributes[:feedback_duration]
+
+        # Add disabled flag
+        attr_parts << 'disabled' if attributes[:disabled]
+
+        attrs_string = attr_parts.join(' ')
+
+        "<wa-copy-button #{attrs_string}></wa-copy-button>"
+      end
+
+      def extract_quoted_attribute(params_string, attr_name)
+        # Match attr-name="value" or attr-name='value'
+        return unless params_string =~ /#{Regexp.escape(attr_name)}=["']([^"']+)["']/
+
+        ::Regexp.last_match(1)
       end
     end
   end

data/lib/markawesome/transformers/details_transformer.rb

@@ -1,14 +1,24 @@
 # frozen_string_literal: true
 
 require_relative 'base_transformer'
+require_relative '../attribute_parser'
 
 module Markawesome
   # Transforms summary/details syntax into wa-details elements
-  # Primary syntax: ^^^appearance? icon-placement?\nsummary\n>>>\ndetails\n^^^
-  # Alternative syntax: :::wa-details appearance? icon-placement?\nsummary\n>>>\ndetails\n:::
+  # Primary syntax: ^^^appearance? icon-placement? disabled? open? name:value?\nsummary\n>>>\ndetails\n^^^
+  # Alternative syntax: :::wa-details appearance? icon-placement? disabled? open? name:value?\nsummary\n>>>\ndetails\n:::
   # Appearances: outlined (default), filled, filled-outlined, plain
   # Icon placement: start, end (default)
+  # Boolean flags: disabled, open
+  # Name: name:group-id for accordion behavior
   class DetailsTransformer < BaseTransformer
+    COMPONENT_ATTRIBUTES = {
+      appearance: %w[outlined filled filled-outlined plain],
+      icon_placement: %w[start end],
+      disabled: %w[disabled],
+      open: %w[open]
+    }.freeze
+
     def self.transform(content)
       # Define both regex patterns - capture parameter string
       primary_regex = /^\^\^\^?(.*?)\n(.*?)\n^>>>\n(.*?)\n^\^\^\^?/m
@@ -19,17 +29,26 @@ module Markawesome
         summary_content = summary_content.strip
         details_content = details_content.strip
 
-        # Parse parameters from the params string
-        appearance_param, icon_placement_param = parse_parameters(params_string)
+        # Parse parameters using AttributeParser
+        attributes = AttributeParser.parse(params_string, COMPONENT_ATTRIBUTES)
+
+        # Extract name parameter (format: name:value) - special handling
+        name_value = extract_name_value(params_string)
 
-        appearance_class = normalize_appearance(appearance_param)
-        icon_placement = normalize_icon_placement(icon_placement_param)
+        appearance_class = normalize_appearance(attributes[:appearance])
+        icon_placement = attributes[:icon_placement] || 'end'
         summary_html = markdown_to_html(summary_content)
         details_html = markdown_to_html(details_content)
 
-        "<wa-details appearance='#{appearance_class}' icon-placement='#{icon_placement}'>" \
-        "<span slot='summary'>#{summary_html}</span>" \
-        "#{details_html}</wa-details>"
+        # Build attributes
+        attr_parts = ["appearance='#{appearance_class}'", "icon-placement='#{icon_placement}'"]
+        attr_parts << 'disabled' if attributes[:disabled]
+        attr_parts << 'open' if attributes[:open]
+        attr_parts << "name='#{name_value}'" if name_value
+
+        "<wa-details #{attr_parts.join(' ')}>" \
+          "<span slot='summary'>#{summary_html}</span>" \
+          "#{details_html}</wa-details>"
       end
 
       # Apply both patterns
@@ -40,19 +59,13 @@ module Markawesome
     class << self
       private
 
-      def parse_parameters(params_string)
-        return [nil, nil] if params_string.nil? || params_string.strip.empty?
+      def extract_name_value(params_string)
+        return nil if params_string.nil? || params_string.strip.empty?
 
-        # Split by whitespace and extract known parameters
+        # Extract name parameter (format: name:value)
         tokens = params_string.strip.split(/\s+/)
-
-        appearance_options = %w[outlined filled filled-outlined plain]
-        placement_options = %w[start end]
-
-        appearance_param = tokens.find { |token| appearance_options.include?(token) }
-        icon_placement_param = tokens.find { |token| placement_options.include?(token) }
-
-        [appearance_param, icon_placement_param]
+        name_token = tokens.find { |token| token.start_with?('name:') }
+        name_token&.sub(/^name:/, '')
       end
 
       def normalize_appearance(appearance_param)
@@ -67,17 +80,6 @@ module Markawesome
           'outlined'
         end
       end
-
-      def normalize_icon_placement(icon_placement_param)
-        case icon_placement_param
-        when 'start'
-          'start'
-        when 'end'
-          'end'
-        else
-          'end'
-        end
-      end
     end
   end
 end

data/lib/markawesome/transformers/dialog_transformer.rb

@@ -2,14 +2,21 @@
 
 require 'digest'
 require_relative 'base_transformer'
+require_relative '../attribute_parser'
 
 module Markawesome
   # Transforms dialog syntax into wa-dialog elements with trigger buttons
   # Primary syntax: ???params\nbutton text\n>>>\ncontent\n???
   # Alternative syntax: :::wa-dialog params\nbutton text\n>>>\ncontent\n:::
-  # Params: light-dismiss and optional width (e.g., 500px, 50vw, 40em)
+  #
+  # Params: space-separated tokens (order doesn't matter)
+  # Flags: light-dismiss
+  # Width: CSS unit value (e.g., 500px, 50vw, 40em)
   # Note: Header with close X button is always enabled for accessibility
   class DialogTransformer < BaseTransformer
+    DIALOG_ATTRIBUTES = {
+      light_dismiss: %w[light-dismiss]
+    }.freeze
     def self.transform(content)
       # Define both regex patterns - capture parameter string, button text, and content
       # Params are on the same line as the opening delimiter
@@ -48,22 +55,17 @@ module Markawesome
     class << self
       private
 
-      # Parse parameters from the params string
+      # Parse parameters from the params string using AttributeParser
       def parse_parameters(params_string)
         return [false, nil] if params_string.nil? || params_string.strip.empty?
 
-        tokens = params_string.strip.split(/\s+/)
-
-        light_dismiss = tokens.include?('light-dismiss')
+        # Parse attributes using AttributeParser
+        attributes = AttributeParser.parse(params_string, DIALOG_ATTRIBUTES)
+        light_dismiss = attributes[:light_dismiss] == 'light-dismiss'
 
-        # Look for width parameter (last token with CSS units)
-        width = nil
-        tokens.reverse_each do |token|
-          if token.match?(/^\d+(\.\d+)?(px|em|rem|vw|vh|%|ch)$/)
-            width = token
-            break
-          end
-        end
+        # Look for width parameter (CSS unit value, not from predefined list)
+        tokens = params_string.strip.split(/\s+/)
+        width = tokens.find { |token| token.match?(/^\d+(\.\d+)?(px|em|rem|vw|vh|%|ch)$/) }
 
         [light_dismiss, width]
       end

data/lib/markawesome/transformers/image_dialog_transformer.rb

@@ -86,21 +86,21 @@ module Markawesome
       # Must protect both markdown syntax (|||...|||) and already-transformed HTML
       def protect_comparisons(content)
         comparison_blocks = []
-        
+
         # First protect markdown comparison syntax: |||...|||
         protected = content.gsub(/\|\|\|(\d+)?\n.*?\n\|\|\|/m) do |match|
           placeholder = "<!--IMAGE_DIALOG_COMPARISON_#{comparison_blocks.length}-->"
           comparison_blocks << match
           placeholder
         end
-        
+
         # Also protect already-transformed HTML comparison blocks: <wa-comparison ...>...</wa-comparison>
-        protected = protected.gsub(/<wa-comparison[^>]*>.*?<\/wa-comparison>/m) do |match|
+        protected = protected.gsub(%r{<wa-comparison[^>]*>.*?</wa-comparison>}m) do |match|
           placeholder = "<!--IMAGE_DIALOG_COMPARISON_#{comparison_blocks.length}-->"
           comparison_blocks << match
           placeholder
         end
-        
+
         [protected, comparison_blocks]
       end
 
@@ -117,7 +117,7 @@ module Markawesome
       def transform_to_dialog(alt_text, image_url, title, config = {})
         # Parse width from title if specified (e.g., "50%", "800px", "60vw")
         width = extract_width_from_title(title)
-        
+
         # Use default width from config if no width specified in title
         width ||= config[:default_width] if config[:default_width]
 

data/lib/markawesome/transformers/tabs_transformer.rb

@@ -1,25 +1,57 @@
 # frozen_string_literal: true
 
 require_relative 'base_transformer'
+require_relative '../attribute_parser'
 
 module Markawesome
   # 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
+  # Primary syntax: ++++++[attributes]\n+++tab1\ncontent\n+++\n+++tab2\ncontent\n+++\n++++++
+  # Alternative syntax: :::wa-tab-group [attributes]\n+++tab1\ncontent\n+++\n+++tab2\ncontent\n+++\n:::
+  # Attributes:
+  #   - placement: top (default), bottom, start, end
+  #   - activation: auto (default), manual
+  #   - active: panel name to show initially (e.g., "general", "tab-2")
+  #   - no-scroll-controls: disables scroll arrows
   class TabsTransformer < BaseTransformer
+    COMPONENT_ATTRIBUTES = {
+      placement: %w[top bottom start end],
+      activation: %w[auto manual]
+    }.freeze
     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
+      # Captures optional attributes (placement, activation, active, no-scroll-controls)
+      primary_regex = /^\+{6}([^\n]*)\n((\+\+\+ [^\n]+\n.*?\n\+\+\+\n?)+)\+{6}/m
+      alternative_regex = /^:::wa-tab-group\s*([^\n]*)\n((\+\+\+ [^\n]+\n.*?\n\+\+\+\n?)+):::/m
 
       # Define shared transformation logic
-      transform_proc = proc do |placement, tabs_block, _third_capture|
-        placement ||= 'top'
+      transform_proc = proc do |params_string, tabs_block, _third_capture|
+        # Parse attributes using AttributeParser
+        attributes = AttributeParser.parse(params_string.to_s.strip, COMPONENT_ATTRIBUTES)
+
+        # Extract boolean flags
+        no_scroll_controls = params_string.to_s.include?('no-scroll-controls')
+
+        # Extract active panel name (any token that's not a placement or activation)
+        active_panel = nil
+        params_string.to_s.split.each do |token|
+          next if COMPONENT_ATTRIBUTES[:placement].include?(token)
+          next if COMPONENT_ATTRIBUTES[:activation].include?(token)
+          next if token == 'no-scroll-controls'
+
+          active_panel = token
+          break
+        end
 
         tabs, tab_panels = extract_tabs_and_panels(tabs_block)
 
-        "<wa-tab-group placement=\"#{placement}\">#{tabs.join}#{tab_panels.join}</wa-tab-group>"
+        # Build HTML attributes
+        html_attrs = []
+        html_attrs << "placement=\"#{attributes[:placement] || 'top'}\""
+        html_attrs << "activation=\"#{attributes[:activation]}\"" if attributes[:activation]
+        html_attrs << "active=\"#{active_panel}\"" if active_panel
+        html_attrs << 'without-scroll-controls' if no_scroll_controls
+
+        "<wa-tab-group #{html_attrs.join(' ')}>#{tabs.join}#{tab_panels.join}</wa-tab-group>"
       end
 
       # Apply both patterns

data/lib/markawesome/transformers/tag_transformer.rb

@@ -1,28 +1,67 @@
 # frozen_string_literal: true
 
 require_relative 'base_transformer'
+require_relative '../attribute_parser'
 
 module Markawesome
   # Transforms tag syntax into wa-tag elements
-  # Primary syntax: @@@variant?\ncontent\n@@@
-  # Inline syntax: @@@ variant? content @@@
-  # Alternative syntax: :::wa-tag variant?\ncontent\n:::
-  # Variants: brand, success, neutral, warning, danger
+  # Primary syntax: @@@params?\ncontent\n@@@
+  # Inline syntax: @@@ params? content @@@
+  # Alternative syntax: :::wa-tag params?\ncontent\n:::
+  #
+  # Supported attributes:
+  # - variant: brand, success, neutral, warning, danger
+  # - appearance: accent, filled, outlined, filled-outlined
+  # - size: small, medium, large
+  # - pill: boolean (rounded edges)
+  # - with-remove: boolean (removable tag with remove button)
   class TagTransformer < BaseTransformer
+    # Component attributes configuration for AttributeParser
+    COMPONENT_ATTRIBUTES = {
+      variant: %w[brand success neutral warning danger],
+      appearance: %w[accent filled outlined filled-outlined],
+      size: %w[small medium large],
+      pill: %w[pill],
+      'with-remove': %w[with-remove]
+    }.freeze
+
     def self.transform(content)
       # Define regex patterns
       # Block syntax (multiline with newlines) - supports both LF and CRLF
-      primary_regex = /^@@@(brand|success|neutral|warning|danger)?\r?\n(.*?)\r?\n@@@/m
-      alternative_regex = /^:::wa-tag\s*(brand|success|neutral|warning|danger)?\r?\n(.*?)\r?\n:::/m
+      # Capture optional parameters and content
+      primary_regex = /^@@@([^\r\n]*?)\r?\n(.*?)\r?\n@@@/m
+      alternative_regex = /^:::wa-tag\s*([^\r\n]*?)\r?\n(.*?)\r?\n:::/m
 
       # Inline syntax (same line with spaces)
-      inline_regex = /@@@\s*(brand|success|neutral|warning|danger)?\s+([^@\r\n]+?)\s+@@@/
+      # Match the whole content between @@@ delimiters on a single line
+      # Use horizontal whitespace only (\h = spaces/tabs, not newlines)
+      inline_regex = /@@@\h*([^@\r\n]+?)\h*@@@/
 
       # Define shared transformation logic
-      transform_proc = proc do |variant, tag_content|
+      transform_proc = proc do |params, tag_content|
         tag_content = tag_content.strip
 
-        build_tag_html(tag_content, variant)
+        build_tag_html(tag_content, params)
+      end
+
+      # Inline transformation - split params from content
+      inline_transform_proc = proc do |full_content|
+        full_content = full_content.strip
+        tokens = full_content.split(/\s+/)
+        params_tokens = []
+        content_tokens = []
+
+        # Separate attribute tokens from content tokens
+        tokens.each do |token|
+          matched = COMPONENT_ATTRIBUTES.any? { |_attr, values| values.include?(token) }
+          matched ? params_tokens << token : content_tokens << token
+        end
+
+        # Build params and content strings
+        params = params_tokens.join(' ')
+        tag_content = content_tokens.any? ? content_tokens.join(' ') : full_content
+
+        build_tag_html(tag_content, params)
       end
 
       # Apply all patterns (inline first to avoid conflicts)
@@ -30,8 +69,7 @@ module Markawesome
         {
           regex: inline_regex,
           block: proc do |_match, matchdata|
-            captures = matchdata.captures
-            transform_proc.call(*captures)
+            inline_transform_proc.call(matchdata[1])
           end
         },
         *dual_syntax_patterns(primary_regex, alternative_regex, transform_proc)
@@ -42,14 +80,26 @@ module Markawesome
     class << self
       private
 
-      def build_tag_html(content, variant)
-        variant_attr = variant ? " variant=\"#{variant}\"" : ''
+      def build_tag_html(content, params)
+        # Parse attributes using AttributeParser
+        attributes = AttributeParser.parse(params, COMPONENT_ATTRIBUTES)
+
+        # Build HTML attributes
+        html_attrs = []
+        html_attrs << "variant=\"#{attributes[:variant]}\"" if attributes[:variant]
+        html_attrs << "appearance=\"#{attributes[:appearance]}\"" if attributes[:appearance]
+        html_attrs << "size=\"#{attributes[:size]}\"" if attributes[:size]
+        html_attrs << 'pill' if attributes[:pill]
+        html_attrs << 'with-remove' if attributes[:'with-remove']
+
+        attrs_string = html_attrs.empty? ? '' : " #{html_attrs.join(' ')}"
+
         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>"
+        "<wa-tag#{attrs_string}>#{tag_html}</wa-tag>"
       end
     end
   end

data/lib/markawesome/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Markawesome
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/markawesome.gemspec

@@ -18,6 +18,7 @@ Gem::Specification.new do |spec|
   spec.metadata['homepage_uri'] = spec.homepage
   spec.metadata['source_code_uri'] = "#{spec.homepage}/tree/main"
   spec.metadata['changelog_uri'] = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata['rubygems_mfa_required'] = 'true'
 
   # Specify which files should be added to the gem when it is released.
   spec.files = Dir.chdir(__dir__) do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: markawesome
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Janne Waren
@@ -91,6 +91,7 @@ files:
 - LICENSE.txt
 - README.md
 - lib/markawesome.rb
+- lib/markawesome/attribute_parser.rb
 - lib/markawesome/transformer.rb
 - lib/markawesome/transformers.rb
 - lib/markawesome/transformers/badge_transformer.rb
@@ -116,6 +117,7 @@ metadata:
   homepage_uri: https://github.com/jannewaren/markawesome
   source_code_uri: https://github.com/jannewaren/markawesome/tree/main
   changelog_uri: https://github.com/jannewaren/markawesome/blob/main/CHANGELOG.md
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -130,7 +132,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.3
 specification_version: 4
 summary: Framework-agnostic Markdown to Web Awesome component transformer
 test_files: []