mustermann-visualizer 0.4.0

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

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

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

@@ -0,0 +1,37 @@
+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/lib/mustermann/visualizer/tree.rb

@@ -0,0 +1,63 @@
+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

data/lib/mustermann/visualizer/tree_renderer.rb

@@ -0,0 +1,78 @@
+require 'mustermann/visualizer/tree'
+require 'mustermann/ast/translator'
+require 'hansi'
+
+module Mustermann
+  module Visualizer
+    # Turns an AST into a Tree
+    # @!visibility private
+    class TreeRenderer < AST::Translator
+      TEMPLATE     = '"<base01>%s</base01><underline><green>%s</green></underline><base01>%s</base01>"  '
+      THEME        = Hansi::Theme[:solarized]
+      PREFIX_COLOR = THEME[:violet]
+      FakeNode     = Struct.new(:type, :start, :stop, :length)
+      private_constant(:TEMPLATE, :THEME, :PREFIX_COLOR, :FakeNode)
+
+      # Takes a pattern (or pattern string and option) and turns it into a tree.
+      # Runs translation if pattern implements to_ast, otherwise returns single
+      # node tree.
+      #
+      # @!visibility private
+      def self.render(pattern, **options)
+        pattern &&= Mustermann.new(pattern, **options)
+        renderer  = new(pattern.to_s)
+        if pattern.respond_to? :to_ast
+          renderer.translate(pattern.to_ast)
+        else
+          length = renderer.string.length
+          node   = FakeNode.new("pattern (not AST based)", 0, length, length)
+          renderer.tree(node)
+        end
+      end
+
+      # @!visibility private
+      attr_reader :string
+
+      # @!visibility private
+      def initialize(string)
+        @string = string
+      end
+
+      # access a substring of the pattern, in inspect mode
+      # @!visibility private
+      def sub(*args)
+        string[*args].inspect[1..-2]
+      end
+
+      # creates a tree node
+      # @!visibility private
+      def tree(node, *children, **typed_children)
+        children   += children_for(typed_children)
+        children    = children.flatten.grep(Tree)
+        infos       = sub(0, node.start), sub(node.start, node.length), sub(node.stop..-1)
+        description = Hansi.render(THEME[:green], node.type.to_s.tr("_", " "))
+        after      = Hansi.render(TEMPLATE, *infos, theme: THEME, tags: true)
+        Tree.new(description, *children, after: after, prefix_color: PREFIX_COLOR)
+      end
+
+      # Take a hash with trees as values and turn the keys into trees, too.
+      # Read again if that didn't make sense.
+      # @!visibility private
+      def children_for(list)
+        list.map do |key, value|
+          value = Array(value).flatten
+          if value.any?
+            after      = " " * string.inspect.length + "  "
+            description = Hansi.render(THEME[:orange], key.to_s)
+            Tree.new(description, *value, after: after, prefix_color: PREFIX_COLOR)
+          end
+        end
+      end
+
+      translate(:node) { t.tree(node, payload: t(payload)) }
+      translate(:with_look_ahead) { t.tree(node, head: t(head), payload: t(payload)) }
+      translate(Array) { map { |e| t(e) }}
+      translate(Object) { }
+    end
+  end
+end

data/mustermann-visualizer.gemspec

@@ -0,0 +1,19 @@
+$:.unshift File.expand_path("../../mustermann/lib", __FILE__)
+require "mustermann/version"
+
+Gem::Specification.new do |s|
+  s.name                  = "mustermann-visualizer"
+  s.version               = Mustermann::VERSION
+  s.author                = "Konstantin Haase"
+  s.email                 = "konstantin.mailinglists@googlemail.com"
+  s.homepage              = "https://github.com/rkh/mustermann"
+  s.summary               = %q{Visualize Mustermann patterns}
+  s.description           = %q{Provides syntax highlighting and other visualizations for Mustermman}
+  s.license               = 'MIT'
+  s.required_ruby_version = '>= 2.1.0'
+  s.files                 = `git ls-files`.split("\n")
+  s.test_files            = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables           = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.add_dependency 'mustermann', Mustermann::VERSION
+  s.add_dependency 'hansi', '~> 0.1.1'
+end

