mustermann19 0.3.1

data/lib/mustermann/router/simple.rb

@@ -0,0 +1,144 @@
+require 'mustermann'
+
+module Mustermann
+  module Router
+    # Simple pattern based router that allows matching a string to a given callback.
+    #
+    # @example
+    #   require 'mustermann/router/simple'
+    #
+    #   router = Mustermann::Router::Simple.new do
+    #     on ':name/:sub' do |string, params|
+    #       params['sub']
+    #     end
+    #
+    #     on 'foo' do
+    #       "bar"
+    #     end
+    #   end
+    #
+    #   router.call("foo") # => "bar"
+    #   router.call("a/b") # => "b"
+    #   router.call("bar") # => nil
+    class Simple
+      # Default value for when no pattern matches
+      attr_accessor :default
+
+      # @example with a default value
+      #   require 'mustermann/router/simple'
+      #
+      #   router = Mustermann::Router::Simple.new(default: 42)
+      #   router.on(':name', capture: :digit) { |string| string.to_i }
+      #   router.call("23")      # => 23
+      #   router.call("example") # => 42
+      #
+      # @example block with implicit receiver
+      #   require 'mustermann/router/simple'
+      #
+      #   router = Mustermann::Router::Simple.new do
+      #     on('/foo') { 'foo' }
+      #     on('/bar') { 'bar' }
+      #   end
+      #
+      # @example block with explicit receiver
+      #   require 'mustermann/router/simple'
+      #
+      #   router = Mustermann::Router::Simple.new(type: :rails) do |r|
+      #     r.on('/foo') { 'foo' }
+      #     r.on('/bar') { 'bar' }
+      #   end
+      #
+      # @param default value to be returned if nothing matches
+      # @param options [Hash] pattern options
+      # @return [Mustermann::Router::Simple] new router instance
+      def initialize(options = {}, &block)
+        @options = options
+        @map     = []
+        @default = @options.delete(:default)
+
+        block.arity == 0 ? instance_eval(&block) : yield(self) if block
+      end
+
+      # @example
+      #   require 'mustermann/router/simple'
+      #
+      #   router = Mustermann::Router::Simple.new
+      #   router.on(':a/:b') { 42 }
+      #   router['foo/bar'] # => <#Proc:...>
+      #   router['foo_bar'] # => nil
+      #
+      # @return [#call, nil] callback for given string, if a pattern matches
+      def [](string)
+        string = string_for(string) unless string.is_a? String
+        @map.detect { |p,v| p === string }[1]
+      end
+
+      # @example
+      #   require 'mustermann/router/simple'
+      #
+      #   router = Mustermann::Router::Simple.new
+      #   router['/:name'] = proc { |string, params| params['name'] }
+      #   router.call('/foo') # => "foo"
+      #
+      # @param pattern [String, Mustermann::Pattern] matcher
+      # @param callback [#call] callback to call on match
+      # @see #on
+      def []=(pattern, callback)
+        on(pattern, call: callback)
+      end
+
+      # @example with block
+      #   require 'mustermann/router/simple'
+      #
+      #   router = Mustermann::Router::Simple.new
+      #
+      #   router.on(':a/:b') { 42 }
+      #   router.call('foo/bar') # => 42
+      #   router.call('foo_bar') # => nil
+      #
+      # @example with callback option
+      #   require 'mustermann/router/simple'
+      #
+      #   callback = proc { 42 }
+      #   router   = Mustermann::Router::Simple.new
+      #
+      #   router.on(':a/:b', call: callback)
+      #   router.call('foo/bar') # => 42
+      #   router.call('foo_bar') # => nil
+      #
+      # @param patterns [Array<String, Pattern>]
+      # @param call [#call] callback object, need to hand in block if missing
+      # @param options [Hash] pattern options
+      def on(*patterns)
+        options = patterns.last.is_a?(Hash) ? patterns.pop : {}
+        call    = options.delete(:call) || Proc.new
+        patterns.each do |pattern|
+          pattern = Mustermann.new(pattern.to_str, @options.merge(options)) if pattern.respond_to? :to_str
+          @map << [pattern, call]
+        end
+      end
+
+      # Finds the matching callback and calls `call` on it with the given input and the params.
+      # @return the callback's return value
+      def call(input)
+        @map.each do |pattern, callback|
+          catch(:pass) do
+            next unless params = pattern.params(string_for(input))
+            return invoke(callback, input, params, pattern)
+          end
+        end
+        @default
+      end
+
+      def invoke(callback, input, params, pattern)
+        callback.call(input, params)
+      end
+
+      def string_for(input)
+        input.to_str
+      end
+
+      private :invoke, :string_for
+    end
+  end
+end

