mustermann19 0.3.1.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 13070ee02993a1b1a6f7e9cf97709b3401185b54
-  data.tar.gz: 7cc22ed29750abd8899d649ca6f9b9849701f099
+  metadata.gz: 7c18eae7550233eced7217aec1439b9a51737fc1
+  data.tar.gz: e242e2fc80b76b0fd6842c6e801b69aa79958354
 SHA512:
-  metadata.gz: fb819ee53bef2d16e6985b72e5dcb529465f8d9c555b5881e8c5b0adf862aed90d26167ca9e4b94843bb666af9038a530bf0ffb9530a856e5605c70db47051b2
-  data.tar.gz: 1ac73cb9e5b86f4d0f51e1269f3d3116e1e5ac124d1b3483494769443e5cea2b43648e972a1fa0e2a27c41d8e5d3aa858d132818dcbe9cfed6e847ad77b4f142
+  metadata.gz: a201dc17c06299c6b7f49749e7ec6add20bea0db6efe5c438044e72209ad0be2f394ac5b59d1eca9b6c9706b73b9dd7dde61c951c37fba8396b5ed30940fc435
+  data.tar.gz: e60038818b219dcf23c58334df578d0d101ce49f609c0cc93e950f0eb804e38a8cccc9835014cee05c1d91b49bb522d35549923aef32238bff620015b7d70aae

data/.travis.yml

@@ -3,6 +3,7 @@ rvm:
 - 1.9.2
 - 2.1.2
 - 2.1.4
+- jruby
 - jruby-head
 - rbx-2
 matrix:

data/README.md

