arugula 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f59b134599b696a71d41c30d0bfc84fbab54e2c0
-  data.tar.gz: d3d49f304685d6f458284a712780a3274bc43b97
+  metadata.gz: 9b9342abba4049dbc32ce57a0d0b6326f0290d36
+  data.tar.gz: 2ec7ae8575d2267627a7b9bfb7e8da5e296f7567
 SHA512:
-  metadata.gz: 6cf01040b54906eaf6c9b4b4e6eff08843ad11fd6c4eb7da26865e068fb627ae9b9defd4382295120874e58bf68c48753f7c8dc80c2c2faf4bff7e1da542f883
-  data.tar.gz: 83b14f9ecf7a4cf2a8feef267d5599c999575db458bd35f3e08302414d4c16580d5234aa92c1d6e1edf09b544f49fc226fb0fc0b4626f650eaaf419b92a349a6
+  metadata.gz: 48655a01f947db1e92761c07373eb7590770de16fd88c6a89ae4a0a0c4ec3df0e611a5e43f25796e2ad56e3279922fc01fb95678fcd8d522ef41dc9207e1d265
+  data.tar.gz: 6c35efef0d7555482792a794ac625958520abf76f2c7eb96b81d1499d033c06de297311953fa27a9d221ad0e3b7d6114c36c79de210fd1962caf983c8658da37

data/.rubocop.yml

@@ -10,6 +10,8 @@ Style/TrailingCommaInLiteral:
 
 Metrics/AbcSize:
   Enabled: false
+Metrics/ClassLength:
+  Enabled: false
 Metrics/CyclomaticComplexity:
   Enabled: false
 Metrics/MethodLength:

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    arugula (0.3.0)
+    arugula (0.4.0)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -25,6 +25,9 @@ Or install it yourself as:
 regexp = Arugula.new('[A-Z][a-z]+')
 regexp.match?('ahoy! my name is Samuel') # => 17
 regexp.match?('foobar') # => null
