tty-markdown-meinac 0.7.2

data/lib/tty/markdown/decorator.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module TTY
+  class Markdown
+    # Responsible for decorating text with theme element styles
+    #
+    # @api private
+    class Decorator
+      # The newline character
+      #
+      # @return [String]
+      #
+      # @api private
+      NEWLINE = "\n"
+      private_constant :NEWLINE
+
+      # Create a {TTY::Markdown::Decorator} instance
+      #
+      # @example
+      #   decorator = TTY::Markdown::Decorator.new(pastel, theme)
+      #
+      # @param [Pastel] pastel
+      #   the pastel
+      # @param [TTY::Markdown::Theme] theme
+      #   the theme
+      #
+      # @api public
+      def initialize(pastel, theme)
+        @pastel = pastel
+        @theme = theme
+      end
+
+      # Detect whether text decoration is enabled
+      #
+      # @example
+      #   decorator.enabled?
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def enabled?
+        @pastel.enabled?
+      end
+
+      # Decorate text with theme element styles
+      #
+      # @example
+      #   decorator.decorate("TTY Toolkit", :strong)
+      #
+      # @param [String] text
+      #   the text
+      # @param [Symbol] name
+      #   the theme element name
+      #
+      # @return [String]
+      #
+      # @api public
+      def decorate(text, name)
+        @pastel.decorate(text, *@theme[name])
+      end
+
+      # Decorate each text line with theme element styles
+      #
+      # @example
+      #   decorator.decorate_each_line("TTY\nToolkit", :strong)
+      #
+      # @param [String] text
+      #   the text
+      # @param [Symbol] name
+      #   the theme element name
+      #
+      # @return [String]
+      #
+      # @api public
+      def decorate_each_line(text, name)
+        text.lines.map do |line|
+          decorate(line.chomp, name)
+        end.join(NEWLINE)
+      end
+    end # Decorator
+  end # Markdown
+end # TTY

data/lib/tty/markdown/error.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module TTY
+  class Markdown
+    # Responsible for indicating a generic error
+    #
+    # @api public
+    class Error < StandardError
+    end # Error
+  end # Markdown
+end # TTY

data/lib/tty/markdown/formatter.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module TTY
+  class Markdown
+    # Responsible for formatting code snippets with standard terminal colors
+    #
+    # @api private
+    class Formatter
+      # Create a {TTY::Markdown::Formatter} instance
+      #
+      # @example
+      #   formatter = TTY::Markdown::Formatter.new(decorator)
+      #
+      # @param [TTY::Markdown::Decorator] decorator
+      #   the decorator
+      #
+      # @api public
+      def initialize(decorator)
+        @decorator = decorator
+      end
+
+      # Format the Rouge lexer tokens
+      #
+      # @example
+      #   formatter.format(tokens)
+      #
+      # @param [Enumerator] tokens
+      #   the Rouge lexer tokens
+      #
+      # @return [String]
+      #
+      # @api public
+      def format(tokens)
+        code = tokens.map { |_token, value| value }.join
+        @decorator.decorate_each_line(code, :code)
+      end
+    end # Formatter
+  end # Markdown
+end # TTY

data/lib/tty/markdown/highlighter.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require "rouge"
+
+require_relative "formatter"
+
+module TTY
+  class Markdown
+    # Responsible for highlighting terminal code snippets
+    #
+    # @api private
+    class Highlighter
+      # Create a {TTY::Markdown::Highlighter} instance
+      #
+      # @example
+      #   highlighter = TTY::Markdown::Highlighter.new(decorator)
+      #
+      # @param [TTY::Markdown::Decorator] decorator
+      #   the decorator
+      # @param [Integer] mode
+      #   the color mode
+      #
+      # @api public
+      def initialize(decorator, mode: 256)
+        @decorator = decorator
+        @mode = mode
+      end
+
+      # Highlight the code snippet
+      #
+      # @example
+      #   highlighter.highlight("puts 'TTY Toolkit'", "ruby")
+      #
+      # @param [String] code
+      #   the code snippet
+      # @param [String, nil] language
+      #   the code language
+      #
+      # @return [String]
+      #
+      # @api public
+      def highlight(code, language = nil)
+        return code unless @decorator.enabled?
+
+        lexer = select_lexer(code, language)
+        formatter.format(lexer.lex(code))
+      end
+
+      private
+
+      # Select a lexer
+      #
+      # @param [String] code
+      #   the code snippet
+      # @param [String, nil] language
+      #   the code language
+      #
+      # @return [Rouge::Lexer]
+      #
+      # @api private
+      def select_lexer(code, language)
+        Rouge::Lexer.find_fancy(language, code) || Rouge::Lexers::PlainText
+      end
+
+      # Select a formatter
+      #
+      # @return [Rouge::Formatter, TTY::Markdown::Formatter]
+      #
+      # @api private
+      def formatter
+        @formatter ||=
+          if @mode < 256
+            Formatter.new(@decorator)
+          elsif @mode == 256
+            Rouge::Formatters::Terminal256.new
+          else
+            Rouge::Formatters::TerminalTruecolor.new
+          end
+      end
+    end # Highlighter
+  end # Markdown
+end # TTY