data/lib/mustermann/shell.rb

@@ -0,0 +1,29 @@
+require 'mustermann/pattern'
+require 'mustermann/simple_match'
+
+module Mustermann
+  # Matches strings that are identical to the pattern.
+  #
+  # @example
+  #   Mustermann.new('/*.*', type: :shell) === '/bar' # => false
+  #
+  # @see Mustermann::Pattern
+  # @see file:README.md#shell Syntax description in the README
+  class Shell < Pattern
+    # @param (see Mustermann::Pattern#initialize)
+    # @return (see Mustermann::Pattern#initialize)
+    # @see (see Mustermann::Pattern#initialize)
+    def initialize(string, options = {})
+      @flags = File::FNM_PATHNAME | File::FNM_DOTMATCH
+      @flags |= File::FNM_EXTGLOB if defined? File::FNM_EXTGLOB
+      super(string, options)
+    end
+
+    # @param (see Mustermann::Pattern#===)
+    # @return (see Mustermann::Pattern#===)
+    # @see (see Mustermann::Pattern#===)
+    def ===(string)
+      File.fnmatch? @string, unescape(string), @flags
+    end
+  end
+end

data/lib/mustermann/simple.rb

@@ -0,0 +1,38 @@
+require 'mustermann/regexp_based'
+
+module Mustermann
+  # Sinatra 1.3 style pattern implementation.
+  #
+  # @example
+  #   Mustermann.new('/:foo', type: :simple) === '/bar' # => true
+  #
+  # @see Mustermann::Pattern
+  # @see file:README.md#simple Syntax description in the README
+  class Simple < RegexpBased
+    supported_options :greedy, :space_matches_plus
+
+    def compile(options = {})
+      greedy             = options.fetch(:greedy, true)
+      uri_decode         = options.fetch(:uri_decode, true)
+      space_matches_plus = options.fetch(:space_matches_plus, true)
+      pattern = @string.gsub(/[^\?\%\\\/\:\*\w]/) { |c| encoded(c, uri_decode, space_matches_plus) }
+      pattern.gsub!(/((:\w+)|\*)/) do |match|
+        match == "*" ? "(?<splat>.*?)" : "(?<#{$2[1..-1]}>[^/?#]+#{?? unless greedy})"
+      end
+      /\A#{Regexp.new(pattern)}\Z/
+    rescue SyntaxError, RegexpError => error
+      type = error.message["invalid group name"] ? CompileError : ParseError
+      raise type, error.message, error.backtrace
+    end
+
+    def encoded(char, uri_decode, space_matches_plus)
+      return Regexp.escape(char) unless uri_decode
+      parser  = URI::Parser.new
+      encoded = Regexp.union(parser.escape(char), parser.escape(char, /./).downcase, parser.escape(char, /./).upcase)
+      encoded = Regexp.union(encoded, encoded('+', true, true)) if space_matches_plus and char == " "
+      encoded
+    end
+
+    private :compile, :encoded
+  end
+end

data/lib/mustermann/simple_match.rb

@@ -0,0 +1,30 @@
+module Mustermann
+  # Fakes MatchData for patterns that do not support capturing.
+  # @see http://ruby-doc.org/core-2.0/MatchData.html MatchData
+  class SimpleMatch
+    # @api private
+    def initialize(string)
+      @string = string.dup
+    end
+
+    # @return [String] the string that was matched against
+    def to_s
+      @string.dup
+    end
+
+    # @return [Array<String>] empty array for imitating MatchData interface
+    def names
+      []
+    end
+
+    # @return [Array<String>] empty array for imitating MatchData interface
+    def captures
+      []
+    end
+
+    # @return [nil] imitates MatchData interface
+    def [](*args)
+      captures[*args]
+    end
+  end
+end

