mustermann-contrib 3.0.4 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c0c40b0826ffa45cc63ae438017ecee316750c370d6bfeac1470c3c9f00fbbd
-  data.tar.gz: 1312ab31f470e624148c3bb26bc020db1723940b161b85c080a05cc8e1b2b787
+  metadata.gz: d3990aa843c8c57b75fc5e7a5a8fa0b0d56f6f46c6a8e4ad8a5b408066b3ee96
+  data.tar.gz: 82b5f3729b4ae440bb94be9117558bd83dbead5b07599254dc3255104cab3f5e
 SHA512:
-  metadata.gz: 75a1d17dfba9808fb7b2c2c5cfeb2ef76622f09aba6d90dc373b6f712cd4e9493624713ec42113d529dffb5dd363d4e54ddf6ad8990cfccacc2503ed639aec6b
-  data.tar.gz: 845a5141b2260ed0b6182bcf98ebd2c7279a32dbee50fe916301e20477815e8c793721009af74440577eedfa40a37ac61d6227551840580fec7dcc8ea820a593
+  metadata.gz: bd18842741789080329166170db2b904af298f2bd80e797e259bb02740aab45ea313f3009f0570079db11cf0d3728b38fb8833c94004b52f43123a27835a3035
+  data.tar.gz: 7d7a909d1970370e86097380bbd0ca47c04e2d34ef2e41ed10d2da1ce60a21976e3b7a814b2d549cd4cbdcee6f6ba3398ba1922a524c7e8d87b0d88336c1c8b3

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mustermann-contrib
 version: !ruby/object:Gem::Version
-  version: 3.0.4
+  version: 3.1.0
 platform: ruby
 authors:
 - Konstantin Haase
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.0.4
+        version: 3.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.0.4
+        version: 3.1.0
 - !ruby/object:Gem::Dependency
   name: hansi
   requirement: !ruby/object:Gem::Requirement
@@ -46,9 +46,6 @@ extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
-- examples/highlighting.rb
-- highlighting.png
-- irb.png
 - lib/mustermann/cake.rb
 - lib/mustermann/express.rb
 - lib/mustermann/file_utils.rb
@@ -56,14 +53,12 @@ files:
 - lib/mustermann/fileutils.rb
 - lib/mustermann/flask.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
@@ -80,22 +75,6 @@ files:
 - 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/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
@@ -107,14 +86,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.9
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Collection of extensions for Mustermann
 test_files: []

data/examples/highlighting.rb

@@ -1,35 +0,0 @@
-require 'bundler/setup'
-require 'mustermann/visualizer'
-
-Hansi.mode = ARGV[0].to_i if ARGV.any?
-
-def self.example(type, *patterns)
-  print Hansi.render(:bold, "  #{type}: ".ljust(14))
-  patterns.each do |pattern|
-    pattern     = Mustermann.new(pattern, type: type)
-    space_after = pattern.to_s.size > 24 ? " " : " " * (25 - pattern.to_s.size)
-    highlight   = Mustermann::Visualizer.highlight(pattern, inspect: true)
-    print highlight.to_ansi + space_after
-  end
-  puts
-end
-
-puts
-example(:cake,     '/:prefix/**')
-example(:express,  '/:prefix+/:id(\d+)', '/:page/:slug+')
-example(:flask,    '/<prefix>/<int:id>', '/user/<int(min=0):id>')
-example(:identity, '/image.png')
-example(:pyramid,  '/{prefix:.*}/{id}',  '/{page}/*slug')
-example(:rails,    '/:slug(.:ext)')
-example(:regexp,   '/(?<slug>[^/]+)',    '/(?:page|user)/(\d+)')
-example(:shell,    '/**/*',              '/\{a,b\}/{a,b}')
-example(:simple,   '/:page/*slug')
-example(:sinatra,  '/:page/*slug',         '/users/{id}?')
-example(:template, '/{+pre}/{page}{?q,p}', '/users/{id}?')
-puts
-
-example(:composition)
-composite = Mustermann.new("/{a}", "/{b}/{c}")
-puts "  " + composite.to_ansi
-puts "  " + (Mustermann.new("/") ^ composite).to_ansi
-puts

data/lib/mustermann/rails.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-require 'mustermann'
-require 'mustermann/ast/pattern'
-require 'mustermann/versions'
-
-module Mustermann
-  # Rails style pattern implementation.
-  #
-  # @example
-  #   Mustermann.new('/:foo', type: :rails) === '/bar' # => true
-  #
-  # @see Mustermann::Pattern
-  # @see file:README.md#rails Syntax description in the README
-  class Rails < AST::Pattern
-    extend Versions
-    register :rails
-
-    # first parser, no optional parts
-    version('2.3') do
-      on(nil) { |c| unexpected(c) }
-      on(?*)  { |c| node(:named_splat) { scan(/\w+/) } }
-      on(?:)  { |c| node(:capture) { scan(/\w+/) } }
-    end
-
-    # rack-mount
-    version('3.0', '3.1') do
-      on(?))  { |c| unexpected(c) }
-      on(?()  { |c| node(:optional, node(:group) { read unless scan(?)) }) }
-      on(?\\) { |c| node(:char, expect(/./)) }
-    end
-
-    # stand-alone journey
-    version('3.2') do
-      on(?|)  { |c| raise ParseError, "the implementation of | is broken in ActionDispatch, cannot compile compatible pattern" }
-      on(?\\) { |c| node(:char, c) }
-    end
-
-    # embedded journey, broken (ignored) escapes
-    version('4.0', '4.1') { on(?\\) { |c| read } }
-
-    # escapes got fixed in 4.2
-    version('4.2') { on(?\\) { |c| node(:char, expect(/./)) } }
-
-    # Rails 5.0 fixes |
-    version('5.0') { on(?|) { |c| node(:or) }}
-  end
-end

data/lib/mustermann/versions.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-module Mustermann
-  # Mixin that adds support for multiple versions of the same type.
-  # @see Mustermann::Rails
-  # @!visibility private
-  module Versions
-    # Checks if class has mulitple versions available and picks one that matches the version option.
-    # @!visibility private
-    def new(*args, version: nil, **options)
-      return super(*args, **options) unless versions.any?
-      self[version].new(*args, **options)
-    end
-
-    # @return [Hash] version to subclass mapping.
-    # @!visibility private
-    def versions
-      @versions ||= {}
-    end
-
-    # Defines a new version.
-    # @!visibility private
-    def version(*list, inherit_from: nil, &block)
-      superclass = self[inherit_from] || self
-      subclass   = Class.new(superclass, &block)
-      list.each { |v| versions[v] = subclass }
-    end
-
-    # Resolve a subclass for a given version string.
-    # @!visibility private
-    def [](version)
-      return versions.values.last unless version
-      detected = versions.detect { |v,_| version.start_with?(v) }
-      raise ArgumentError, 'unsupported version %p' % version unless detected
-      detected.last
-    end
-
-    # @!visibility private
-    def name
-      super || superclass.name
-    end
-
-    # @!visibility private
-    def inspect
-      name
-    end
-  end
-end

data/mustermann-contrib.gemspec

@@ -1,18 +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 Mustermann}
-  s.license               = 'MIT'
-  s.required_ruby_version = '>= 2.6.0'
-  s.files                 = `git ls-files`.split("\n")
-  s.test_files            = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.add_dependency 'mustermann', Mustermann::VERSION
-  s.add_dependency 'hansi', '~> 0.2.0'
-end

data/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/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/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