docyard 0.8.0 → 1.0.0

data/lib/docyard/components/processors/video_embed_processor.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require_relative "../base_processor"
+require_relative "../support/markdown_code_block_helper"
+
+module Docyard
+  module Components
+    module Processors
+      class VideoEmbedProcessor < BaseProcessor
+        include Support::MarkdownCodeBlockHelper
+
+        YOUTUBE_PATTERN = /::youtube\[([^\]]+)\](?:\{([^}]*)\})?/
+        VIMEO_PATTERN = /::vimeo\[([^\]]+)\](?:\{([^}]*)\})?/
+        VIDEO_PATTERN = /::video\[([^\]]+)\](?:\{([^}]*)\})?/
+
+        self.priority = 5
+
+        def preprocess(content)
+          process_outside_code_blocks(content) do |segment|
+            process_video_embeds(segment)
+          end
+        end
+
+        private
+
+        def process_video_embeds(content)
+          result = content.gsub(YOUTUBE_PATTERN) do
+            video_id = Regexp.last_match(1)
+            attrs_string = Regexp.last_match(2)
+            build_youtube_embed(video_id, parse_attributes(attrs_string))
+          end
+
+          result = result.gsub(VIMEO_PATTERN) do
+            video_id = Regexp.last_match(1)
+            attrs_string = Regexp.last_match(2)
+            build_vimeo_embed(video_id, parse_attributes(attrs_string))
+          end
+
+          result.gsub(VIDEO_PATTERN) do
+            src = Regexp.last_match(1)
+            attrs_string = Regexp.last_match(2)
+            build_native_video(src, parse_attributes(attrs_string))
+          end
+        end
+
+        def parse_attributes(attrs_string)
+          return {} if attrs_string.nil? || attrs_string.empty?
+
+          attrs = {}
+
+          attrs_string.scan(/(\w+)="([^"]*)"/) do |key, value|
+            attrs[key] = value
+          end
+
+          %w[autoplay loop muted nofullscreen controls playsinline].each do |flag|
+            attrs[flag] = true if attrs_string.match?(/\b#{flag}\b/) && !attrs.key?(flag)
+          end
+
+          attrs
+        end
+
+        def build_youtube_embed(video_id, attrs)
+          params = youtube_params(attrs)
+          url = "https://www.youtube-nocookie.com/embed/#{escape_attr(video_id)}"
+          url += "?#{params.join('&')}" unless params.empty?
+
+          build_iframe(url, attrs, "youtube")
+        end
+
+        def build_vimeo_embed(video_id, attrs)
+          params = vimeo_params(attrs)
+          url = "https://player.vimeo.com/video/#{escape_attr(video_id)}"
+          url += "?#{params.join('&')}" unless params.empty?
+
+          build_iframe(url, attrs, "vimeo")
+        end
+
+        def build_native_video(src, attrs)
+          wrapper_style = build_wrapper_style(attrs)
+          video_attrs = build_video_attrs(src, attrs)
+
+          "\n\n" \
+            "<div class=\"docyard-video docyard-video--native\"#{wrapper_style} markdown=\"0\">\n  " \
+            "<video #{video_attrs.join(' ')}></video>\n" \
+            "</div>" \
+            "\n\n"
+        end
+
+        def build_video_attrs(src, attrs)
+          video_attrs = ["src=\"#{escape_attr(src)}\""]
+          video_attrs.concat(video_optional_attrs(attrs))
+          video_attrs.concat(video_boolean_attrs(attrs))
+          video_attrs
+        end
+
+        def video_optional_attrs(attrs)
+          result = []
+          result << "poster=\"#{escape_attr(attrs['poster'])}\"" if attrs["poster"]
+          result << "preload=\"#{escape_attr(attrs['preload'])}\"" if attrs["preload"]
+          result
+        end
+
+        def video_boolean_attrs(attrs)
+          result = []
+          result << "controls" unless controls_disabled?(attrs)
+          result << "autoplay" if attrs["autoplay"]
+          result << "muted" if attrs["muted"]
+          result << "loop" if attrs["loop"]
+          result << "playsinline" if attrs["playsinline"]
+          result
+        end
+
+        def controls_disabled?(attrs)
+          ["false", false].include?(attrs["controls"])
+        end
+
+        def youtube_params(attrs)
+          params = []
+          params << "autoplay=1" if attrs["autoplay"]
+          params << "loop=1" if attrs["loop"]
+          params << "mute=1" if attrs["muted"]
+          params << "controls=0" if ["false", false].include?(attrs["controls"])
+          params << "start=#{attrs['start']}" if attrs["start"]
+          params << "rel=0"
+          params
+        end
+
+        def vimeo_params(attrs)
+          params = []
+          params << "autoplay=1" if attrs["autoplay"]
+          params << "loop=1" if attrs["loop"]
+          params << "muted=1" if attrs["muted"]
+          params << "controls=0" if ["false", false].include?(attrs["controls"])
+          params << "dnt=1"
+          params
+        end
+
+        def build_iframe(url, attrs, provider)
+          wrapper_style = build_wrapper_style(attrs)
+          iframe_attrs = build_iframe_attrs(url, attrs, provider)
+
+          "\n\n" \
+            "<div class=\"docyard-video docyard-video--#{provider}\"#{wrapper_style} markdown=\"0\">\n  " \
+            "<iframe #{iframe_attrs.join(' ')}></iframe>\n" \
+            "</div>" \
+            "\n\n"
+        end
+
+        def build_wrapper_style(attrs)
+          width = validate_dimension(attrs["width"])
+          height = validate_dimension(attrs["height"])
+          return "" unless width || height
+
+          styles = []
+          styles << "max-width: #{width}px" if width
+          styles << "height: #{height}px" if height
+          " style=\"#{styles.join('; ')}\""
+        end
+
+        def validate_dimension(value)
+          return nil if value.nil? || value.to_s.empty?
+
+          int_value = value.to_s.to_i
+          return nil unless int_value.positive? && int_value <= 10_000
+
+          int_value
+        end
+
+        def build_iframe_attrs(url, attrs, provider)
+          iframe_attrs = [
+            "src=\"#{url}\"",
+            "title=\"#{escape_attr(attrs['title'] || default_title(provider))}\"",
+            "frameborder=\"0\""
+          ]
+
+          iframe_attrs << "allow=\"#{build_allow_attr(attrs)}\""
+          iframe_attrs << "allowfullscreen" unless attrs["nofullscreen"]
+
+          iframe_attrs
+        end
+
+        def build_allow_attr(attrs)
+          permissions = %w[encrypted-media picture-in-picture web-share]
+          permissions.unshift("autoplay") if attrs["autoplay"]
+          permissions << "fullscreen" unless attrs["nofullscreen"]
+          permissions.join("; ")
+        end
+
+        def default_title(provider)
+          case provider
+          when "youtube" then "YouTube video player"
+          when "vimeo" then "Vimeo video player"
+          else "Video player"
+          end
+        end
+
+        def escape_attr(text)
+          text.to_s
+            .gsub("&", "&amp;")
+            .gsub("<", "&lt;")
+            .gsub(">", "&gt;")
+            .gsub('"', "&quot;")
+        end
+      end
+    end
+  end
+end

data/lib/docyard/components/support/code_block/feature_extractor.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "patterns"
+require_relative "../../../rendering/icons"
 
 module Docyard
   module Components
@@ -18,7 +19,8 @@ module Docyard
             cleaned = markdown.gsub(CODE_FENCE_REGEX) do
               block_data = extract_block_data(Regexp.last_match)
               blocks << block_data
-              "```#{block_data[:lang]}\n#{block_data[:cleaned_content]}```"
+              highlight_lang = Icons.highlight_language(block_data[:lang])
+              "```#{highlight_lang}\n#{block_data[:cleaned_content]}```"
             end
             { cleaned_markdown: cleaned, blocks: blocks }
           end

data/lib/docyard/components/support/code_block/icon_detector.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../../../rendering/language_mapping"
+require_relative "../../../rendering/icons"
 
 module Docyard
   module Components
@@ -22,20 +22,13 @@ module Docyard
               }
             end
 
