mustermann19 0.3.1 → 0.3.1.1

data/spec/string_scanner_spec.rb

@@ -0,0 +1,271 @@
+require 'support'
+require 'mustermann/string_scanner'
+
+describe Mustermann::StringScanner do
+  include Support::ScanMatcher
+
+  subject(:scanner) { Mustermann::StringScanner.new(example_string) }
+  let(:example_string) { "foo bar" }
+
+  describe :scan do
+    it { should scan("foo")     }
+    it { should scan(/foo/)     }
+    it { should scan(:name)     }
+    it { should scan(":name")   }
+
+    it { should_not scan(" ")   }
+    it { should_not scan("bar") }
+
+    example do
+      should scan("foo")
+      should scan(" ")
+      should scan("bar")
+    end
+
+    example do
+      scanner.position = 4
+      should scan("bar")
+    end
+
+    example do
+      should scan("foo")
+      scanner.reset
+      should scan("foo")
+    end
+  end
+
+  describe :check do
+    it { should check("foo")     }
+    it { should check(/foo/)     }
+    it { should check(:name)     }
+    it { should check(":name")   }
+
+    it { should_not check(" ")   }
+    it { should_not check("bar") }
+
+    example do
+      should     check("foo")
+      should_not check(" ")
+      should_not check("bar")
+      should     check("foo")
+    end
+
+    example do
+      scanner.position = 4
+      should check("bar")
+    end
+  end
+
+  describe :scan_until do
+    it { should scan_until("foo")     }
+    it { should scan_until(":name")   }
+    it { should scan_until(" ")       }
+    it { should scan_until("bar")     }
+    it { should_not scan_until("baz") }
+
+    example do
+      should scan_until(" ")
+      should check("bar")
+    end
+
+    example do
+      should scan_until(" ")
+      scanner.reset
+      should scan("foo")
+    end
+  end
+
+  describe :check_until do
+    it { should check_until("foo")     }
+    it { should check_until(":name")   }
+    it { should check_until(" ")       }
+    it { should check_until("bar")     }
+    it { should_not check_until("baz") }
+
+    example do
+      should check_until(" ")
+      should_not check("bar")
+    end
+  end
+
+  describe :getch do
+    example { scanner.getch.should be == "f" }
+
+    example do
+      scanner.scan("foo")
+      scanner.getch.should be == " "
+      should scan("bar")
+    end
+
+    example do
+      scanner.getch
+      scanner.reset
+      should scan("foo")
+    end
+  end
+
+  describe :<< do
+    example do
+      should_not scan_until("baz")
+      scanner << " baz"
+      scanner.to_s.should be == "foo bar baz"
+      should scan_until("baz")
+    end
+  end
+
+  describe :eos? do
+    it { should_not be_eos }
+    example do
+      scanner.position = 7
+      should be_eos
+    end
+  end
+
+  describe :beginning_of_line? do
+    let(:example_string) { "foo\nbar" }
+    it { should be_beginning_of_line }
+
+    example do
+      scanner.position = 2
+      should_not be_beginning_of_line
+    end
+
+    example do
+      scanner.position = 3
+      should_not be_beginning_of_line
+    end
+
+    example do
+      scanner.position = 4
+      should be_beginning_of_line
+    end
+  end
+
+  describe :rest do
+    example { scanner.rest.should be == "foo bar" }
+    example do
+      scanner.position = 4
+      scanner.rest.should be == "bar"
+    end
+  end
+
+  describe :rest_size do
+    example { scanner.rest_size.should be == 7 }
+    example do
+      scanner.position = 4
+      scanner.rest_size.should be == 3
+    end
+  end
+
+  describe :peek do
+    example { scanner.peek(3).should be == "foo" }
+
+    example do
+      scanner.peek(3).should be == "foo"
+      scanner.peek(3).should be == "foo"
+    end
+
+    example do
+      scanner.position = 4
+      scanner.peek(3).should be == "bar"
+    end
+  end
+
+  describe :inspect do
+    example { scanner.inspect.should be == '#<Mustermann::StringScanner 0/7 @ "foo bar">' }
+    example do
+      scanner.position = 4
+      scanner.inspect.should be == '#<Mustermann::StringScanner 4/7 @ "foo bar">'
+    end
+  end
+
+  describe :[] do
+    example do
+      should scan(:name)
+      scanner['name'].should be == "foo bar"
+    end
+
+    example do
+      should scan(:name, capture: /\S+/)
+      scanner['name'].should be == "foo"
+      should scan(" :name", capture: /\S+/)
+      scanner['name'].should be == "bar"
+    end
+
+    example do
+      should scan(":a",  capture: /\S+/)
+      should scan(" :b", capture: /\S+/)
+      scanner['a'].should be == "foo"
+      scanner['b'].should be == "bar"
+    end
+
+    example do
+      a = scanner.scan(":a",  capture: /\S+/)
+      b = scanner.scan(" :b", capture: /\S+/)
+      a.params['a'].should be == 'foo'
+      b.params['b'].should be == 'bar'
+      a.params['b'].should be_nil
+      b.params['a'].should be_nil
+    end
+
+    example do
+      result = scanner.check(":a",  capture: /\S+/)
+      result.params['a'].should be == 'foo'
+      scanner['a'].should be_nil
+    end
+
+    example do
+      should scan(:name)
+      scanner.reset
+      scanner['name'].should be_nil
+    end
+  end
+
+  describe :unscan do
+    example do
+      should scan(:name, capture: /\S+/)
+      scanner['name'].should be == "foo"
+      should scan(" :name", capture: /\S+/)
+      scanner['name'].should be == "bar"
+      scanner.unscan
+      scanner['name'].should be == "foo"
+      scanner.rest.should be == " bar"
+    end
+
+    example do
+      should scan_until(" ")
+      scanner.unscan
+      scanner.rest.should be == "foo bar"
+    end
+
+    example do
+      expect { scanner.unscan }.to raise_error(Mustermann::StringScanner::ScanError,
+        'unscan failed: previous match record not exist')
+    end
+  end
+
+  describe :terminate do
+    example do
+      scanner.terminate
+      scanner.should be_eos
+    end
+  end
+
+  describe :to_h do
+    example { scanner.to_h.should be == {} }
+    example do
+    end
+  end
+
+  describe :to_s do
+    example { scanner.to_s.should be == "foo bar" }
+  end
+
+  describe :clear_cache do
+    example do
+      scanner.scan("foo")
+      Mustermann::StringScanner.clear_cache
+      Mustermann::StringScanner.cache_size.should be == 0
+    end
+  end
+end

