mustermann 1.0.1 → 1.0.2.rc1

data/mustermann-contrib/lib/mustermann/visualizer/highlighter/composite.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+module Mustermann
+  module Visualizer
+    # @!visibility private
+    module Highlighter
+      # @!visibility private
+      module Composite
+        extend self
+
+        # @!visibility private
+        def highlight?(pattern)
+          pattern.is_a? Mustermann::Composite
+        end
+
+        # @!visibility private
+        def highlight(pattern, renderer)
+          operator = " #{pattern.operator} "
+          patterns = pattern.patterns.map { |p| highlight_nested(p, renderer) }.join(quote(renderer, operator))
+          renderer.pre(:composite) + patterns + renderer.post(:composite)
+        end
+
+        # @!visibility private
+        def highlight_nested(pattern, renderer)
+          highlighter = Highlighter.highlighter_for(pattern)
+          if highlighter.respond_to? :nested_highlight
+            highlighter.nested_highlight(pattern, renderer)
+          else
+            type  = quote(renderer, pattern.class.name[/[^:]+$/].downcase + ":", :type)
+            quote = quote(renderer, ?")
+            type + quote + highlighter.highlight(pattern, renderer) + quote
+          end
+        end
+
+        # @!visibility private
+        def nested_highlight(pattern, renderer)
+          quote(renderer, ?() + highlight(pattern, renderer) + quote(renderer, ?))
+        end
+
+        # @!visibility private
+        def quote(renderer, string, type = :quote)
+          renderer.pre(type) + renderer.escape(string, string) + renderer.post(type)
+        end
+      end
+    end
+  end
+end

data/mustermann-contrib/lib/mustermann/visualizer/highlighter/dummy.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Mustermann
+  module Visualizer
+    # @!visibility private
+    module Highlighter
+      # Provides highlighting for patterns that don't have a highlighter.
+      # @!visibility private
+      module Dummy
+        # @!visibility private
+        def self.highlight(pattern, renderer)
+          output = String.new
+          output << renderer.pre(:root) << renderer.pre(:unknown)
+          output << renderer.escape(pattern.to_s)
+          output << renderer.post(:unknown) << renderer.post(:root)
+        end
+      end
+    end
+  end
+end

data/mustermann-contrib/lib/mustermann/visualizer/highlighter/regular.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+require 'strscan'
+
+module Mustermann
+  module Visualizer
+    # @!visibility private
+    module Highlighter
+      # Provides highlighting for {Mustermann::Regular}
+      # @!visibility private
+      class Regular
+        # @!visibility private
+        SPECIAL_ESCAPE = ['w', 'W', 'd', 'D', 'h', 'H', 's', 'S', 'G', 'b', 'B']
+        private_constant(:SPECIAL_ESCAPE)
+
+        # @!visibility private
+        def self.highlight?(pattern)
+          pattern.class.name == "Mustermann::Regular"
+        end
+
+        # @!visibility private
+        def self.highlight(pattern, renderer)
+          new(renderer).highlight(pattern)
+        end
+
+        # @!visibility private
+        attr_reader :renderer, :output, :scanner
+
+        # @!visibility private
+        def initialize(renderer)
+          @renderer = renderer
+          @output   = String.new
+        end
+
+        # @!visibility private
+        def highlight(pattern)
+          output << renderer.pre(:root)
+          @scanner = ::StringScanner.new(pattern.to_s)
+          scan
+          output << renderer.post(:root)
+        end
+
+        # @!visibility private
+        def scan(stop = nil)
+          until scanner.eos?
+            case char = scanner.getch
+            when stop                then return char
+            when ?/                  then element(:separator, char)
+            when Regexp.escape(char) then element(:char, char)
+            when ?\\                 then escaped(scanner.getch)
+            when ?(                  then potential_capture
+            when ?[                  then char_class
+            when ?^, ?$              then element(:illegal, char)
+            when ?{                  then element(:special, "\{#{scanner.scan(/[^\}]*\}/)}")
+            else element(:special, char)
+            end
+          end
+        end
+
+        # @!visibility private
+        def char_class
+          if result = scanner.scan(/\[:\w+:\]\]/)
+            element(:special, "[#{result}")
+          else
+            element(:special, ?[)
+            element(:special, ?^) if scanner.scan(/\^/)
+          end
+        end
+
+        # @!visibility private
+        def potential_capture
+          if scanner.scan(/\?<(\w+)>/)
+            element(:capture, "(?<") do
+              element(:name, scanner[1])
+              output << ">" << scan(?))
+            end
+          elsif scanner.scan(/\?(?:(?:-\w+)?:|>|<=|<!|!|=)/)
+            element(:special, "(#{scanner[0]}")
+          else
+            element(:capture, "(") { output << scan(?)) }
+          end
+        end
+
+        # @!visibility private
+        def escaped(char)
+          case char
+          when  *SPECIAL_ESCAPE    then element(:special, "\\#{char}")
+          when 'A', 'Z', 'z'       then element(:illegal, "\\#{char}")
+          when 'g'                 then element(:special, "\\#{char}#{scanner.scan(/<\w*>/)}")
+          when 'p', 'u'            then element(:special, "\\#{char}#{scanner.scan(/\{[^\}]*\}/)}")
+          when ?/                  then element(:separator, char)
+          else element(:escaped, ?\\) { element(:escaped_char, char) }
+          end
+        end
+
+        # @!visibility private
+        def element(type, content = nil)
+          output << renderer.pre(type)
+          output << renderer.escape(content) if content
+          yield if block_given?
+          output << renderer.post(type)
+        end
+      end
+    end
+  end
+end

data/mustermann-contrib/lib/mustermann/visualizer/pattern_extension.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+module Mustermann
+  module Visualizer
+    # Mixin that will be added to {Mustermann::Pattern}.
+    module PatternExtension
+      prepend_features Composite
+      prepend_features Pattern
+
+      # @example
+      #   puts Mustermann.new("/:page").to_ansi
+      #
+      # @return [String] ANSI colorized version of the pattern.
+      def to_ansi(inspect: nil, **theme)
+        Visualizer.highlight(self, **theme).to_ansi(inspect: inspect)
+      end
+
+      # @example
+      #   puts Mustermann.new("/:page").to_html
+      #
+      # @return [String] HTML version of the pattern.
+      def to_html(inspect: nil, tag: :span, class_prefix: "mustermann_", css: :inline, **theme)
+        Visualizer.highlight(self, **theme).to_html(inspect: inspect, tag: tag, class_prefix: class_prefix, css: css)
+      end
+
+      # @example
+      #   puts Mustermann.new("/:page").to_tree
+      #
+      # @return [String] tree version of the pattern.
+      def to_tree
+        Visualizer.tree(self).to_s
+      end
+
+      # If invoked directly by puts: ANSI colorized version of the pattern.
+      # If invoked by anything else: String version of the pattern.
+      #
+      # @example
+      #   require 'mustermann/visualizer'
+      #   pattern = Mustermann.new('/:page')
+      #   puts pattern        # will have color
+      #   puts pattern.to_s   # will not have color
+      #
+      # @return [String] non-colorized or colorized version of the pattern
+      def to_s
+        caller_locations.first.label == 'puts' ? to_ansi : super
+      end
+
+      # If invoked directly by IRB, same as {#color_inspect}, otherwise same as  {Mustermann::Pattern#inspect}.
+      def inspect
+        caller_locations.first.base_label == '<module:IRB>' ? color_inspect : super
+      end
+
+      # @return [String] ANSI colorized version of {Mustermann::Pattern#inspect}
+      def color_inspect(base_color = nil, **theme)
+        base_color ||= Highlight::DEFAULT_THEME[:base01]
+        template = is_a?(Composite) ? "*#<%p:(*%s*)>*" : "*#<%p:*%s*>*"
+        Hansi.render(template, self.class, to_ansi(inspect: true, **theme), "*" => base_color)
+      end
+
+      # If invoked directly by IRB, same as {#color_inspect}, otherwise same as Object#pretty_print.
+      def pretty_print(q)
+        if q.class.name.to_s[/[^:]+$/] == "ColorPrinter"
+          q.text(color_inspect, inspect.length)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/mustermann-contrib/lib/mustermann/visualizer/renderer/ansi.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+module Mustermann
+  module Visualizer
+    # @!visibility private
+    module Renderer
+      # Generates ANSI colored strings.
+      # @!visibility private
+      class ANSI
+        # @!visibility private
+        def initialize(target, mode: Hansi.mode, **options)
+          @target  = target
+          @mode    = mode
+          @options = options
+        end
+
+        # @!visibility private
+        def render
+          template = @target.to_hansi_template(**@options)
+          Hansi.render(template, tags: true, theme: @target.theme, mode: @mode)
+        end
+      end
+    end
+  end
+end

data/mustermann-contrib/lib/mustermann/visualizer/renderer/generic.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module Mustermann
+  module Visualizer
+    # @!visibility private
+    module Renderer
+      # Logic shared by most renderers.
+      class Generic
+        # @!visibility private
+        def initialize(target, inspect: nil, add_qoutes: true)
+          @target     = target
+          @inspect    = inspect
+          @add_qoutes = !target.pattern.is_a?(Mustermann::Composite)
+        end
+
+        # @!visibility private
+        def render
+          quote =  "#{pre(:quote)}#{escape_string(?")}#{post(:quote)}" if @inspect and @add_qoutes
+          pre(:pattern).to_s + preamble.to_s + quote.to_s + @target.render(self) + quote.to_s + post(:pattern).to_s
+        end
+
+        # @!visibility private
+        def preamble
+        end
+
+        # @!visibility private
+        def escape(value, inspect_value = value.to_s.inspect[1..-2])
+          escape_string(@inspect ? inspect_value : value.to_s)
+        end
+
+        # @!visibility private
+        def escape_string(string)
+          string
+        end
+
+        # @!visibility private
+        def pre(type)
+          ""
+        end
+
+        # @!visibility private
+        def post(type)
+          ""
+        end
+      end
+    end
+  end
+end