-            icon, icon_source = auto_detect_icon(language)
-            { title: title, icon: icon, icon_source: icon_source }
+            { title: title, icon: language, icon_source: "language" }
           end
 
-          def auto_detect_icon(language)
-            return [nil, nil] if language.nil?
+          def render_icon(language)
+            return "" if language.nil? || language.to_s.empty?
 
-            if LanguageMapping.terminal_language?(language)
-              %w[terminal-window phosphor]
-            elsif (ext = LanguageMapping.extension_for(language))
-              [ext, "file-extension"]
-            else
-              %w[file phosphor]
-            end
+            Icons.render_for_language(language)
           end
         end
       end

data/lib/docyard/components/support/code_block/line_number_resolver.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Docyard
+  module Components
+    module Support
+      module CodeBlock
+        module LineNumberResolver
+          module_function
+
+          def enabled?(option)
+            return false if option == ":no-line-numbers"
+
+            option&.start_with?(":line-numbers") || false
+          end
+
+          def start_line(option)
+            return 1 unless option&.include?("=")
+
+            option.split("=").last.to_i
+          end
+
+          def generate_numbers(code_text, start = 1)
+            line_count = [code_text.lines.count, 1].max
+            (start...(start + line_count)).to_a
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docyard/components/support/code_detector.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative "../../rendering/language_mapping"
+require_relative "../../rendering/icons"
 
 module Docyard
   module Components
