mustermann-contrib 1.0.0.beta2

data/spec/visualizer_spec.rb

@@ -0,0 +1,199 @@
+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|b' do
+        let(:pattern) { Mustermann.new('a|b') }
+        its(:to_sexp) { should be == '(root (union (char a) | (char b)))' }
+      end
+
+      context '(a|b)' do
+        let(:pattern) { Mustermann.new('(a|b)c') }
+        its(:to_sexp) { should be == '(root (union "(" (char a) | (char b) ")") (char c))' }
+      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, check_anchors: false) }
+        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 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, check_anchors: false) }
+        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 "(?-mix:") (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
+
+    context :composite do
+      let(:pattern) { Mustermann.new(":a", ":b") ^ Mustermann.new(":c") }
+      its(:to_sexp) do
+        should be == '(composite (quote "(") (composite (type sinatra:) (quote "\\"") '         \
+          '(root (capture : (name a))) (quote "\\"") (quote " | ") (type sinatra:) (quote '     \
+          '"\\"") (root (capture : (name b))) (quote "\\"")) (quote ")") (quote " ^ ") (type '  \
+          'sinatra:) (quote "\\"") (root (capture : (name c))) (quote "\\""))'
+      end
+    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

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: mustermann-contrib
+version: !ruby/object:Gem::Version
+  version: 1.0.0.beta2
+platform: ruby
+authors:
+- Konstantin Haase
+- Zachary Scott
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-08-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mustermann
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.beta2
+- !ruby/object:Gem::Dependency
+  name: hansi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: Adds many plugins to Mustermman
+email: mail@zzak.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- examples/highlighting.rb
+- highlighting.png
+- irb.png
+- lib/mustermann/cake.rb
+- lib/mustermann/express.rb
+- lib/mustermann/file_utils.rb
+- lib/mustermann/file_utils/glob_pattern.rb
+- lib/mustermann/fileutils.rb
+- lib/mustermann/flask.rb
+- lib/mustermann/grape.rb
+- lib/mustermann/pyramid.rb
+- lib/mustermann/rails.rb
+- lib/mustermann/shell.rb
+- lib/mustermann/simple.rb
+- lib/mustermann/string_scanner.rb
+- lib/mustermann/strscan.rb
+- lib/mustermann/template.rb
+- lib/mustermann/uri_template.rb
+- lib/mustermann/versions.rb
+- lib/mustermann/visualizer.rb
+- lib/mustermann/visualizer/highlight.rb
+- lib/mustermann/visualizer/highlighter.rb
+- lib/mustermann/visualizer/highlighter/ad_hoc.rb
+- lib/mustermann/visualizer/highlighter/ast.rb
+- lib/mustermann/visualizer/highlighter/composite.rb
+- lib/mustermann/visualizer/highlighter/dummy.rb
+- lib/mustermann/visualizer/highlighter/regular.rb
+- lib/mustermann/visualizer/pattern_extension.rb
+- lib/mustermann/visualizer/renderer/ansi.rb
+- lib/mustermann/visualizer/renderer/generic.rb
+- lib/mustermann/visualizer/renderer/hansi_template.rb
+- lib/mustermann/visualizer/renderer/html.rb
+- lib/mustermann/visualizer/renderer/sexp.rb
+- lib/mustermann/visualizer/tree.rb
+- lib/mustermann/visualizer/tree_renderer.rb
+- mustermann-contrib.gemspec
+- spec/cake_spec.rb
+- spec/express_spec.rb
+- spec/file_utils_spec.rb
+- spec/flask_spec.rb
+- spec/flask_subclass_spec.rb
+- spec/grape_spec.rb
+- spec/pattern_extension_spec.rb
+- spec/pyramid_spec.rb
+- spec/rails_spec.rb
+- spec/shell_spec.rb
+- spec/simple_spec.rb
+- spec/string_scanner_spec.rb
+- spec/template_spec.rb
+- spec/visualizer_spec.rb
+- theme.png
+- tree.png
+homepage: https://github.com/sinatra/mustermann
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Collection of extensions for Mustermann
+test_files: []
+has_rdoc: