mustermann 1.0.2.rc1 → 1.0.2.rc2

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

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

@@ -1,19 +0,0 @@
-$:.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

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

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

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