data/lib/mustermann/sinatra.rb

@@ -0,0 +1,22 @@
+require 'mustermann/ast/pattern'
+
+module Mustermann
+  # Sinatra 2.0 style pattern implementation.
+  #
+  # @example
+  #   Mustermann.new('/:foo') === '/bar' # => true
+  #
+  # @see Mustermann::Pattern
+  # @see file:README.md#sinatra Syntax description in the README
+  class Sinatra < AST::Pattern
+    on(nil, ??, ?)) { |c| unexpected(c) }
+    on(?*)          { |c| scan(/\w+/) ? node(:named_splat, buffer.matched) : node(:splat) }
+    on(?()          { |c| node(:group) { read unless scan(?)) } }
+    on(?:)          { |c| node(:capture) { scan(/\w+/) } }
+    on(?\\)         { |c| node(:char, expect(/./)) }
+
+    suffix ?? do |char, element|
+      node(:optional, element)
+    end
+  end
+end

data/lib/mustermann/template.rb

@@ -0,0 +1,48 @@
+require 'mustermann/ast/pattern'
+
+module Mustermann
+  # URI template pattern implementation.
+  #
+  # @example
+  #   Mustermann.new('/{foo}') === '/bar' # => true
+  #
+  # @see Mustermann::Pattern
+  # @see file:README.md#template Syntax description in the README
+  # @see http://tools.ietf.org/html/rfc6570 RFC 6570
+  class Template < AST::Pattern
+    on ?{ do |char|
+      variable = proc do
+        match  = expect(/(?<name>\w+)(?:\:(?<prefix>\d{1,4})|(?<explode>\*))?/)
+        node(:variable, match[:name], prefix: match[:prefix], explode: match[:explode])
+      end
+
+      operator   = buffer.scan(/[\+\#\.\/;\?\&\=\,\!\@\|]/)
+      expression = node(:expression, [variable[]], operator: operator) { variable[] if scan(?,) }
+      expression if expect(?})
+    end
+
+    on(?}) { |c| unexpected(c) }
+
+    # @!visibility private
+    def compile(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      @split_params = {}
+      super(*args, options.merge(:split_params => @split_params))
+    end
+
+    # @!visibility private
+    def map_param(key, value)
+      return super unless variable = @split_params[key]
+      value = value.split variable[:separator]
+      value.map! { |e| e.sub(/\A#{key}=/, '') } if variable[:parametric]
+      value.map! { |e| super(key, e) }
+    end
+
+    # @!visibility private
+    def always_array?(key)
+      @split_params.include? key
+    end
+
+    private :compile, :map_param, :always_array?
+  end
+end

data/lib/mustermann/to_pattern.rb

@@ -0,0 +1,45 @@
+require 'mustermann'
+
+module Mustermann
+  # Mixin for adding {#to_pattern} ducktyping to objects.
+  #
+  # @example
+  #   require 'mustermann/to_pattern'
+  #
+  #   class Foo
+  #     include Mustermann::ToPattern
+  #
+  #     def to_s
+  #       ":foo/:bar"
+  #     end
+  #   end
+  #
+  #   Foo.new.to_pattern # => #<Mustermann::Sinatra:":foo/:bar">
+  #
+  # By default included into {String}, {Symbol}, {Regexp} and {Mustermann::Pattern}.
+  module ToPattern
+    # Converts the object into a {Mustermann::Pattern}.
+    #
+    # @example converting a string
+    #   ":name.png".to_pattern # => #<Mustermann::Sinatra:":name.png">
+    #
+    # @example converting a string with options
+    #   "/*path".to_pattern(type: :rails) # => #<Mustermann::Rails:"/*path">
+    #
+    # @example converting a regexp
+    #   /.*/.to_pattern # => #<Mustermann::Regular:".*">
+    #
+    # @example converting a pattern
+    #  Mustermann.new("foo").to_pattern # => #<Mustermann::Sinatra:"foo">
+    #
+    # @param [Hash] options The options hash.
+    # @return [Mustermann::Pattern] pattern corresponding to object.
+    def to_pattern(options = {})
+      Mustermann.new(self, options)
+    end
+
+    append_features String
+    append_features Regexp
+    append_features Mustermann::Pattern
+  end
+end

data/lib/mustermann/version.rb

@@ -0,0 +1,3 @@
+module Mustermann
+  VERSION ||= '0.3.1'
+end

data/mustermann.gemspec

@@ -0,0 +1,31 @@
+$:.unshift File.expand_path("../lib", __FILE__)
+require "mustermann/version"
+
+Gem::Specification.new do |s|
+  s.name                  = "mustermann19"
+  s.version               = Mustermann::VERSION
+  s.authors               = ["Konstantin Haase", "namusyaka"]
+  s.email                 = "namusyaka@gmail.com"
+  s.homepage              = "https://github.com/namusyaka/mustermann"
+  s.summary               = %q{use patterns like regular expressions}
+  s.description           = %q{library implementing patterns that behave like regular expressions for use in Ruby 1.9}
+  s.license               = 'MIT'
+  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.extra_rdoc_files      = %w[README.md internals.md]
+  s.require_path          = 'lib'
+  s.required_ruby_version = '>= 1.9.2'
+
+  s.add_dependency 'enumerable-lazy' if RUBY_VERSION < '2.0.0'
+  s.add_development_dependency 'rspec' #, '~> 2.14'
+  s.add_development_dependency 'rspec-its'
+  s.add_development_dependency 'addressable'
+  s.add_development_dependency 'sinatra', '~> 1.4'
+  s.add_development_dependency 'rack-test'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'yard'
+  #s.add_development_dependency 'redcarpet'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'coveralls'
+end

data/spec/expander_spec.rb

@@ -0,0 +1,105 @@
+require 'support'
+require 'mustermann/expander'
+
+describe Mustermann::Expander do
+  it 'expands a pattern' do
+    expander = Mustermann::Expander.new("/:foo.jpg")
+    expander.expand(foo: 42).should be == "/42.jpg"
+  end
+
+  it 'expands multiple patterns' do
+    expander = Mustermann::Expander.new << "/:foo.:ext" << "/:foo"
+    expander.expand(foo: 42, ext: 'jpg').should be == "/42.jpg"
+    expander.expand(foo: 23).should be == "/23"
+  end
+
+  it 'supports setting pattern options' do
+    expander = Mustermann::Expander.new(type: :rails) << "/:foo(.:ext)" << "/:bar"
+    expander.expand(foo: 42, ext: 'jpg').should be == "/42.jpg"
+    expander.expand(foo: 42).should be == "/42"
+  end
+
+  it 'supports combining different pattern styles' do
+    expander = Mustermann::Expander.new << Mustermann.new("/:foo(.:ext)", type: :rails) << Mustermann.new("/:bar", type: :sinatra)
+    expander.expand(foo: 'pony', ext: 'jpg').should be == '/pony.jpg'
+    expander.expand(bar: 23).should be == "/23"
+  end
+
+  it 'ignores nil values' do
+    expander = Mustermann::Expander.new << Mustermann.new("/:foo(.:ext)?")
+    expander.expand(foo: 'pony', ext: nil).should be == '/pony'
+  end
+
+  describe :additional_values do
+    context "illegal value" do
+      example { expect { Mustermann::Expander.new(additional_values: :foo) }.to raise_error(ArgumentError) }
+      example { expect { Mustermann::Expander.new('/').expand(:foo, a: 10) }.to raise_error(ArgumentError) }
+    end
+
+    context :raise do
+      subject(:expander) { Mustermann::Expander.new('/:a', additional_values: :raise) }
+      example { expander.expand(a: ?a).should be == '/a' }
+      example { expect { expander.expand(a: ?a, b: ?b) }.to raise_error(Mustermann::ExpandError) }
+      example { expect { expander.expand(b: ?b) }.to raise_error(Mustermann::ExpandError) }
+    end
+
+    context :ignore do
+      subject(:expander) { Mustermann::Expander.new('/:a', additional_values: :ignore) }
+      example { expander.expand(a: ?a).should be == '/a' }
+      example { expander.expand(a: ?a, b: ?b).should be == '/a' }
+      example { expect { expander.expand(b: ?b) }.to raise_error(Mustermann::ExpandError) }
+    end
+
+    context :append do
+      subject(:expander) { Mustermann::Expander.new('/:a', additional_values: :append) }
+      example { expander.expand(a: ?a).should be == '/a' }
+      example { expander.expand(a: ?a, b: ?b).should be == '/a?b=b' }
+      example { expect { expander.expand(b: ?b) }.to raise_error(Mustermann::ExpandError) }
+    end
+  end
+
+  describe :cast do
+    subject(:expander) { Mustermann::Expander.new('/:a(/:b)?') }
+
+    example { expander.cast          { "FOOBAR"          }.expand(a: "foo")           .should be == "/FOOBAR"   }
+    example { expander.cast          { |v| v.upcase      }.expand(a: "foo")           .should be == "/FOO"      }
+    example { expander.cast          { |v| v.upcase      }.expand(a: "foo", b: "bar") .should be == "/FOO/BAR"  }
+    example { expander.cast(:a)      { |v| v.upcase      }.expand(a: "foo", b: "bar") .should be == "/FOO/bar"  }
+    example { expander.cast(:a, :b)  { |v| v.upcase      }.expand(a: "foo", b: "bar") .should be == "/FOO/BAR"  }
+    example { expander.cast(Integer) { |k,v| "#{k}_#{v}" }.expand(a: "foo", b: 42)    .should be == "/foo/b_42" }
+
+    example do
+      expander.cast(:a) { |v| v.upcase   }
+      expander.cast(:b) { |v| v.downcase }
+      expander.expand(a: "fOo", b: "bAr").should be == "/FOO/bar"
+    end
+  end
+
+  describe :== do
+    example { Mustermann::Expander.new('/foo')               .should     be == Mustermann::Expander.new('/foo') }
+    example { Mustermann::Expander.new('/foo')               .should_not be == Mustermann::Expander.new('/bar') }
+    example { Mustermann::Expander.new('/foo', type: :rails) .should     be == Mustermann::Expander.new('/foo', type: :rails) }
+    example { Mustermann::Expander.new('/foo', type: :rails) .should_not be == Mustermann::Expander.new('/foo', type: :sinatra) }
+  end
+
+  describe :hash do
+    example { Mustermann::Expander.new('/foo')               .hash.should     be == Mustermann::Expander.new('/foo').hash }
+    example { Mustermann::Expander.new('/foo')               .hash.should_not be == Mustermann::Expander.new('/bar').hash }
+    example { Mustermann::Expander.new('/foo', type: :rails) .hash.should     be == Mustermann::Expander.new('/foo', type: :rails).hash }
+    example { Mustermann::Expander.new('/foo', type: :rails) .hash.should_not be == Mustermann::Expander.new('/foo', type: :sinatra).hash }
+  end
+
+  describe :eql? do
+    example { Mustermann::Expander.new('/foo')               .should     be_eql Mustermann::Expander.new('/foo') }
+    example { Mustermann::Expander.new('/foo')               .should_not be_eql Mustermann::Expander.new('/bar') }
+    example { Mustermann::Expander.new('/foo', type: :rails) .should     be_eql Mustermann::Expander.new('/foo', type: :rails) }
+    example { Mustermann::Expander.new('/foo', type: :rails) .should_not be_eql Mustermann::Expander.new('/foo', type: :sinatra) }
+  end
+
+  describe :equal? do
+    example { Mustermann::Expander.new('/foo')               .should_not be_equal Mustermann::Expander.new('/foo') }
+    example { Mustermann::Expander.new('/foo')               .should_not be_equal Mustermann::Expander.new('/bar') }
+    example { Mustermann::Expander.new('/foo', type: :rails) .should_not be_equal Mustermann::Expander.new('/foo', type: :rails) }
+    example { Mustermann::Expander.new('/foo', type: :rails) .should_not be_equal Mustermann::Expander.new('/foo', type: :sinatra) }
+  end
+end