@@ -20,7 +20,7 @@ module Docyard
           language = extract_language
           return nil unless language
 
-          icon_for_language(language)
+          { language: language }
         end
 
         private
@@ -45,16 +45,6 @@ module Docyard
 
           lang_line.downcase
         end
-
-        def icon_for_language(language)
-          if LanguageMapping.terminal_language?(language)
-            { icon: "terminal-window", source: "phosphor" }
-          elsif (extension = LanguageMapping.extension_for(language))
-            { icon: extension, source: "file-extension" }
-          else
-            { icon: "file", source: "phosphor" }
-          end
-        end
       end
     end
   end

data/lib/docyard/components/support/code_group/html_builder.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+require_relative "../../../rendering/icons"
+
+module Docyard
+  module Components
+    module Support
+      module CodeGroup
+        class HtmlBuilder
+          def initialize(blocks, group_id)
+            @blocks = blocks
+            @group_id = group_id
+          end
+
+          def build
+            <<~HTML
+              <div class="docyard-code-group" data-code-group="#{@group_id}">
+                <div class="docyard-code-group__tabs-wrapper">
+                  <div class="docyard-code-group__tabs-scroll-container">
+                    <div role="tablist" aria-label="Code examples" class="docyard-code-group__tabs">
+                      #{build_tabs}
+                      <div class="docyard-code-group__indicator" aria-hidden="true"></div>
+                    </div>
+                  </div>
+                  #{build_copy_button}
+                </div>
+                <div class="docyard-code-group__panels">
+                  #{build_panels}
+                </div>
+              </div>
+            HTML
+          end
+
+          private
+
+          def build_tabs
+            @blocks.each_with_index.map do |block, index|
+              build_tab(block, index)
+            end.join("\n")
+          end
+
+          def build_tab(block, index)
+            selected = index.zero? ? "true" : "false"
+            tabindex = index.zero? ? "0" : "-1"
+            icon_html = render_icon(block[:lang])
+            <<~HTML.strip
+              <button
+                role="tab"
+                aria-selected="#{selected}"
+                aria-controls="cg-panel-#{@group_id}-#{index}"
+                id="cg-tab-#{@group_id}-#{index}"
+                class="docyard-code-group__tab"
+                tabindex="#{tabindex}"
+                data-label="#{escape_html(block[:label])}"
+              >#{icon_html}<span class="docyard-code-group__tab-label">#{escape_html(block[:label])}</span></button>
+            HTML
+          end
+
+          def render_icon(lang)
+            return "" if lang.nil? || lang.empty?
+
+            Icons.render_for_language(lang)
+          end
+
+          def build_copy_button
+            copy_icon = Icons.render("copy", "regular") || ""
+            <<~HTML.strip
+              <button class="docyard-code-group__copy" aria-label="Copy code to clipboard">
+                <span class="docyard-code-group__copy-icon">#{copy_icon}</span>
+                <span class="docyard-code-group__copy-text">Copy</span>
+              </button>
+            HTML
+          end
+
+          def build_panels
+            @blocks.each_with_index.map do |block, index|
+              build_panel(block, index)
+            end.join("\n")
+          end
+
+          def build_panel(block, index)
+            hidden = index.zero? ? "false" : "true"
+            code_text = escape_html_attribute(block[:code_text] || "")
+            <<~HTML.strip
+              <div
+                role="tabpanel"
+                id="cg-panel-#{@group_id}-#{index}"
+                aria-labelledby="cg-tab-#{@group_id}-#{index}"
+                aria-hidden="#{hidden}"
+                class="docyard-code-group__panel"
+                tabindex="0"
+                data-code="#{code_text}"
+              >#{block[:content]}</div>
+            HTML
+          end
+
+          def escape_html(text)
+            text.to_s
+              .gsub("&", "&amp;")
+              .gsub("<", "&lt;")
+              .gsub(">", "&gt;")
+              .gsub('"', "&quot;")
+          end
+
+          def escape_html_attribute(text)
+            text.to_s
+              .gsub("&", "&amp;")
+              .gsub("<", "&lt;")
+              .gsub(">", "&gt;")
+              .gsub('"', "&quot;")
+              .gsub("'", "&#39;")
+              .gsub("\n", "&#10;")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/docyard/components/support/markdown_code_block_helper.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Docyard
+  module Components
+    module Support
+      module MarkdownCodeBlockHelper
+        FENCED_CODE_BLOCK_REGEX = /^(`{3,}|~{3,})[^\n]*\n.*?^\1\s*$/m
+
+        def process_outside_code_blocks(content)
+          segments = split_by_code_blocks(content)
+
+          segments.map do |segment|
+            segment[:type] == :code ? segment[:content] : yield(segment[:content])
+          end.join
+        end
+
+        def find_code_block_ranges(content, exclude_language: nil)
+          ranges = []
+          content.scan(FENCED_CODE_BLOCK_REGEX) do
+            match = Regexp.last_match
+            next if exclude_language && match[0] =~ /\A[`~]{3,}#{exclude_language}\b/
+
+            ranges << (match.begin(0)...match.end(0))
+          end
+          ranges
+        end
+
+        def inside_code_block?(position, ranges)
+          ranges.any? { |range| range.cover?(position) }
+        end
+
+        private
+
+        def split_by_code_blocks(content)
+          segments = []
+          current_pos = 0
+
+          content.scan(FENCED_CODE_BLOCK_REGEX) do
+            match = Regexp.last_match
+            match_start = match.begin(0)
+            match_end = match.end(0)
+
+            segments << { type: :text, content: content[current_pos...match_start] } if match_start > current_pos
+
+            segments << { type: :code, content: content[match_start...match_end] }
+            current_pos = match_end
+          end
+
+          segments << { type: :text, content: content[current_pos..] } if current_pos < content.length
+
+          segments.empty? ? [{ type: :text, content: content }] : segments
+        end
+      end
+    end
+  end
+end