@@ -8,6 +8,12 @@
 
 
 *Make sure you view the correct docs: [latest release](http://rubydoc.info/gems/mustermann/frames), [master](http://rubydoc.info/github/rkh/mustermann/master/frames).*
+* **[mustermann](mustermann/README.md): Your personal string matching expert. This is probably what you're looking for.**
+* [mustermann-everything](mustermann-everything/README.md): A meta gem depending on all other official mustermann gems.
+* [mustermann-fileutils](mustermann-fileutils/README.md): Efficient file system operations using Mustermann patterns.
+* [mustermann-strscan](mustermann-strscan/README.md): A version of Ruby's [StringScanner](http://ruby-doc.org/stdlib-2.0/libdoc/strscan/rdoc/StringScanner.html) made for pattern objects.
+* [mustermann-visualizer](mustermann-visualizer/README.md): Syntax highlighting and tree visualization for patterns.
+* A selection of pattern types for mustermann, each as their own little library, see [below](#-pattern-types).
 
 Welcome to [Mustermann](http://en.wikipedia.org/wiki/List_of_placeholder_names_by_language#German). Mustermann is your personal string matching expert. As an expert in the field of strings and patterns, Mustermann keeps its runtime dependencies to a minimum and is fully covered with specs and documentation.
 

data/Rakefile

@@ -1,6 +1,6 @@
 ENV['JRUBY_OPTS'] = '--2.0 -X-C'
 ENV['RBXOPT'] = '-X20'
 
-task(:spec) { ruby '-w -S rspec' }
+task(:rspec)     { ruby '-S rspec'      }
 task(:doc_stats) { ruby '-S yard stats' }
-task(default: [:spec, :doc_stats])
+task default: [:rspec, :doc_stats]

data/lib/mustermann.rb

@@ -1,10 +1,15 @@
 require 'mustermann/pattern'
 require 'mustermann/composite'
+require 'thread'
 
 # Namespace and main entry point for the Mustermann library.
 #
 # Under normal circumstances the only external API entry point you should be using is {Mustermann.new}.
 module Mustermann
+  # Type to use if no type is given.
+  # @api private
+  DEFAULT_TYPE = :sinatra
+
   # Creates a new pattern based on input.
   #
   # * From {Mustermann::Pattern}: returns given pattern.
@@ -54,7 +59,7 @@ module Mustermann
   # @see file:README.md#Types_and_Options "Types and Options" in the README
   def self.new(*input)
     options = input.last.kind_of?(Hash) ? input.pop : {}
-    type = options.delete(:type) || :sinatra
+    type = options.delete(:type) || DEFAULT_TYPE
     input = input.first if input.size < 2
     case input
     when Pattern then input
@@ -69,6 +74,9 @@ module Mustermann
     end
   end
 
+  @mutex ||= Mutex.new
+  @types ||= {}
+
   # Maps a type to its factory.
   #
   # @example
@@ -77,10 +85,24 @@ module Mustermann
   # @param [Symbol] key a pattern type identifier
   # @raise [ArgumentError] if the type is not supported
   # @return [Class, #new] pattern factory
-  def self.[](key)
-    constant, library = register.fetch(key) { raise ArgumentError, "unsupported type %p" % key }
-    require library if library
-    constant.respond_to?(:new) ? constant : register[key] = const_get(constant)
+  def self.[](name)
+    return name if name.respond_to? :new
+    @types.fetch(normalized = normalized_type(name)) do
+      @mutex.synchronize do
+        error = try_require "mustermann/#{normalized}"
+        @types.fetch(normalized) { raise ArgumentError, "unsupported type %p#{" (#{error.message})" if error}" % name }
+      end
+    end
+  end
+
+  # @return [LoadError, nil]
+  # @!visibility private
+  def self.try_require(path)
+    require(path)
+    nil
+  rescue LoadError => error
+    raise(error) if error.respond_to?(:path) && error.path != path
+    error
   end
 
   # @!visibility private
@@ -93,18 +115,19 @@ module Mustermann
     @register
   end
 
+  def self.register(name, type)
+    @types[normalized_type(name)] = type
+  end
+
+  # @!visibility private
+  def self.normalized_type(type)
+    type.to_s.gsub('-', '_').downcase
+  end
+
   # @!visibility private
   def self.extend_object(object)
     return super unless defined? ::Sinatra::Base and object.is_a? Class and object < ::Sinatra::Base
     require 'mustermann/extension'
     object.register Extension
   end
-
-  register :identity
-  register :rails
-  register :regular, :regexp
-  register :shell
-  register :simple
-  register :sinatra
-  register :template
 end

data/lib/mustermann/ast/boundaries.rb

@@ -0,0 +1,48 @@
+require 'mustermann/ast/translator'
+
+module Mustermann
+  module AST
+    # Make sure #start and #stop is set on every node and within its parents #start and #stop.
+    # @!visibility private
+    class Boundaries < Translator
+      # @return [Mustermann::AST::Node] the ast passed as first argument
+      # @!visibility private
+      #def self.set_boundaries(ast, string: nil, start: 0, stop: string.length)
+      def self.set_boundaries(ast, options = {})
+        string = options.fetch(:string, nil)
+        start  = options.fetch(:start, 0)
+        stop   = options.fetch(:stop, string.length)
+        new.translate(ast, start, stop)
+        ast
+      end
+
+      translate(:node) do |start, stop|
+        t.set_boundaries(node, start, stop)
+        t(payload, node.start, node.stop)
+      end
+
+      translate(:with_look_ahead) do |start, stop|
+        t.set_boundaries(node, start, stop)
+        t(head,    node.start, node.stop)
+        t(payload, node.start, node.stop)
+      end
+
+      translate(Array) do |start, stop|
+        each do |subnode|
+          t(subnode, start, stop)
+          start = subnode.stop
+        end
+      end
+
+      translate(Object) { |*| node }
+
+      # Checks that a node is within the given boundaries.
+      # @!visibility private
+      def set_boundaries(node, start, stop)
+        node.start = start                      if node.start.nil? or node.start < start
+        node.stop  = node.start + node.min_size if node.stop.nil?  or node.stop  < node.start
+        node.stop  = stop                       if node.stop > stop
+      end
+    end
+  end
+end

data/lib/mustermann/ast/expander.rb

@@ -10,21 +10,25 @@ module Mustermann
     class Expander < Translator
       raises ExpandError
 
-      translate Array do
+      translate Array do |*args|
         inject(t.pattern) do |pattern, element|
-          t.add_to(pattern, t(element))
+          t.add_to(pattern, t(element, *args))
         end
       end
 
-      translate :capture do
-        t.for_capture(node)
+      translate :capture do |options = {}|
+        t.for_capture(node, options)
       end
 
       translate :named_splat, :splat do
         t.pattern + t.for_capture(node)
       end
 
-      translate :root, :group, :expression do
+      translate :expression do
+        t(payload, allow_reserved: operator.allow_reserved)
+      end
+
+      translate :root, :group do
         t(payload)
       end
 
@@ -52,9 +56,9 @@ module Mustermann
 
       # helper method for captures
       # @!visibility private
-      def for_capture(node)
+      def for_capture(node, options = {})
         name = node.name.to_sym
-        pattern('%s', name, name => /(?!#{pattern_for(node)})./)
+        pattern('%s', name, name => /(?!#{pattern_for(node, options)})./)
       end
 
       # maps sorted key list to sprintf patterns and filters

data/lib/mustermann/ast/node.rb

@@ -4,24 +4,23 @@ module Mustermann
     # @!visibility private
     class Node
       # @!visibility private
-      attr_accessor :payload
+      attr_accessor :payload, :start, :stop
 
       # @!visibility private
       # @param [Symbol] name of the node
       # @return [Class] factory for the node
       def self.[](name)
-        @names ||= {}
-        #@names.fetch(name) { Object.const_get(constant_name(name)) }
-        @names.fetch(name) do
+        @names       ||= {}
+        @names[name] ||= begin
           const_name = constant_name(name)
-          const_name.split("::").inject(Object){|current, const| current.const_get(const) }
+          const_name.split("::").inject(Object){|current, const| current.const_get(const) } rescue nil
         end
       end
 
+      # Turns a class name into a node identifier.
       # @!visibility private
-      def is_a?(type)
-        type = Node[type] if type.is_a? Symbol
-        super(type)
+      def self.type
+        name[/[^:]+$/].split(/(?<=.)(?=[A-Z])/).map(&:downcase).join(?_).to_sym
       end
 
       # @!visibility private
@@ -47,6 +46,12 @@ module Mustermann
         self.payload = payload
       end
 
+      # @!visibility private
+      def is_a?(type)
+        type = Node[type] if type.is_a? Symbol
+        super(type)
+      end
+
       # Double dispatch helper for reading from the buffer into the payload.
       # @!visibility private
       def parse
@@ -69,6 +74,24 @@ module Mustermann
         yield(self) unless called
       end
 
+      # @return [Integer] length of the substring
+      # @!visibility private
+      def length
+        stop - start if start and stop
+      end
+
+      # @return [Integer] minimum size for a node
+      # @!visibility private
+      def min_size
+        0
+      end
+
+      # Turns a class name into a node identifier.
+      # @!visibility private
+      def type
+        self.class.type
+      end
+
       # @!visibility private
       class Capture < Node
         # @see Mustermann::AST::Compiler::Capture#default
@@ -96,6 +119,11 @@ module Mustermann
 
       # @!visibility private
       class Char < Node
+        # @return [Integer] minimum size for a node
+        # @!visibility private
+        def min_size
+          1
+        end
       end
 
       # AST node for template expressions.
@@ -126,6 +154,10 @@ module Mustermann
       class Optional < Node
       end
 
+      # @!visibility private
+      class Or < Node
+      end
+
       # @!visibility private
       class Root < Node
         # @!visibility private
@@ -145,6 +177,11 @@ module Mustermann
 
       # @!visibility private
       class Separator < Node
+        # @return [Integer] minimum size for a node
+        # @!visibility private
+        def min_size
+          1
+        end
       end
 
       # @!visibility private
@@ -176,7 +213,8 @@ module Mustermann
         attr_accessor :head, :at_end
 
         # @!visibility private
-        def initialize(payload, at_end)
+        def initialize(payload, at_end, options = {})
+          super(options)
           self.head, *self.payload = Array(payload)
           self.at_end = at_end
         end

data/lib/mustermann/ast/parser.rb

@@ -42,7 +42,7 @@ module Mustermann
       attr_reader :buffer, :string, :pattern
 
       extend Forwardable
-      def_delegators :buffer, :eos?, :getch
+      def_delegators :buffer, :eos?, :getch, :pos
 
       # @!visibility private
       def initialize(options = {})
@@ -66,8 +66,10 @@ module Mustermann
       # @return [Mustermann::AST::Node]
       # @!visibility private
       def node(type, *args, &block)
-        type = Node[type] unless type.respond_to? :new
-        block ? type.parse(*args, &block) : type.new(*args)
+        type  = Node[type] unless type.respond_to? :new
+        start = pos
+        node  = block ? type.parse(*args, &block) : type.new(*args)
+        min_size(start, pos, node)
       end
 
       # Create a node for a character we don't have an explicit rule for.
@@ -83,12 +85,26 @@ module Mustermann
       # @return [Mustermann::AST::Node] next element
       # @!visibility private
       def read
-        char    = getch
-        method  = "read %p" % char
-        element = respond_to?(method) ? send(method, char) : default_node(char)
+        start  = pos
+        char   = getch
+        method = "read %p" % char
+        element= respond_to?(method) ? send(method, char) : default_node(char)
+        min_size(start, pos, element)
         read_suffix(element)
       end
 
+      # sets start on node to start if it's not set to a lower value.
+      # sets stop on node to stop if it's not set to a higher value.
+      # @return [Mustermann::AST::Node] the node passed as third argument
+      # @!visibility private
+      def min_size(start, stop, node)
+        stop  ||= start
+        start ||= stop
+        node.start = start unless node.start and node.start < start
+        node.stop  = stop  unless node.stop  and node.stop  > stop
+        node
+      end
+
       # Checks for a potential suffix on the buffer.
       # @param [Mustermann::AST::Node] element node without suffix
       # @return [Mustermann::AST::Node] node with suffix
@@ -96,7 +112,8 @@ module Mustermann
       def read_suffix(element)
         self.class.suffix.inject(element) do |ele, (regexp, after, callback)|
           next ele unless ele.is_a?(after) and payload = scan(regexp)
-          instance_exec(payload, ele, &callback)
+          content = instance_exec(payload, ele, &callback)
+          min_size(element.start, pos, content)
         end
       end
 
@@ -109,25 +126,8 @@ module Mustermann
       # @return [String, MatchData, nil]
       # @!visibility private
       def scan(regexp)
-        match_buffer(:scan, regexp)
-      end
-
-      # Wrapper around {StringScanner#check} that turns strings into escaped
-      # regular expressions and returns a MatchData if the regexp has any
-      # named captures.
-      #
-      # @param [Regexp, String] regexp
-      # @see StringScanner#check
-      # @return [String, MatchData, nil]
-      # @!visibility private
-      def check(regexp)
-        match_buffer(:check, regexp)
-      end
-
-      # @!visibility private
-      def match_buffer(method, regexp)
         regexp = Regexp.new(Regexp.escape(regexp)) unless regexp.is_a? Regexp
-        string = buffer.public_send(method, regexp)
+        string = buffer.scan(regexp)
         regexp.names.any? ? regexp.match(string) : string
       end
 
@@ -247,8 +247,6 @@ module Mustermann
         char = "space" if char == " "
         raise exception, "unexpected #{char || "end of string"} while parsing #{string.inspect}"
       end
-
-      private :match_buffer
     end
 
     #private_constant :Parser

data/lib/mustermann/ast/pattern.rb

@@ -1,4 +1,5 @@
 require 'mustermann/ast/parser'
+require 'mustermann/ast/boundaries'
 require 'mustermann/ast/compiler'
 require 'mustermann/ast/transformer'
 require 'mustermann/ast/validation'
@@ -18,9 +19,9 @@ module Mustermann
 
       extend Forwardable, SingleForwardable
       single_delegate on: :parser, suffix: :parser
-      instance_delegate %w[parser compiler transformer validation template_generator param_scanner].map(&:to_sym) => 'self.class'
+      instance_delegate %w[parser compiler transformer validation template_generator param_scanner boundaries].map(&:to_sym) => 'self.class'
       instance_delegate parse: :parser, transform: :transformer, validate: :validation,
-        generate_templates: :template_generator, scan_params: :param_scanner
+        generate_templates: :template_generator, scan_params: :param_scanner, set_boundaries: :boundaries
 
       # @api private
       # @return [#parse] parser object for pattern
@@ -39,7 +40,14 @@ module Mustermann
       end
 
       # @api private
-      # @return [#transform] compiler object for pattern
+      # @return [#set_boundaries] translator making sure start and stop is set on all nodes
+      # @!visibility private
+      def self.boundaries
+        Boundaries
+      end
+
+      # @api private
+      # @return [#transform] transformer object for pattern
       # @!visibility private
       def self.transformer
         Transformer
@@ -79,7 +87,12 @@ module Mustermann
       # @!visibility private
       def to_ast
         @ast_cache ||= EqualityMap.new
-        @ast_cache.fetch(@string) { validate(transform(parse(@string, pattern: self))) }
+        @ast_cache.fetch(@string) do
+          ast   = parse(@string, pattern: self)
+          ast &&= transform(ast)
+          ast &&= set_boundaries(ast, string: @string)
+          validate(ast)
+        end
       end
 
       # All AST-based pattern implementations support expanding.
@@ -117,7 +130,7 @@ module Mustermann
         @param_converters ||= scan_params(to_ast)
       end
 
-      private :compile, :parse, :transform, :validate, :generate_templates, :param_converters, :scan_params
+      private :compile, :parse, :transform, :validate, :generate_templates, :param_converters, :scan_params, :set_boundaries
     end
   end
 end