mustermann 1.0.1 → 1.0.2.rc1

data/{lib → mustermann/lib}/mustermann/concat.rb

@@ -10,8 +10,19 @@ module Mustermann
       # @!visibility private
       def +(other)
         other &&= Mustermann.new(other, type: :identity, **options)
-        return super unless native = native_concat(other)
-        self.class.new(native, **options)
+        if (patterns = look_ahead(other)) && !patterns.empty?
+          concat = (self + patterns.inject(:+))
+          concat + other.patterns.slice(patterns.length..-1).inject(:+)
+        else
+          return super unless native = native_concat(other)
+          self.class.new(native, **options)
+        end
+      end
+
+      # @!visibility private
+      def look_ahead(other)
+        return unless other.is_a?(Concat)
+        other.patterns.take_while(&method(:native_concat?))
       end
 
       # @!visibility private

data/{lib → mustermann/lib}/mustermann/pattern.rb

@@ -226,7 +226,7 @@ module Mustermann
     #     warn "does not support expanding"
     #   end
     #
-    # Expanding is supported by almost all patterns (notable execptions are {Mustermann::Shell},
+    # Expanding is supported by almost all patterns (notable exceptions are {Mustermann::Shell},
     # {Mustermann::Regular} and {Mustermann::Simple}).
     #
     # Union {Mustermann::Composite} patterns (with the | operator) support expanding if all

data/{lib → mustermann/lib}/mustermann/sinatra.rb

@@ -42,7 +42,7 @@ module Mustermann
     # If a string is supplied, it is treated as a fully escaped Sinatra pattern.
     #
     # If the other pattern is also a Sintara pattern, it might join the two to a third
-    # sinatra pattern instead of generating a composite for efficency reasons.
+    # sinatra pattern instead of generating a composite for efficiency reasons.
     #
     # This only happens if the sinatra pattern behaves exactly the same as a composite
     # would in regards to matching, parsing, expanding and template generation.

data/{lib → mustermann/lib}/mustermann/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Mustermann
-  VERSION ||= '1.0.1'
+  VERSION ||= '1.0.2.rc1'
 end

data/{spec → mustermann/spec}/concat_spec.rb

@@ -57,6 +57,18 @@ describe Mustermann::Concat do
       its(:class) { should be == Mustermann::Concat }
       its(:to_s)  { should be == '(sinatra:"/:foo" + rails:"/:bar" + sinatra:"/:baz")' }
     end
+
+    context "sinatra + (sinatra + regular)" do
+      subject(:pattern) { Mustermann.new("/foo") + (Mustermann.new("/bar") + Mustermann.new(/baz/)) }
+      its(:class) { should be == Mustermann::Concat }
+      its(:to_s)  { should be == '(sinatra:"/foo/bar" + regular:"baz")' }
+    end
+
+    context "sinatra + (sinatra + rails (different options) + sinatra)" do
+      subject(:pattern) { Mustermann.new("/foo") + (Mustermann.new("/bar") + Mustermann.new("/baz", type: :rails, uri_decode: false) + Mustermann.new("/boo")) }
+      its(:class) { should be == Mustermann::Concat }
+      its(:to_s)  { should be == '(sinatra:"/foo/bar" + rails:"/baz" + sinatra:"/boo")' }
+    end
   end
 
   subject(:pattern) { Mustermann::Concat.new("/:foo", "/:bar") }

data/support/lib/support.rb

@@ -0,0 +1,7 @@
+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/support/lib/support/coverage.rb

@@ -0,0 +1,23 @@
+require 'simplecov'
+require 'coveralls'
+require 'support/projects'
+
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
+  [
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ]
+)
+
+SimpleCov.start do
+  project_name 'mustermann'
+  minimum_coverage 100
+  coverage_dir '.coverage'
+
+  add_filter "/spec/"
+  add_filter "/support/"
+
+  Support::Projects.each do |project|
+    add_group project.sub('mustermann-', ''), "/#{project}/lib"
+  end
+end