data/lib/docyard/components/support/tabs/icon_detector.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "../code_detector"
+require_relative "../../../rendering/icons"
 
 module Docyard
   module Components
@@ -41,10 +42,13 @@ module Docyard
             detected = CodeDetector.detect(tab_content)
             return nil unless detected
 
+            language = detected[:language]
+            return nil unless Icons.devicon?(language)
+
             {
               name: tab_name,
-              icon: detected[:icon],
-              icon_source: detected[:source]
+              icon: language,
+              icon_source: "language"
             }
           end
 

data/lib/docyard/components/support/tabs/parser.rb

@@ -3,6 +3,7 @@
 require_relative "../code_block/feature_extractor"
 require_relative "../code_block/icon_detector"
 require_relative "../code_block/line_wrapper"
+require_relative "../code_block/line_number_resolver"
 require_relative "icon_detector"
 require_relative "../../../rendering/icons"
 require_relative "../../../rendering/renderer"
@@ -21,6 +22,7 @@ module Docyard
           CodeBlockFeatureExtractor = CodeBlock::FeatureExtractor
           CodeBlockIconDetector = CodeBlock::IconDetector
           CodeBlockLineWrapper = CodeBlock::LineWrapper
+          LineNumbers = CodeBlock::LineNumberResolver
 
           def self.parse(content)
             new(content).parse