data/lib/tty/markdown/parser.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require "kramdown/parser/kramdown"
+
+module TTY
+  class Markdown
+    # Responsible for parsing standard and extended Markdown syntax
+    #
+    # @api private
+    class Parser < Kramdown::Parser::Kramdown
+      # The fenced code block pattern
+      #
+      # @return [Regexp]
+      #
+      # @api private
+      FENCED_CODEBLOCK_MATCH = /
+        ^ {0,3}(([~`]){3,})\s*?((\S+?)(?:\?\S*)?)?\s*?\n
+        (.*?)
+        ^ {0,3}\1\2*\s*?\n
+      /mx.freeze
+
+      # The fenced code block start pattern
+      #
+      # @return [Regexp]
+      #
+      # @api private
+      FENCED_CODEBLOCK_START = /^ {0,3}[~`]{3,}/.freeze
+      private_constant :FENCED_CODEBLOCK_START
+
+      define_parser(:codeblock_fenced_extension, FENCED_CODEBLOCK_START, nil,
+                    :parse_codeblock_fenced)
+
+      # Create a {TTY::Markdown::Parser} instance
+      #
+      # @example
+      #   parser = TTY::Markdown::Parser.new("# TTY Toolkit", {})
+      #
+      # @param [String] source
+      #   the Markdown source
+      # @param [Hash] options
+      #   the parsing options
+      #
+      # @api private
+      def initialize(source, options)
+        super
+        replace_fenced_codeblock_parser
+      end
+
+      private
+
+      # Replace the fenced code block parser
+      #
+      # @return [void]
+      #
+      # @api private
+      def replace_fenced_codeblock_parser
+        @block_parsers[
+          @block_parsers.index(:codeblock_fenced)
+        ] = :codeblock_fenced_extension
+      end
+    end # Parser
+  end # Markdown
+end # TTY
+
+# Add the TTY::Markdown::Parser to the available Kramdown parsers
+Kramdown::Parser.const_set(:TTYMarkdown, TTY::Markdown::Parser)

data/lib/tty/markdown/symbols.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+require_relative "error"
+
+module TTY
+  class Markdown
+    # Responsible for storing the symbols configuration
+    #
+    # @api private
+    class Symbols
+      # The ASCII name
+      #
+      # @return [String]
+      #
+      # @api private
+      ASCII = "ascii"
+      private_constant :ASCII
+
+      # The name to the ASCII symbol hash
+      #
+      # @return [Hash{Symbol => String}]
+      #
+      # @api private
+      NAME_TO_ASCII = {
+        arrow: "->",
+        bar: "|",
+        bottom_center: "+",
+        bottom_right: "+",
+        bottom_left: "+",
+        bracket_left: "[",
+        bracket_right: "]",
+        bullet: "*",
+        diamond: "*",
+        hash: "#",
+        hellip: "...",
+        laquo: "<<",
+        laquo_space: "<< ",
+        ldquo: "\"",
+        line: "-",
+        lsquo: "\"",
+        mdash: "--",
+        mid_center: "+",
+        mid_left: "+",
+        mid_right: "+",
+        ndash: "-",
+        paren_left: "(",
+        paren_right: ")",
+        pipe: "|",
+        raquo: ">>",
+        raquo_space: " >>",
+        rdquo: "\"",
+        rsquo: "\"",
+        top_center: "+",
+        top_left: "+",
+        top_right: "+"
+      }.freeze
+      private_constant :NAME_TO_ASCII
+
+      # The name to the Unicode symbol hash
+      #
+      # @return [Hash{Symbol => String}]
+      #
+      # @api private
+      NAME_TO_UNICODE = {
+        arrow: "»",
+        bar: "┃",
+        bottom_center: "┴",
+        bottom_right: "┘",
+        bottom_left: "└",
+        bracket_left: "[",
+        bracket_right: "]",
+        bullet: "●",
+        diamond: "◈",
+        hash: "#",
+        hellip: "…",
+        laquo: "«",
+        laquo_space: "« ",
+        ldquo: "“",
+        line: "─",
+        lsquo: "‘",
+        mdash: "\u2014",
+        mid_center: "┼",
+        mid_left: "├",
+        mid_right: "┤",
+        ndash: "-",
+        paren_left: "(",
+        paren_right: ")",
+        pipe: "│",
+        raquo: "»",
+        raquo_space: " »",
+        rdquo: "”",
+        rsquo: "’",
+        top_center: "┬",
+        top_left: "┌",
+        top_right: "┐"
+      }.freeze
+      private_constant :NAME_TO_UNICODE
+
+      # The Unicode name
+      #
+      # @return [String]
+      #
+      # @api private
+      UNICODE = "unicode"
+      private_constant :UNICODE
+
+      # Create a {TTY::Markdown::Symbols} instance
+      #
+      # @example
+      #   symbols = TTY::Markdown::Symbols.from(:ascii)
+      #
+      # @example
+      #   symbols = TTY::Markdown::Symbols.from({
+      #     base: :ascii,
+      #     override: {
+      #       arrow: "=>"
+      #     }
+      #   })
+      #
+      # @param [Hash, String, Symbol] symbols
+      #   the symbols configuration
+      #
+      # @return [TTY::Markdown::Symbols]
+      #
+      # @raise [TTY::Markdown::Error]
+      #   when the symbols value is invalid
+      #
+      # @api public
+      def self.from(symbols)
+        new(validate_names(build_symbols(symbols)))
+      end
+
+      # Build the symbols hash
+      #
+      # @param [Hash, String, Symbol] symbols
+      #   the symbols configuration
+      #
+      # @return [Hash{Symbol => String}]
+      #
+      # @raise [TTY::Markdown::Error]
+      #   when the symbols value is invalid
+      #
+      # @api private
+      def self.build_symbols(symbols)
+        case symbols
+        when String, Symbol
+          select_symbols(symbols)
+        when Hash
+          base_symbols = select_symbols(symbols.fetch(:base, UNICODE))
+          base_symbols.merge(symbols[:override].to_h)
+        else
+          raise_value_error(symbols)
+        end
+      end
+      private_class_method :build_symbols
+
+      # Validate the symbols names
+      #
+      # @param [Hash{Symbol => String}] value
+      #   the symbols value
+      #
+      # @return [Hash{Symbol => String}]
+      #
+      # @raise [TTY::Markdown::Error]
+      #   when the symbol name is invalid
+      #
+      # @api private
+      def self.validate_names(value)
+        unknown_names = value.keys - NAME_TO_ASCII.keys
+        return value if unknown_names.empty?
+
+        raise_name_error(*unknown_names)
+      end
+      private_class_method :validate_names
+
+      # Select either ASCII or Unicode symbols
+      #
+      # @param [String, Symbol] name
+      #   the symbols name
+      #
+      # @return [Hash{Symbol => String}]
+      #
+      # @raise [TTY::Markdown::Error]
+      #   when the symbols name is invalid
+      #
+      # @api private
+      def self.select_symbols(name)
+        case name.to_s
+        when ASCII   then NAME_TO_ASCII
+        when UNICODE then NAME_TO_UNICODE
+        else raise_symbols_name_error(name)
+        end
+      end
+      private_class_method :select_symbols
+
+      # Raise the symbols value error
+      #
+      # @param [Object] value
+      #   the symbols value
+      #
+      # @return [void]
+      #
+      # @raise [TTY::Markdown::Error]
+      #   when the symbols value is invalid
+      #
+      # @api private
+      def self.raise_value_error(value)
+        raise Error, "invalid symbols: #{value.inspect}. " \
+                     "Use a hash with base and override keys or a symbol."
+      end
+      private_class_method :raise_value_error
+
+      # Raise the symbol name error
+      #
+      # @param [Array<Symbol>] names
+      #   the symbols names
+      #
+      # @return [void]
+      #
+      # @raise [TTY::Markdown::Error]
+      #   when the symbol name is invalid
+      #
+      # @api private
+      def self.raise_name_error(*names)
+        raise Error, "invalid symbol name#{"s" if names.size > 1}: " \
+                     "#{names.map(&:inspect).join(", ")}."
+      end
+      private_class_method :raise_name_error
+
+      # Raise the symbols name error
+      #
+      # @param [String, Symbol] name
+      #   the symbols name
+      #
+      # @return [void]
+      #
+      # @raise [TTY::Markdown::Error]
+      #   when the symbols name is invalid
+      #
+      # @api private
+      def self.raise_symbols_name_error(name)
+        raise Error, "invalid symbols name: #{name.inspect}. " \
+                     "Use the :#{ASCII} or :#{UNICODE} name."
+      end
+      private_class_method :raise_symbols_name_error
+
+      # Create a {TTY::Markdown::Symbols} instance
+      #
+      # @param [Hash{Symbol => String}] symbols
+      #   the symbols configuration
+      #
+      # @api private
+      def initialize(symbols)
+        @symbols = symbols
+      end
+      private_class_method :new
+
+      # Retrieve a symbol by name
+      #
+      # @example
+      #   symbols[:arrow]
+      #
+      # @param [Symbol] name
+      #   the symbol name
+      #
+      # @return [String, nil]
+      #
+      # @api public
+      def [](name)
+        @symbols[name.to_sym]
+      end
+
+      # Wrap the content in brackets
+      #
+      # @example
+      #   symbols.wrap_in_brackets("TTY Toolkit")
+      #
+      # @param [String] content
+      #   the content
+      #
+      # @return [String]
+      #
+      # @api public
+      def wrap_in_brackets(content)
+        "#{self[:bracket_left]}#{content}#{self[:bracket_right]}"
+      end
+
+      # Wrap the content in parentheses
+      #
+      # @example
+      #   symbols.wrap_in_parentheses("TTY Toolkit")
+      #
+      # @param [String] content
+      #   the content
+      #
+      # @return [String]
+      #
+      # @api public
+      def wrap_in_parentheses(content)
+        "#{self[:paren_left]}#{content}#{self[:paren_right]}"
+      end
+    end # Symbols
+  end # Markdown
+end # TTY