mustermann-visualizer 0.4.0

data/lib/mustermann/visualizer/highlighter/ad_hoc.rb

@@ -0,0 +1,94 @@
+require 'strscan'
+
+module Mustermann
+  module Visualizer
+    # @!visibility private
+    module Highlighter
+      # Used to generate highlighting rules on the fly.
+      # @see {Mustermann::Shell#highlighter}
+      # @see {Mustermann::Simple#highlighter}
+      # @!visibility private
+      class AdHoc
+        # @!visibility private
+        def self.highlight(pattern, renderer)
+          new(pattern, renderer).highlight
+        end
+
+        # @!visibility private
+        def self.rules
+          @rules ||= {}
+        end
+
+        # @!visibility private
+        def self.on(regexp, type = nil, &callback)
+          return regexp.map  { |key, value| on(key, value, &callback) } if regexp.is_a? Hash
+          raise ArgumentError, 'needs type or callback' unless type or callback
+          callback    ||= proc { |matched| element(type, matched) }
+          regexp        = Regexp.new(Regexp.escape(regexp)) unless regexp.is_a? Regexp
+          rules[regexp] = callback
+        end
+
+        # @!visibility private
+        attr_reader :pattern, :renderer, :rules, :output, :scanner
+        def initialize(pattern, renderer)
+          @pattern  = pattern
+          @renderer = renderer
+          @output   = ""
+          @rules    = self.class.rules
+          @scanner  = StringScanner.new(pattern.to_s)
+        end
+
+        # @!visibility private
+        def highlight(stop = /\Z/)
+          output << renderer.pre(:root)
+          until scanner.eos? or scanner.check(stop)
+            position = scanner.pos
+            apply(scanner)
+            read_char(scanner) if position == scanner.pos and not scanner.check(stop)
+          end
+          output << renderer.post(:root)
+        end
+
+        # @!visibility private
+        def apply(scanner)
+          rules.each do |regexp, callback|
+            next unless result = scanner.scan(regexp)
+            instance_exec(result, &callback)
+          end
+        end
+
+        # @!visibility private
+        def read_char(scanner)
+          return unless char = scanner.getch
+          type = char == ?/ ? :separator : :char
+          element(type, char)
+        end
+
+        # @!visibility private
+        def escaped(content = ?\\, char)
+          element(:escaped, content) { element(:escaped_char, char) }
+        end
+
+        # @!visibility private
+        def nested(type, opening, closing, *separators)
+          element(type, opening) do
+            char = nil
+            until char == closing or scanner.eos?
+              highlight(Regexp.union(closing, *separators))
+              char = scanner.getch
+              output << char if char
+            end
+          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/lib/mustermann/visualizer/highlighter/ast.rb

@@ -0,0 +1,102 @@
+require 'mustermann/ast/translator'
+
+module Mustermann
+  module Visualizer
+    # @!visibility private
+    module Highlighter
+      # Provides highlighting for AST based patterns
+      # @!visibility private
+      class AST
+        Index   = Struct.new(:type, :start, :stop, :payload) { undef :to_a }
+        Indexer = Mustermann::AST::Translator.create do
+          translate(:node)  { |i| Index.new(type, start, stop, Array(t(payload, i)).flatten.compact) }
+          translate(Array)  { |i| map { |e| t(e, i) } }
+          translate(Object) { |i| }
+
+          translate(:with_look_ahead) do |input|
+            [t(head, input), *t(payload, input)]
+          end
+
+          translate(:expression) do |input|
+            index = Index.new(type, start, stop, Array(t(payload, input)).compact)
+            index.payload.delete_if { |e| e.type == :separator }
+            index
+          end
+
+          translate(:capture) do |input|
+            substring   = input[start, length]
+            if substart = substring.index(name)
+              substart += start
+              substop   = substart + name.length
+              payload   = [Index.new(:name, substart, substop, [])]
+            end
+            Index.new(type, start, stop, payload || [])
+          end
+
+          translate(:char) do |input|
+            substring = input[start, length]
+            if payload == substring
+              Index.new(type, start, stop, [])
+            elsif substart = substring.index(payload)
+              substart    += start
+              substop      = substart + payload.length
+              Index.new(:escaped, start, stop, [Index.new(:escaped_char, substart, substop, [])])
+            else
+              Index.new(:escaped, start, stop, [])
+            end
+          end
+        end
+
+        private_constant(:Index, :Indexer)
+
+        # @!visibility private
+        def self.highlight?(pattern)
+          pattern.respond_to? :to_ast
+        end
+
+        # @!visibility private
+        def self.highlight(pattern, renderer)
+          new(pattern, renderer).highlight
+        end
+
+        # @!visibility private
+        def initialize(pattern, renderer)
+          @ast      = pattern.to_ast
+          @string   = pattern.to_s
+          @renderer = renderer
+        end
+
+        # @!visibility private
+        def highlight
+          index = Indexer.translate(@ast, @string)
+          inject_literals(index)
+          render(index)
+        end
+
+        # @!visibility private
+        def render(index)
+          return @renderer.escape(@string[index.start..index.stop-1]) if index.type == :literal
+          payload = index.payload.map { |i| render(i) }.join
+          "#{ @renderer.pre(index.type) }#{ payload }#{ @renderer.post(index.type) }"
+        end
+
+        # @!visibility private
+        def inject_literals(index)
+          start, old_payload, index.payload = index.start, index.payload, []
+          old_payload.each do |element|
+            index.payload << literal(start, element.start) if start < element.start
+            index.payload << element
+            inject_literals(element)
+            start = element.stop
+          end
+          index.payload << literal(start, index.stop) if start < index.stop
+        end
+
+        # @!visibility private
+        def literal(start, stop)
+          Index.new(:literal, start, stop, [])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+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 = ""
+          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/lib/mustermann/visualizer/highlighter/regular.rb

@@ -0,0 +1,104 @@
+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   = ""
+        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/lib/mustermann/visualizer/pattern_extension.rb

@@ -0,0 +1,66 @@
+module Mustermann
+  module Visualizer
+    # Mixin that will be added to {Mustermann::Pattern}.
+    module PatternExtension
+      prepend_features Pattern
+
+      # @example
+      #   puts Mustermann.new("/:page").to_ansi
+      #
+      # @return [String] ANSI colorized version of the pattern.
+      def to_ansi(inspect: false, **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: false, 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]
+        Hansi.render("*#<%p:*%s*>*", 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/lib/mustermann/visualizer/renderer/ansi.rb

@@ -0,0 +1,23 @@
+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/lib/mustermann/visualizer/renderer/generic.rb

@@ -0,0 +1,49 @@
+require 'mustermann/regular'
+
+module Mustermann
+  module Visualizer
+    # @!visibility private
+    module Renderer
+      # Logic shared by most renderers.
+      class Generic
+        # @!visibility private
+        def initialize(target, inspect: false)
+          @target  = target
+          @inspect = inspect
+        end
+
+        # @!visibility private
+        def render
+          quote = @inspect ? "#{pre(:quote)}\"#{post(:quote)}" : ""
+          pre(:pattern).to_s + preamble.to_s + quote + @target.render(self) + quote + post(:pattern).to_s
+        end
+
+        # @!visibility private
+        def preamble
+        end
+
+        # @!visibility private
+        def escape(value)
+          value = value.to_s
+          value = value.inspect[1..-2] if @inspect
+          escape_string(value)
+        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