@@ -120,15 +122,15 @@ module Docyard
               focus_lines: block_data[:focus_lines] || {},
               error_lines: block_data[:error_lines] || {},
               warning_lines: block_data[:warning_lines] || {},
-              start_line: extract_start_line(block_data[:option])
+              start_line: LineNumbers.start_line(block_data[:option])
             }
             CodeBlockLineWrapper.wrap_code_block(html, wrapper_data)
           end
 
           def build_full_locals(processed_html, code_text, block_data)
             title_data = CodeBlockIconDetector.detect(block_data[:title], block_data[:lang])
-            show_line_numbers = line_numbers_enabled?(block_data[:option])
-            start_line = extract_start_line(block_data[:option])
+            show_line_numbers = LineNumbers.enabled?(block_data[:option])
+            start_line = LineNumbers.start_line(block_data[:option])
 
             base_locals(processed_html, code_text, show_line_numbers, start_line)
               .merge(feature_locals(block_data))
@@ -141,7 +143,7 @@ module Docyard
               code_text: escape_html_attribute(code_text),
               copy_icon: Icons.render("copy", "regular") || "",
               show_line_numbers: show_line_numbers,
-              line_numbers: show_line_numbers ? generate_line_numbers(code_text, start_line) : [],
+              line_numbers: show_line_numbers ? LineNumbers.generate_numbers(code_text, start_line) : [],
               start_line: start_line
             }
           end
@@ -164,25 +166,6 @@ module Docyard
             }
           end
 
-          def line_numbers_enabled?(block_option)
-            return false if block_option == ":no-line-numbers"
-            return true if block_option&.start_with?(":line-numbers")
-
-            false
-          end
-
-          def extract_start_line(block_option)
-            return 1 unless block_option&.include?("=")
-
-            block_option.split("=").last.to_i
-          end
-
-          def generate_line_numbers(code_text, start_line)
-            line_count = code_text.lines.count
-            line_count = 1 if line_count.zero?
-            (start_line...(start_line + line_count)).to_a
-          end
-
           def extract_code_text(html)
             text = html.gsub(/<[^>]+>/, "")
             text = CGI.unescapeHTML(text)

data/lib/docyard/config/analytics_resolver.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Docyard
+  module AnalyticsResolver
+    def analytics_options
+      analytics = config.analytics
+      {
+        analytics_google: analytics.google,
+        analytics_plausible: analytics.plausible,
+        analytics_fathom: analytics.fathom,
+        analytics_script: analytics.script,
+        has_analytics: any_analytics_configured?(analytics)
+      }
+    end
+
+    private
+
+    def any_analytics_configured?(analytics)
+      [analytics.google, analytics.plausible, analytics.fathom, analytics.script].any? do |value|
+        value.is_a?(String) && !value.strip.empty?
+      end
+    end
+  end
+end