data/mustermann-contrib/lib/mustermann/visualizer/renderer/hansi_template.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+require 'mustermann/visualizer/renderer/generic'
+
+module Mustermann
+  module Visualizer
+    # @!visibility private
+    module Renderer
+      # Generates Hansi template string.
+      # @see Mustermann::Visualizer::Renderer::ANSI
+      # @!visibility private
+      class HansiTemplate < Generic
+        # @!visibility private
+        def initialize(*)
+          @hansi = Hansi::StringRenderer.new(tags: true)
+          super
+        end
+
+        # @!visibility private
+        def escape_string(string)
+          @hansi.escape(string)
+        end
+
+        # @!visibility private
+        def pre(type)
+          "<#{type}>"
+        end
+
+        # @!visibility private
+        def post(type)
+          "</#{type}>"
+        end
+      end
+    end
+  end
+end

data/mustermann-contrib/lib/mustermann/visualizer/renderer/html.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+require 'mustermann/visualizer/renderer/generic'
+require 'cgi'
+
+module Mustermann
+  module Visualizer
+    # @!visibility private
+    module Renderer
+      # Generates HTML output.
+      # @!visibility private
+      class HTML < Generic
+        # @!visibility private
+        def initialize(target, tag: :span, class_prefix: "mustermann_", css: :inline, **options)
+          raise ArgumentError, 'css option %p not supported, should be true, false or inline' if css != true and css != false and css != :inline
+          super(target, **options)
+          @css, @tag, @class_prefix = css, tag, class_prefix
+        end
+
+        # @!visibility private
+        def preamble
+          "<style type=\"text/css\">\n%s</style>" %  stylesheet if  @css == true
+        end
+
+        # @!visibility private
+        def stylesheet
+          @target.theme.to_css { |name| ".#{@class_prefix}pattern .#{@class_prefix}#{name}" }
+        end
+
+        # @!visibility private
+        def escape_string(string)
+          CGI.escape_html(string)
+        end
+
+        # @!visibility private
+        def pre(type)
+          if @css == :inline
+            return "" unless rule = @target.theme[type]
+            "<#{@tag} style=\"#{rule.to_css_rule}\">"
+          else
+            "<#{@tag} class=\"#{@class_prefix}#{type}\">"
+          end
+        end
+
+        # @!visibility private
+        def post(type)
+          "</#{@tag}>"
+        end
+      end
+    end
+  end
+end