data/spec/support/expand_matcher.rb

@@ -1,8 +1,9 @@
-RSpec::Matchers.define :expand do |values = {}|
+RSpec::Matchers.define :expand do |behavior = nil, values = {}|
+  values, behavior = behavior, nil if behavior.kind_of?(Hash)
   match do |pattern|
     @string  ||= nil
     begin
-      expanded = pattern.expand(values)
+      expanded = pattern.expand(behavior, values)
     rescue Exception
       false
     else
@@ -15,8 +16,9 @@ RSpec::Matchers.define :expand do |values = {}|
   end
 
   failure_message do |pattern|
-    message = "expected %p to be expandable with %p" % [pattern, values]
-    expanded = pattern.expand(values)
+    message =  "expected %p to be expandable with %p" % [pattern, values]
+    message << " (%p behavior)" % behavior if behavior
+    expanded = pattern.expand(behavior, values)
     message << " and result in %p, but got %p" % [@string, expanded] if @string
     message
   end
@@ -24,4 +26,4 @@ RSpec::Matchers.define :expand do |values = {}|
   failure_message_when_negated do |pattern|
     "expected %p not to be expandable with %p" % [pattern, values]
   end
-end
+end

data/spec/support/generate_template_matcher.rb

@@ -0,0 +1,27 @@
+RSpec::Matchers.define :generate_template do |template|
+  match { |pattern| pattern.to_templates.include? template }
+
+  failure_message do |pattern|
+    "expected %p to generate template %p, but only generated %s" % [
+      pattern, template, pattern.to_templates.map(&:inspect).join(', ')
+    ]
+  end
+
+  failure_message_when_negated do |pattern|
+    "expected %p not to generate template %p" % [ pattern, template ]
+  end
+end
+
+RSpec::Matchers.define :generate_templates do |*templates|
+  match { |pattern| pattern.to_templates.sort == templates.sort }
+
+  failure_message do |pattern|
+    "expected %p to generate templates %p, but generated %p" % [
+      pattern, templates.sort, pattern.to_templates.sort
+    ]
+  end
+
+  failure_message_when_negated do |pattern|
+    "expected %p not to generate templates %p" % [ pattern, templates ]
+  end
+end