+
+regexp = Arugula.new('Hello ([a-z]+)!')
+regexp.match('Hello world!') # => #<MatchData "Hello world!" 1:"world">
 ```
 
 ## Development

data/lib/arugula.rb

@@ -19,6 +19,7 @@ class Arugula
   def match(str, index = 0)
     match_data = MatchData.new(self, str)
     loop do
+      match_data.reset_captures!
       match, end_index = @root.match(str, index, match_data)
       if match
         match_data.start_index = index
@@ -33,4 +34,15 @@ class Arugula
   def to_s
     "/#{@root}/"
   end
+
+  alias inspect to_s
+
+  def hash
+    to_s.hash
+  end
+
+  def ==(other)
+    return false unless other.is_a?(Arugula) || other.is_a?(Regexp)
+    inspect == other.inspect
+  end
 end

data/lib/arugula/match_data.rb

@@ -1,5 +1,6 @@
 class Arugula
   class MatchData
+    attr_reader :string, :regexp
     def initialize(regexp, string)
       # require "awesome_print"
       # ap regexp, raw: true
@@ -12,6 +13,12 @@ class Arugula
       @captures[name] = start_index...end_index
     end
 
+    def reset_captures!
+      @captures.keys.each do |key|
+        @captures[key] = nil
+      end
+    end
+
     attr_accessor :start_index
     attr_accessor :end_index
 
@@ -21,18 +28,54 @@ class Arugula
 
     def inspect
       captures_part = @captures.map do |name, range|
-        " #{name}:#{@string[range].dump}"
+        " #{name}:#{dump_str(range && @string[range])}"
       end.join
-      "#<MatchData #{to_s.dump}#{captures_part}>"
+      "#<MatchData #{dump_str(to_s)}#{captures_part}>"
     end
 
     def to_a
-      @captures.map { |_name, range| @string[range] }.unshift(to_s)
+      captures.unshift(to_s)
+    end
+
+    def size
+      @captures.size + 1
+    end
+    alias length size
+
+    def captures
+      @captures.map { |_name, range| range && @string[range] }
+    end
+
+    def pre_match
+      return '' if start_index == 0
+      @string[0...start_index]
+    end
+
+    def post_match
+      return '' if end_index == string.size
+      @string[end_index..-1]
     end
 
     def freeze
       @captures.freeze
       super
     end
+
+    def hash
+      @string.hash ^ @regexp.hash ^ @captures.hash
+    end
+
+    def ==(other)
+      return false unless other.is_a?(MatchData) || other.is_a?(::MatchData)
+      string == other.string &&
+        regexp == other.regexp &&
+        captures == other.captures
+    end
+
+    private
+
+    def dump_str(str)
+      str.nil? ? 'nil' : str.dump
+    end
   end
 end

data/lib/arugula/parser.rb

@@ -30,7 +30,7 @@ class Arugula
       peek = pattern.chr
       if tok.nil?
         fail 'shouldnt happen'
-      elsif tok == '['
+      elsif tok == '[' && !characterclass_type?
         push_part(:characterclass)
       elsif tok == '-' &&
             characterclass_type? &&
@@ -41,6 +41,10 @@ class Arugula
         pattern.slice!(0)
       elsif tok == ']' && characterclass_type?
         pop_part
+      elsif tok == '^' && characterclass_type? && state.parts.empty?
+        characterclass_part = pop_part
+        wrap_state(:not)
+        @states << characterclass_part
       elsif tok == '$'
         push_part(:eol)
       elsif tok == '^'
@@ -72,6 +76,24 @@ class Arugula
         wrap_state(:star)
       elsif tok == '+'
         wrap_state(:plus)
+      elsif tok == '?'
+        wrap_state(:question)
+      elsif tok == '{'
+        before_comma = ''
+        after_comma = ''
+        until pattern.chr == ',' || pattern.chr == '}'
+          before_comma << pattern.slice!(0)
+        end
+        if pattern.chr == ','
+          pattern.slice!(0)
+        else
+          after_comma = before_comma
+        end
+        after_comma << pattern.slice!(0) until pattern.chr == '}'
+        pattern.slice!(0) if pattern.chr == '}'
+        before = before_comma.empty? ? 0 : before_comma.to_i
+        after = after_comma.empty? ? Float::INFINITY : after_comma.to_i
+        wrap_state(:quantifier, before, after)
       else
         push_part(:literal, tok)
       end
@@ -85,8 +107,9 @@ class Arugula
       @states << part unless name == :literal
     end
 
-    def wrap_state(name)
-      wrapped = Part.all.find { |p| p.type == name }.new(state.parts.pop)
+    def wrap_state(name, *content)
+      wrapped = Part.all.find { |p| p.type == name }
+                    .new(*content, state.parts.pop)
       state.parts << wrapped
       @states << wrapped
     end

data/lib/arugula/parts.rb

@@ -21,7 +21,7 @@ class Arugula
     end
 
     def to_s
-      literal.gsub('\\', '\\\\')
+      literal.gsub('\\', '\\\\').gsub(/[.]/) { |m| "\\#{m}" }
     end
 
     def match(str, index, _match_data)
@@ -61,8 +61,8 @@ class Arugula
 
     def match(str, index, match_data)
       parts.each do |part|
-        match, match_index = part.match(str, index, match_data)
-        return true, match_index if match
+        matches, match_index = part.match(str, index, match_data)
+        return true, match_index if matches
       end
       [false, index]
     end
@@ -83,7 +83,14 @@ class Arugula
   class CharacterClassPart < Part
     include MatchAny
     def to_s
-      "[#{parts.join}]"
+      parts_string = parts.map do |part|
+        next part unless part.class.type == :literal
+        lit = part.literal
+        lit = '\\]' if lit == ']'
+        lit = '\\[' if lit == '['
+        lit
+      end.join
+      "[#{parts_string}]"
     end
   end
 
@@ -108,13 +115,17 @@ class Arugula
       d: ->(str, index) { ('0'..'9').member?(str[index]) },
       s: ->(str, index) { [' ', "\t"].include?(str[index]) },
       S: ->(str, index) { ![' ', "\t"].include?(str[index]) },
+      z: ->(str, index) { index == str.size },
+      Z: ->(str, index) { str[index..-1] == "\n" || index == str.size },
     }.freeze
 
     OFFSETS = begin
       offsets = {
-        A: 0,
+        A: ->(_str, _index) { 0 },
+        Z: ->(_str, _index) { 0 },
+        z: ->(_str, _index) { 0 },
       }
-      offsets.default = 1
+      offsets.default = ->(_str, _index) { 1 }
       offsets.freeze
     end
 
@@ -124,7 +135,7 @@ class Arugula
 
     def match(str, index, _match_data)
       matches = MATCHERS[@metachar][str, index]
-      [matches, index + (matches ? OFFSETS[@metachar] : 0)]
+      [matches, index + (matches ? OFFSETS[@metachar][str, index] : 0)]
     end
 
     def to_s
@@ -181,33 +192,93 @@ class Arugula
     end
   end
 
-  class StarPart < Part
+  class NotPart < Part
     include Wrapping
+
     def to_s
-      "#{wrapped}*"
+      @wrapped.to_s.dup.insert(1, '^')
+    end
+
+    def match(str, index, match_data)
+      matches, end_index = wrapped.match(str, index, match_data)
+      [!matches, matches ? index : end_index + 1]
+    end
+  end
+
+  module MatchNTimes
+    include Wrapping
+    def initialize(*args, times: 1..1)
+      @times = times
+      super(*args)
     end
 
     def match(str, index, match_data)
+      match_count = 0
+      end_index = index
+
       loop do
         matches, index = wrapped.match(str, index, match_data)
-        return true, index unless matches
+        if matches
+          end_index = index
+          match_count += 1
+        end
+        break if !matches || match_count > @times.end
       end
+
+      matches = @times.member?(match_count)
+      [matches, matches ? end_index : index]
+    end
+  end
+
+  class StarPart < Part
+    include MatchNTimes
+    def initialize(*args)
+      super(*args, times: 0..Float::INFINITY)
+    end
+
+    def to_s
+      "#{wrapped}*"
     end
   end
 
   class PlusPart < Part
-    include Wrapping
+    include MatchNTimes
+    def initialize(*args)
+      super(*args, times: 1..Float::INFINITY)
+    end
+
     def to_s
       "#{wrapped}+"
     end
+  end
 
-    def match(str, index, match_data)
-      has_matched = false
-      loop do
-        matches, index = wrapped.match(str, index, match_data)
-        has_matched = true if matches
-        return has_matched, index unless matches
-      end
+  class QuestionPart < Part
+    include MatchNTimes
+    def initialize(*args)
+      super(*args, times: 0..1)
+    end
+
+    def to_s
+      "#{wrapped}?"
+    end
+  end
+
+  class QuantifierPart < Part
+    include MatchNTimes
+    def initialize(before, after, *args)
+      super(*args, times: before..after)
+    end
+
+    def to_s
+      before = @times.begin
+      after = @times.end
+      quantifier_part = '{'.dup
+      quantifier_part << before.to_s unless before == 0
+      quantifier_part << ',' unless before == after
+      quantifier_part << after.to_s unless before == after ||
+                                           after == Float::INFINITY
+      quantifier_part << '}'
+      "#{wrapped}#{quantifier_part}"
     end
   end
 
@@ -217,7 +288,8 @@ class Arugula
     end
 
     def match(str, index, _match_data)
-      matches = index < str.size
+      char = str[index]
+      matches = char && char != "\n"
       [matches, index + (matches ? 1 : 0)]
     end
   end

data/lib/arugula/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 class Arugula
-  VERSION = '0.3.0'.freeze
+  VERSION = '0.4.0'.freeze
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: arugula
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Samuel Giddins