data/mustermann-contrib/lib/mustermann/visualizer/renderer/sexp.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+require 'mustermann/visualizer/renderer/generic'
+
+module Mustermann
+  module Visualizer
+    # @!visibility private
+    module Renderer
+      # Generates a s-expression like string.
+      # @!visibility private
+      class Sexp < Generic
+        # @!visibility private
+        def render
+          @inspect = false
+          super.gsub(/ ?\)( \))*/) { |s| s.gsub(' ', '') }.strip
+        end
+
+
+        # @!visibility private
+        def pre(type)
+          "(#{type} " if type != :pattern
+        end
+
+        # @!visibility private
+        def escape_string(input)
+          inspect = input.inspect
+          input   = inspect if inspect != "\"#{input}\""
+          input   = inspect if input =~ /[\s\"\'\(\)]/
+          input + " "
+        end
+
+        # @!visibility private
+        def post(type)
+          ") " if type != :pattern
+        end
+      end
+    end
+  end
+end

data/mustermann-contrib/lib/mustermann/visualizer/tree.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+require 'hansi'
+
+module Mustermann
+  module Visualizer
+    # Represents a (sub)tree and at the same time a node in the tree.
+    class Tree
+      # @!visibility private
+      attr_reader :line, :children, :prefix_color, :before, :after
+
+      # @!visibility private
+      def initialize(line, *children, prefix_color: :default, before: "", after: "")
+        @line         = line
+        @children     = children
+        @prefix_color = prefix_color
+        @before       = before
+        @after        = after
+      end
+
+      # used for positioning {#after}
+      # @!visibility private
+      def line_widths(offset = 0)
+        child_widths = children.flat_map { |c| c.line_widths(offset + 2)  }
+        width        = length(line + before) + offset
+        [width, *child_widths]
+      end
+
+      # Renders the tree.
+      # @return [String] rendered version of the tree
+      def to_s
+        render("", "", line_widths.max)
+      end
+
+      # Renders tree, including nesting.
+      # @!visibility private
+      def render(first_prefix, prefix, width)
+        output = before + Hansi.render(prefix_color, first_prefix) + line
+        output = ljust(output, width) + "  " + after + "\n"
+        children[0..-2].each { |child| output += child.render(prefix + "├ ", prefix + "│ ", width) }
+        output += children.last.render(prefix + "└ ", prefix + "  ", width) if children.last
+        output
+      end
+
+      # @!visibility private
+      def length(string)
+        deansi(string).length
+      end
+
+      # @!visibility private
+      def deansi(string)
+        string.gsub(/\e\[[^m]+m/, '')
+      end
+
+      # @!visibility private
+      def ljust(string, width)
+        missing = width - length(string)
+        append  = missing > 0 ? " " * missing : ""
+        string + append
+      end
+
+      private :ljust, :deansi, :length
+    end
+  end
+end