data/spec/support/pattern.rb

@@ -2,6 +2,8 @@ require 'timeout'
 
 module Support
   module Pattern
+    extend RSpec::Matchers::DSL
+
     def pattern(pattern, options = nil, &block)
       description   = "pattern %p" % pattern
 
@@ -17,6 +19,7 @@ module Support
         its(:to_s) { should be == pattern }
         its(:inspect) { should be == "#<#{described_class}:#{pattern.inspect}>" }
         its(:names) { should be_an(Array) }
+        its(:to_templates) { should be == [pattern] } if described_class.name == "Mustermann::Template"
 
         example 'string should be immune to external change' do
           subject.to_s.replace "NOT THE PATTERN"

data/spec/support/scan_matcher.rb

@@ -0,0 +1,63 @@
+module Support
+  module ScanMatcher
+    extend RSpec::Matchers::DSL
+
+    def scan(pattern, options = {})
+      give_scan_result(:scan, pattern, options)
+    end
+
+    def check(pattern, options = {})
+      give_scan_result(:check, pattern, options)
+    end
+
+    def scan_until(pattern, options = {})
+      give_scan_result(:scan_until, pattern, options)
+    end
+
+    def check_until(pattern, options = {})
+      give_scan_result(:check_until, pattern, options)
+    end
+
+    matcher :give_scan_result do |method_name, pattern, options = {}|
+      def result_expectations
+        @result_expectations ||= []
+      end
+
+      def expect_result(description, expected, &block)
+        result_expectations << Proc.new do |result|
+          if !block.call(result)
+            "expected %p to %s %p matching %s" % [ result.scanner, method_name, pattern, description ]
+          end
+        end
+      end
+
+      match do |scanner|
+        scanned = scanner.public_send(method_name, pattern, options)
+        scanned and result_expectations.all? { |e| !e.call(scanned) }
+      end
+
+      chain(:matching_substring) do |substring|
+        expected_result("the substring %p" % substring) { |r| r.to_s == substring }
+      end
+
+      chain(:matching_length) do |length|
+        expected_result("%d characters" % length) { |r| r.length == length }
+      end
+
+      chain(:matching_params) do |params|
+        expected_result("with params %p" % [params]) { |r| r.params == params }
+      end
+
+      failure_message do |scanner|
+        if scanned = scanner.public_send(method_name, pattern, options = {})
+          message  = result_expectations.inject(nil) { |m,e| m || e.call(scanned) }
+        end
+        message || "expected %p to %s %p" % [ scanner, method_name, pattern ]
+      end
+
+      failure_message_when_negated do |scanner|
+        "expected %p not to %s %p" % [ scanner, method_name, pattern ]
+      end
+    end
+  end
+end

data/spec/support.rb

@@ -1,5 +1,6 @@
 require 'support/env'
-require 'support/coverage'
 require 'support/expand_matcher'
+require 'support/generate_template_matcher'
 require 'support/match_matcher'
 require 'support/pattern'