data/spec/pattern_extension_spec.rb

@@ -0,0 +1,48 @@
+require 'support'
+require 'mustermann/visualizer'
+require 'pp'
+require 'stringio'
+
+describe Mustermann::Visualizer::PatternExtension do
+  subject(:pattern) { Mustermann.new("/:name") }
+  before { Hansi.mode = 16  }
+  after  { Hansi.mode = nil }
+
+  specify :to_ansi do
+    pattern.to_ansi(inspect: true,  capture: :red,   default: nil).should be == "\e[0m\"\e[0m/\e[0m\e[91m:\e[0m\e[91mname\e[0m\"\e[0m"
+    pattern.to_ansi(inspect: false, capture: :green, default: nil).should be == "\e[0m/\e[0m\e[32m:\e[0m\e[32mname\e[0m"
+  end
+
+  specify :to_html do
+    pattern.to_html(css: false, class_prefix: "", tag: :tt).should be == '<tt class="pattern"><tt class="root"><tt class="separator">/</tt><tt class="capture">:<tt class="name">name</tt></tt></tt></tt>'
+  end
+
+  specify :to_tree do
+    pattern.to_tree.should be == Mustermann::Visualizer.tree(pattern).to_s
+  end
+
+  specify :color_inspect do
+    pattern.color_inspect.should include(pattern.to_ansi(inspect: true))
+    pattern.color_inspect.should include("#<Mustermann::Sinatra:")
+  end
+
+  specify :to_s do
+    object = Class.new { def puts(arg) arg.to_s end }.new
+    object.puts(pattern).should be == pattern.to_ansi
+  end
+
+  context :pretty_print do
+    before(:all) { ColorPrinter = Class.new(::PP) }
+    let(:output) { StringIO.new }
+
+    specify 'with color printer' do
+      ColorPrinter.new(output, 79).pp(pattern)
+      output.string.should be == pattern.color_inspect
+    end
+
+    specify 'without color printer' do
+      ::PP.new(output, 79).pp(pattern)
+      output.string.should be == pattern.inspect
+    end
+  end
+end

data/spec/visualizer_spec.rb

