mustermann 1.0.1 → 1.0.2.rc1

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

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+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-contrib/mustermann-contrib.gemspec

@@ -0,0 +1,19 @@
+$:.unshift File.expand_path("../../mustermann/lib", __FILE__)
+require "mustermann/version"
+
+Gem::Specification.new do |s|
+  s.name                  = "mustermann-contrib"
+  s.version               = Mustermann::VERSION
+  s.authors               = ["Konstantin Haase", "Zachary Scott"]
+  s.email                 = "sinatrarb@googlegroups.com"
+  s.homepage              = "https://github.com/sinatra/mustermann"
+  s.summary               = %q{Collection of extensions for Mustermann}
+  s.description           = %q{Adds many plugins to Mustermman}
+  s.license               = 'MIT'
+  s.required_ruby_version = '>= 2.2.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.2.0'
+end

data/mustermann-contrib/spec/cake_spec.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+require 'support'
+require 'mustermann/cake'
+
+describe Mustermann::Cake do
+  extend Support::Pattern
+
+  pattern '' do
+    it { should     match('')  }
+    it { should_not match('/') }
+
+    it { should expand.to('') }
+    it { should_not expand(a: 1) }
+
+    it { should generate_template('') }
+
+    it { should respond_to(:expand)       }
+    it { should respond_to(:to_templates) }
+  end
+
+  pattern '/' do
+    it { should     match('/')    }
+    it { should_not match('/foo') }
+
+    it { should expand.to('/') }
+    it { should_not expand(a: 1) }
+  end
+
+  pattern '/foo' do
+    it { should     match('/foo')     }
+    it { should_not match('/bar')     }
+    it { should_not match('/foo.bar') }
+
+    it { should expand.to('/foo') }
+    it { should_not expand(a: 1) }
+  end
+
+  pattern '/foo/bar' do
+    it { should     match('/foo/bar')   }
+    it { should_not match('/foo%2Fbar') }
+    it { should_not match('/foo%2fbar') }
+
+    it { should expand.to('/foo/bar') }
+    it { should_not expand(a: 1) }
+  end
+
+  pattern '/:foo' do
+    it { should match('/foo')       .capturing foo: 'foo'       }
+    it { should match('/bar')       .capturing foo: 'bar'       }
+    it { should match('/foo.bar')   .capturing foo: 'foo.bar'   }
+    it { should match('/%0Afoo')    .capturing foo: '%0Afoo'    }
+    it { should match('/foo%2Fbar') .capturing foo: 'foo%2Fbar' }
+
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/')        }
+    it { should_not match('/foo/')    }
+
+    example { pattern.params('/foo')   .should be == {"foo" => "foo"} }
+    example { pattern.params('/f%20o') .should be == {"foo" => "f o"} }
+    example { pattern.params('').should be_nil }
+
+    it { should expand(foo: 'bar')     .to('/bar')       }
+    it { should expand(foo: 'b r')     .to('/b%20r')     }
+    it { should expand(foo: 'foo/bar') .to('/foo%2Fbar') }
+
+    it { should_not expand(foo: 'foo', bar: 'bar') }
+    it { should_not expand(bar: 'bar') }
+    it { should_not expand }
+
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/*' do
+    it { should match('/')        }
+    it { should match('/foo')     }
+    it { should match('/foo/bar') }
+
+    example { pattern.params('/foo/bar') .should be == {"splat" => ["foo", "bar"]}}
+    it { should generate_template('/{+splat}') }
+  end
+
+  pattern '/**' do
+    it { should match('/')        .capturing splat: ''        }
+    it { should match('/foo')     .capturing splat: 'foo'     }
+    it { should match('/foo/bar') .capturing splat: 'foo/bar' }
+
+    example { pattern.params('/foo/bar') .should be == {"splat" => ["foo/bar"]} }
+    it { should generate_template('/{+splat}') }
+  end
+end

data/mustermann-contrib/spec/express_spec.rb

@@ -0,0 +1,210 @@
+# frozen_string_literal: true
+require 'support'
+require 'mustermann/express'
+
+describe Mustermann::Express do
+  extend Support::Pattern
+
+  pattern '' do
+    it { should     match('')  }
+    it { should_not match('/') }
+
+    it { should expand.to('') }
+    it { should_not expand(a: 1) }
+
+    it { should generate_template('') }
+
+    it { should respond_to(:expand)       }
+    it { should respond_to(:to_templates) }
+  end
+
+  pattern '/' do
+    it { should     match('/')    }
+    it { should_not match('/foo') }
+
+    it { should expand.to('/') }
+    it { should_not expand(a: 1) }
+  end
+
+  pattern '/foo' do
+    it { should     match('/foo')     }
+    it { should_not match('/bar')     }
+    it { should_not match('/foo.bar') }
+
+    it { should expand.to('/foo') }
+    it { should_not expand(a: 1) }
+  end
+
+  pattern '/foo/bar' do
+    it { should     match('/foo/bar')   }
+    it { should_not match('/foo%2Fbar') }
+    it { should_not match('/foo%2fbar') }
+
+    it { should expand.to('/foo/bar') }
+    it { should_not expand(a: 1) }
+  end
+
+  pattern '/:foo' do
+    it { should match('/foo')       .capturing foo: 'foo'       }
+    it { should match('/bar')       .capturing foo: 'bar'       }
+    it { should match('/foo.bar')   .capturing foo: 'foo.bar'   }
+    it { should match('/%0Afoo')    .capturing foo: '%0Afoo'    }
+    it { should match('/foo%2Fbar') .capturing foo: 'foo%2Fbar' }
+
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/')        }
+    it { should_not match('/foo/')    }
+
+    example { pattern.params('/foo')   .should be == {"foo" => "foo"} }
+    example { pattern.params('/f%20o') .should be == {"foo" => "f o"} }
+    example { pattern.params('').should be_nil }
+
+    it { should expand(foo: 'bar')     .to('/bar')       }
+    it { should expand(foo: 'b r')     .to('/b%20r')     }
+    it { should expand(foo: 'foo/bar') .to('/foo%2Fbar') }
+
+    it { should_not expand(foo: 'foo', bar: 'bar') }
+    it { should_not expand(bar: 'bar') }
+    it { should_not expand }
+
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/:foo+' do
+    it { should_not match('/') }
+    it { should match('/foo')     .capturing foo: 'foo' }
+    it { should match('/foo/bar') .capturing foo: 'foo/bar' }
+
+    it { should expand                  .to('/')        }
+    it { should expand(foo:  nil)       .to('/')        }
+    it { should expand(foo:  '')        .to('/')        }
+    it { should expand(foo: 'foo')      .to('/foo')     }
+    it { should expand(foo: 'foo/bar')  .to('/foo/bar') }
+    it { should expand(foo: 'foo.bar')  .to('/foo.bar') }
+
+    it { should generate_template('/{+foo}') }
+  end
+
+  pattern '/:foo?' do
+    it { should match('/foo')       .capturing foo: 'foo'       }
+    it { should match('/bar')       .capturing foo: 'bar'       }
+    it { should match('/foo.bar')   .capturing foo: 'foo.bar'   }
+    it { should match('/%0Afoo')    .capturing foo: '%0Afoo'    }
+    it { should match('/foo%2Fbar') .capturing foo: 'foo%2Fbar' }
+    it { should match('/') }
+
+    it { should_not match('/foo?')    }
+    it { should_not match('/foo/bar') }
+    it { should_not match('/foo/')    }
+
+    example { pattern.params('/foo')   .should be == {"foo" => "foo"} }
+    example { pattern.params('/f%20o') .should be == {"foo" => "f o"} }
+    example { pattern.params('/')      .should be == {"foo" => nil  } }
+
+    it { should expand(foo: 'bar')     .to('/bar')       }
+    it { should expand(foo: 'b r')     .to('/b%20r')     }
+    it { should expand(foo: 'foo/bar') .to('/foo%2Fbar') }
+    it { should expand                 .to('/')          }
+
+    it { should_not expand(foo: 'foo', bar: 'bar') }
+    it { should_not expand(bar: 'bar') }
+
+    it { should generate_template('/{foo}') }
+    it { should generate_template('/')      }
+  end
+
+  pattern '/:foo*' do
+    it { should match('/')        .capturing foo: '' }
+    it { should match('/foo')     .capturing foo: 'foo' }
+    it { should match('/foo/bar') .capturing foo: 'foo/bar' }
+
+    it { should expand                  .to('/')        }
+    it { should expand(foo:  nil)       .to('/')        }
+    it { should expand(foo:  '')        .to('/')        }
+    it { should expand(foo: 'foo')      .to('/foo')     }
+    it { should expand(foo: 'foo/bar')  .to('/foo/bar') }
+    it { should expand(foo: 'foo.bar')  .to('/foo.bar') }
+
+    it { should generate_template('/{+foo}') }
+  end
+
+  pattern '/:foo(.*)' do
+    it { should match('/')        .capturing foo: '' }
+    it { should match('/foo')     .capturing foo: 'foo' }
+    it { should match('/foo/bar') .capturing foo: 'foo/bar' }
+
+    it { should expand(foo:  '')        .to('/')        }
+    it { should expand(foo: 'foo')      .to('/foo')     }
+    it { should expand(foo: 'foo/bar')  .to('/foo/bar') }
+    it { should expand(foo: 'foo.bar')  .to('/foo.bar') }
+
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/:foo(\d+)' do
+    it { should_not match('/')    }
+    it { should_not match('/foo') }
+    it { should match('/15') .capturing foo: '15' }
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/:foo(\d+|bar)' do
+    it { should_not match('/')    }
+    it { should_not match('/foo') }
+    it { should match('/15')  .capturing foo: '15' }
+    it { should match('/bar') .capturing foo: 'bar' }
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/:foo(\))' do
+    it { should_not match('/')    }
+    it { should_not match('/foo') }
+    it { should match('/)').capturing foo: ')' }
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/:foo(prefix(\d+|bar))' do
+    it { should_not match('/prefix')    }
+    it { should_not match('/prefixfoo') }
+    it { should match('/prefix15')  .capturing foo: 'prefix15' }
+    it { should match('/prefixbar') .capturing foo: 'prefixbar' }
+    it { should generate_template('/{foo}') }
+  end
+
+  pattern '/(.+)' do
+    it { should_not match('/') }
+    it { should match('/foo')     .capturing splat: 'foo' }
+    it { should match('/foo/bar') .capturing splat: 'foo/bar' }
+    it { should generate_template('/{+splat}') }
+  end
+
+  pattern '/(foo(a|b))' do
+    it { should_not match('/') }
+    it { should match('/fooa') .capturing splat: 'fooa' }
+    it { should match('/foob') .capturing splat: 'foob' }
+    it { should generate_template('/{+splat}') }
+  end
+
+  context 'invalid syntax' do
+    example 'unexpected closing parenthesis' do
+      expect { Mustermann::Express.new('foo)bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected ) while parsing "foo)bar"')
+    end
+
+    example 'missing closing parenthesis' do
+      expect { Mustermann::Express.new('foo(bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected end of string while parsing "foo(bar"')
+    end
+
+    example 'unexpected ?' do
+      expect { Mustermann::Express.new('foo?bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected ? while parsing "foo?bar"')
+    end
+
+    example 'unexpected *' do
+      expect { Mustermann::Express.new('foo*bar') }.
+        to raise_error(Mustermann::ParseError, 'unexpected * while parsing "foo*bar"')
+    end
+  end
+end

data/mustermann-contrib/spec/file_utils_spec.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+require 'support'
+require 'mustermann/file_utils'
+
+describe Mustermann::FileUtils do
+  subject(:utils) { Mustermann::FileUtils }
+  include FileUtils
+
+  before do
+    @pwd     = Dir.pwd
+    @tmp_dir = File.join(__dir__, 'tmp')
+
+    mkdir_p(@tmp_dir)
+    chdir(@tmp_dir)
+
+    touch("foo.txt")
+    touch("foo.rb")
+    touch("bar.txt")
+    touch("bar.rb")
+  end
+
+  after do
+    chdir(@pwd)     if @pwd
+    rm_rf(@tmp_dir) if @tmp_dir
+  end
+
+  describe :glob_pattern do
+    example { utils.glob_pattern('/:foo')                 .should be == '/*'                  }
+    example { utils.glob_pattern('/*foo')                 .should be == '/**/*'               }
+    example { utils.glob_pattern('/(ab|c)?/:foo/d/*bar')  .should be == '/{{ab,c},}/*/d/**/*' }
+    example { utils.glob_pattern('/a', '/b')              .should be == '{/a,/b}'             }
+    example { utils.glob_pattern('**/*', type: :shell)    .should be == '**/*'                }
+    example { utils.glob_pattern(/can't parse this/)      .should be == '**/*'                }
+    example { utils.glob_pattern('/foo', type: :identity) .should be == '/foo'                }
+    example { utils.glob_pattern('/fo*', type: :identity) .should be == '/fo\\*'              }
+  end
+
+  describe :glob do
+    example do
+      utils.glob(":name.txt").sort.should be == ['bar.txt', 'foo.txt']
+    end
+
+    example do
+      extensions = []
+      utils.glob("foo.:ext") { |file, params| extensions << params['ext'] }
+      extensions.sort.should be == ['rb', 'txt']
+    end
+
+    example do
+      utils.glob(":name.:ext", capture: { ext: 'rb', name: 'foo' }).should be == ['foo.rb']
+    end
+  end
+
+  describe :glob_map do
+    example do
+      utils.glob_map(':name.rb' => ':name/init.rb').should be == {
+        "bar.rb" => "bar/init.rb",
+        "foo.rb" => "foo/init.rb"
+      }
+    end
+
+    example do
+      result   = {}
+      returned = utils.glob_map(':name.rb' => ':name/init.rb') { |k, v| result[v] = k.upcase }
+      returned.sort         .should be == ["BAR.RB", "FOO.RB"]
+      result["bar/init.rb"] .should be == "BAR.RB"
+    end
+  end
+
+  describe :cp do
+    example do
+      utils.cp(':name.rb' => ':name.ruby', ':name.txt' => ':name.md')
+      File.should be_exist('foo.ruby')
+      File.should be_exist('bar.md')
+      File.should be_exist('bar.txt')
+    end
+  end
+
+  describe :cp_r do
+    example do
+      mkdir_p "foo/bar"
+      utils.cp_r('foo/:name' => :name)
+      File.should be_directory('bar')
+    end
+  end
+
+  describe :mv do
+    example do
+      utils.mv(':name.rb' => ':name.ruby', ':name.txt' => ':name.md')
+      File.should     be_exist('foo.ruby')
+      File.should     be_exist('bar.md')
+      File.should_not be_exist('bar.txt')
+    end
+  end
+
+  describe :ln do
+    example do
+      utils.ln(':name.rb' => ':name.ruby', ':name.txt' => ':name.md')
+      File.should be_exist('foo.ruby')
+      File.should be_exist('bar.md')
+      File.should be_exist('bar.txt')
+    end
+  end
+
+  describe :ln_s do
+    example do
+      utils.ln_s(':name.rb' => ':name.ruby', ':name.txt' => ':name.md')
+      File.should be_symlink('foo.ruby')
+      File.should be_symlink('bar.md')
+      File.should be_exist('bar.txt')
+    end
+  end
+
+  describe :ln_sf do
+    example do
+      utils.ln_sf(':name.rb' => ':name.txt')
+      File.should be_symlink('foo.txt')
+    end
+  end
+end