+require 'support/scan_matcher'

data/spec/template_spec.rb

@@ -8,6 +8,9 @@ describe Mustermann::Template do
   pattern '' do
     it { should     match('')  }
     it { should_not match('/') }
+
+    it { should respond_to(:expand)       }
+    it { should respond_to(:to_templates) }
   end
 
   pattern '/' do
@@ -812,4 +815,23 @@ describe Mustermann::Template do
         to raise_error(Mustermann::ParseError, 'unexpected end of string while parsing "foo{bar"')
     end
   end
+
+  context "peeking" do
+    subject(:pattern) { Mustermann::Template.new("{name}bar") }
+
+    describe :peek_size do
+      example { pattern.peek_size("foo%20bar/blah") .should be == "foo%20bar".size }
+      example { pattern.peek_size("/foo bar")       .should be_nil }
+    end
+
+    describe :peek_match do
+      example { pattern.peek_match("foo%20bar/blah") .to_s .should be == "foo%20bar" }
+      example { pattern.peek_match("/foo bar")             .should be_nil }
+    end
+
+    describe :peek_params do
+      example { pattern.peek_params("foo%20bar/blah") .should be == [{"name" => "foo "}, "foo%20bar".size] }
+      example { pattern.peek_params("/foo bar")       .should be_nil }
+    end
+  end
 end

data/spec/to_pattern_spec.rb

@@ -1,5 +1,6 @@
 require 'support'
 require 'mustermann/to_pattern'
+require 'delegate'
 
 describe Mustermann::ToPattern do
   context String do
@@ -12,9 +13,57 @@ describe Mustermann::ToPattern do
     example { //.to_pattern(type: :rails) .should be_a(Mustermann::Regular) }
   end
 
+  context Symbol do
+    example { :foo.to_pattern               .should be_a(Mustermann::Sinatra) }
+    example { :foo.to_pattern(type: :rails) .should be_a(Mustermann::Sinatra) }
+  end
+
+  context Array do
+    example { [:foo, :bar].to_pattern               .should be_a(Mustermann::Composite) }
+    example { [:foo, :bar].to_pattern(type: :rails) .should be_a(Mustermann::Composite) }
+  end
+
   context Mustermann::Pattern do
     subject(:pattern) { Mustermann.new('') }
     example { pattern.to_pattern.should be == pattern }
     example { pattern.to_pattern(type: :rails).should be_a(Mustermann::Sinatra) }
   end
+
+  context 'custom class' do
+    let(:example_class) do
+      Class.new do
+        include Mustermann::ToPattern
+        def to_s
+          ":foo/:bar"
+        end
+      end
+    end
+
+    example { example_class.new.to_pattern                    .should be_a(Mustermann::Sinatra) }
+    example { example_class.new.to_pattern(type: :rails)      .should be_a(Mustermann::Rails)   }
+    example { Mustermann.new(example_class.new)               .should be_a(Mustermann::Sinatra) }
+    example { Mustermann.new(example_class.new, type: :rails) .should be_a(Mustermann::Rails)   }
+  end
+
+  context 'primitive delegate' do
+    let(:example_class) do
+      Class.new(DelegateClass(Array)) do
+        include Mustermann::ToPattern
+      end
+    end
+
+    example { example_class.new([:foo, :bar]).to_pattern               .should be_a(Mustermann::Composite) }
+    example { example_class.new([:foo, :bar]).to_pattern(type: :rails) .should be_a(Mustermann::Composite) }
+  end
+
+  context 'primitive subclass' do
+    let(:example_class) do
+      Class.new(Array) do
+        include Mustermann::ToPattern
+      end
+    end
+
+    example { example_class.new([:foo, :bar]).to_pattern               .should be_a(Mustermann::Composite) }
+    example { example_class.new([:foo, :bar]).to_pattern(type: :rails) .should be_a(Mustermann::Composite) }
+  end
 end