data/support/lib/support/env.rb

@@ -0,0 +1,19 @@
+if RUBY_VERSION < '2.1.0'
+  $stderr.puts "needs Ruby 2.1.0, you're running #{RUBY_VERSION}"
+  exit 1
+end
+
+RUBY_ENGINE ||= 'ruby'
+ENV['RACK_ENV'] = 'test'
+
+require 'tool/warning_filter'
+$-w = true
+
+require 'rspec'
+require 'rspec/its'
+
+RSpec.configure do |config|
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+end

data/support/lib/support/expand_matcher.rb

@@ -0,0 +1,28 @@
+RSpec::Matchers.define :expand do |behavior = nil, **values|
+  match do |pattern|
+    @string  ||= nil
+    begin
+      expanded = pattern.expand(behavior, values)
+    rescue Exception
+      false
+    else
+      @string ? @string == expanded : !!expanded
+    end
+  end
+
+  chain :to do |string|
+    @string = string
+  end
+
+  failure_message do |pattern|
+    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
+
+  failure_message_when_negated do |pattern|
+    "expected %p not to be expandable with %p" % [pattern, values]
+  end
+end

data/support/lib/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/support/lib/support/match_matcher.rb

@@ -0,0 +1,39 @@
+RSpec::Matchers.define :match do |expected|
+  match do |actual|
+    @captures ||= false
+    match = actual.match(expected)
+    match &&= @captures.all? { |k, v| match[k] == v } if @captures
+    match
+  end
+
+  chain :capturing do |captures|
+    @captures = captures
+  end
+
+  failure_message do |actual|
+    require 'pp'
+    match = actual.match(expected)
+    if match
+      key, value = @captures.detect { |k, v| match[k] != v }
+      message = "expected %p to capture %p as %p when matching %p, but got %p\n\nRegular Expression:\n%p" % [
+        actual.to_s, key, value, expected, match[key], actual.regexp
+      ]
+
+      if actual.respond_to? :to_ast
+        require 'mustermann/visualizer/tree_renderer'
+        tree = Mustermann::Visualizer::TreeRenderer.render(actual)
+        message << "\n\nAST:\n#{tree}"
+      end
+
+      message
+    else
+      "expected %p to match %p" % [ actual, expected ]
+    end
+  end
+
+  failure_message_when_negated do |actual|
+    "expected %p not to match %p" % [
+      actual.to_s, expected
+    ]
+  end
+end

data/support/lib/support/pattern.rb

@@ -0,0 +1,42 @@
+require 'timeout'
+
+module Support
+  module Pattern
+    extend RSpec::Matchers::DSL
+
+    def pattern(pattern, options = nil, &block)
+      description   = "pattern %p" % pattern
+
+      if options
+        description << " with options %p" % [options]
+        instance = subject_for(pattern, options)
+      else
+        instance = subject_for(pattern)
+      end
+
+      context description do
+        subject(:pattern, &instance)
+        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"
+          subject.to_s.should be == pattern
+        end
+
+        instance_eval(&block)
+      end
+    end
+
+    def subject_for(pattern, *args)
+      instance = Timeout.timeout(1) { described_class.new(pattern, *args) }
+      proc { instance }
+    rescue Timeout::Error => error
+      proc { raise Timeout::Error, "could not compile #{pattern.inspect} in time", error.backtrace }
+    rescue Exception => error
+      proc { raise error }
+    end
+  end
+end

data/support/lib/support/projects.rb

@@ -0,0 +1,20 @@
+module Support
+  module Projects
+    include Enumerable
+    extend self
+
+    def base
+      File.expand_path('../../../..', __FILE__)
+    end
+
+    def projects
+      @@projects ||= Dir.chdir(base) do
+        Dir['mustermann*/*.gemspec'].map { |f| File.dirname(f) }.sort
+      end
+    end
+
+    def each(&block)
+      projects.each(&block)
+    end
+  end
+end

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