@@ -0,0 +1,179 @@
+require 'support'
+require 'mustermann/visualizer'
+
+describe Mustermann::Visualizer do
+  subject(:highlight) { Mustermann::Visualizer.highlight(pattern) }
+  before { Hansi.mode = 256 }
+  after  { Hansi.mode = nil }
+
+  describe :highlight do
+    context :sinatra do
+      context "/a" do
+        let(:pattern) { Mustermann.new("/a") }
+        its(:to_ansi)    { should be == "\e[0m\e[38;5;246m\e[38;5;246m\e[38;5;247m/\e[0m\e[38;5;246m\e[38;5;246m\e[38;5;246ma\e[0m" }
+        its(:to_html)    { should be == '<span style="color: #839496;"><span style="color: #93a1a1;">/</span><span style="color: #839496;">a</span></span></span>' }
+        its(:to_sexp)    { should be == '(root (separator /) (char a))' }
+        its(:to_pattern) { should be == pattern }
+        its(:to_s)       { should be == "/a" }
+        its(:stylesheet) { should include(".mustermann_pattern .mustermann_illegal {\n  color: #8b0000;") }
+
+        example do
+          highlight.to_html(css: false).should be == 
+            '<span class="mustermann_pattern"><span class="mustermann_root"><span class="mustermann_separator">/</span><span class="mustermann_char">a</span></span></span>'
+        end
+
+        example do
+          renderer = Mustermann::Visualizer::Renderer::Generic
+          result   = highlight.render_with(renderer)
+          result.should be == pattern.to_s
+        end
+      end
+
+      context '/:name' do
+        let(:pattern) { Mustermann.new("/:name") }
+        its(:to_sexp) { should be == "(root (separator /) (capture : (name name)))" }
+      end
+
+      context '/{name}' do
+        let(:pattern) { Mustermann.new("/{name}") }
+        its(:to_sexp) { should be == "(root (separator /) (capture { (name name) }))" }
+      end
+
+      context '/{+name}' do
+        let(:pattern) { Mustermann.new("/{+name}") }
+        its(:to_sexp) { should be == "(root (separator /) (named_splat {+ (name name) }))" }
+      end
+
+      context ':user(@:host)?' do
+        let(:pattern) { Mustermann.new(':user(@:host)?') }
+        its(:to_sexp) { should be == '(root (capture : (name user)) (optional (group "(" (char @) (capture : (name host)) ")") ?))' }
+      end
+
+      context 'a b' do
+        let(:pattern) { Mustermann.new('a b') }
+        its(:to_sexp) { should be == '(root (char a) (char " ") (char b))' }
+      end
+
+      context '\:a' do
+        let(:pattern) { Mustermann.new('\:a') }
+        its(:to_sexp) { should be == '(root (escaped "\\\\" (escaped_char :)) (char a))' }
+      end
+    end
+
+    context :regexp do
+      context 'a' do
+        let(:pattern) { Mustermann.new('a', type: :regexp) }
+        its(:to_sexp) { should be == '(root (char a))' }
+      end
+
+      context '/(\d+)' do
+        let(:pattern) { Mustermann.new('/(\d+)', type: :regexp) }
+        its(:to_sexp) { should be == '(root (separator /) (capture "(" (special "\\\\d") (special +))))' }
+      end
+
+      context '\A' do
+        let(:pattern) { Mustermann.new('\A', type: :regexp) }
+        its(:to_sexp) { should be == '(root (illegal "\\\\A"))' }
+      end
+
+      context '(?<name>.)\g<name>' do
+        let(:pattern) { Mustermann.new('(?<name>.)\g<name>', type: :regexp) }
+        its(:to_sexp) { should be == '(root (capture "(?<" (name) >(special .))) (special "\\\\g<name>"))' }
+      end
+
+      context '\p{Ll}' do
+        let(:pattern) { Mustermann.new('\p{Ll}', type: :regexp) }
+        its(:to_sexp) { should be == '(root (special "\\\\p{Ll}"))' }
+      end
+
+      context '\/' do
+        let(:pattern) { Mustermann.new('\/', type: :regexp) }
+        its(:to_sexp) { should be == '(root (separator /))' }
+      end
+
+      context '\[' do
+        let(:pattern) { Mustermann.new('\[', type: :regexp) }
+        its(:to_sexp) { should be == '(root (escaped "\\\\" (escaped_char [)))' }
+      end
+
+      context '^' do
+        let(:pattern) { Mustermann.new('^', type: :regexp) }
+        its(:to_sexp) { should be == '(root (illegal ^))' }
+      end
+
+      context '(?-mix:.)' do
+        let(:pattern) { Mustermann.new('(?-mix:.)', type: :regexp) }
+        its(:to_sexp) { should be == '(root (special "(") (special .) (special ")"))' }
+      end
+
+      context '[a\d]' do
+        let(:pattern) { Mustermann.new('[a\d]', type: :regexp) }
+        its(:to_sexp) { should be == '(root (special [) (char a) (special "\\\\d") (special ]))' }
+      end
+
+      context '[^a-z]' do
+        let(:pattern) { Mustermann.new('[^a-z]', type: :regexp) }
+        its(:to_sexp) { should be == '(root (special [) (special ^) (char a) (special -) (char z) (special ]))' }
+      end
+
+      context '[[:digit:]]' do
+        let(:pattern) { Mustermann.new('[[:digit:]]', type: :regexp) }
+        its(:to_sexp) { should be == '(root (special [[:digit:]]))' }
+      end
+
+      context 'a{1,}' do
+        let(:pattern) { Mustermann.new('a{1,}', type: :regexp) }
+        its(:to_sexp) { should be == "(root (char a) (special {1,}))" }
+      end
+    end
+
+    context :template do
+      context '/{name}' do
+        let(:pattern) { Mustermann.new("/{+foo,bar*}", type: :template) }
+        its(:to_sexp) { should be == "(root (separator /) (expression {+ (variable (name foo)) , (variable (name bar) *) }))" }
+      end
+    end
+
+    context "custom AST based pattern" do
+      let(:my_type) { Class.new(Mustermann::AST::Pattern) { on('x') { |*| node(:char, "o") } }}
+      let(:pattern) { Mustermann.new("fxx", type: my_type) }
+      its(:to_sexp) { should be == "(root (char f) (escaped x) (escaped x))" }
+    end
+
+    context "without known highlighter" do
+      let(:pattern) { Mustermann::Pattern.new("foo") }
+      its(:to_sexp) { should be == "(root (unknown foo))" }
+    end
+  end
+
+  describe :tree do
+    subject(:tree) { Mustermann::Visualizer.tree(pattern) }
+
+    context :sinatra do
+      context "/:a(@:b)" do
+        let(:pattern) { Mustermann.new("/:a(@:b)") }
+        let(:tree_data) do
+          <<-TREE.gsub(/^\s+/, '')
+            \e[38;5;61m\e[0m\e[38;5;100mroot\e[0m             \e[0m\e[38;5;66m\"\e[0m\e[38;5;66m\e[38;5;242m\e[0m\e[38;5;66m\e[4m\e[38;5;100m/:a(@:b)\e[0m\e[38;5;66m\e[38;5;242m\e[0m\e[38;5;66m\"  \e[0m
+            \e[38;5;61m└ \e[0m\e[38;5;166mpayload\e[0m                    
+            \e[38;5;61m  ├ \e[0m\e[38;5;100mseparator\e[0m    \e[0m\e[38;5;66m\"\e[0m\e[38;5;66m\e[38;5;242m\e[0m\e[38;5;66m\e[4m\e[38;5;100m/\e[0m\e[38;5;66m\e[38;5;242m:a(@:b)\e[0m\e[38;5;66m\"  \e[0m
+            \e[38;5;61m  ├ \e[0m\e[38;5;100mcapture\e[0m      \e[0m\e[38;5;66m\"\e[0m\e[38;5;66m\e[38;5;242m/\e[0m\e[38;5;66m\e[4m\e[38;5;100m:a\e[0m\e[38;5;66m\e[38;5;242m(@:b)\e[0m\e[38;5;66m\"  \e[0m
+            \e[38;5;61m  └ \e[0m\e[38;5;100mgroup\e[0m        \e[0m\e[38;5;66m\"\e[0m\e[38;5;66m\e[38;5;242m/:a\e[0m\e[38;5;66m\e[4m\e[38;5;100m(@:b)\e[0m\e[38;5;66m\e[38;5;242m\e[0m\e[38;5;66m\"  \e[0m
+            \e[38;5;61m    └ \e[0m\e[38;5;166mpayload\e[0m                
+            \e[38;5;61m      ├ \e[0m\e[38;5;100mchar\e[0m     \e[0m\e[38;5;66m\"\e[0m\e[38;5;66m\e[38;5;242m/:a(\e[0m\e[38;5;66m\e[4m\e[38;5;100m@\e[0m\e[38;5;66m\e[38;5;242m:b)\e[0m\e[38;5;66m\"  \e[0m
+            \e[38;5;61m      └ \e[0m\e[38;5;100mcapture\e[0m  \e[0m\e[38;5;66m\"\e[0m\e[38;5;66m\e[38;5;242m/:a(@\e[0m\e[38;5;66m\e[4m\e[38;5;100m:b\e[0m\e[38;5;66m\e[38;5;242m)\e[0m\e[38;5;66m\"  \e[0m
+          TREE
+        end
+        its(:to_s) { should be == tree_data }
+      end
+    end
+
+    context :shell do
+      context "/**/*" do
+        let(:pattern) { Mustermann.new("/**/*", type: :shell) }
+        let(:tree_data) { "\e[38;5;61m\e[0m\e[38;5;100mpattern (not AST based)\e[0m  \e[0m\e[38;5;66m\"\e[0m\e[38;5;66m\e[38;5;242m\e[0m\e[38;5;66m\e[4m\e[38;5;100m/**/*\e[0m\e[38;5;66m\e[38;5;242m\e[0m\e[38;5;66m\"  \e[0m\n" }
+        its(:to_s) { should be == tree_data }
+      end
+    end
+  end
+end