thefox-ext 1.9.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 569a588809c70468e59dc2d762bf261d94108cc4d9c535c664c518c99b820914
-  data.tar.gz: 9307e0cf0b76da29e09537bc93e7e77f70137dcb69621d94089ad24f08a080d2
+  metadata.gz: da29c60568cd97ae87c97b6d299215f77c4ab55ad711bbae6793d762b441fcce
+  data.tar.gz: 1a31f430986f74719a80e3900152acfb7b714f553a1b26204dc6b615f2f7455e
 SHA512:
-  metadata.gz: 4e8c14d434bd57584ae5f72d2c99923af6da39c0e88b1e2cee8afb5f03776d1997be3a994e54f97632c9b96e7f280a4e2249717cdb1d4ee1163f9be7c8c98e20
-  data.tar.gz: 5f4527fb0be38f6e1c4018a8896374475405565907484d894e5294bdb43f989050f1af2217b25c12095d454a64f162fd148355a0685218560d6ad1e085e6c735
+  metadata.gz: 7f014e0cfd460e98cec083744b72a40bdd73d4b2558ce921c7ac003b0aad7eadd9f73deafc1a8bff5392206eabb51b9f8442b8f034c512227b4afc7ad94622bc
+  data.tar.gz: f559019dcc8cb52656b785b71db0fd91cfc786b7246b22c4b533a7b5584317ac9114f0b32c0de38c1a2ce277fe7ff8ec231fdbebb1e436b3c602d7775644957d

data/.github/workflows/ci.yml

@@ -10,6 +10,7 @@ on:
   push:
     branches:
       - master
+      - feature/*
 
 jobs:
   test:
@@ -17,7 +18,6 @@ jobs:
     strategy:
       matrix:
         ruby-version:
-          - '2.3'
           - '2.4'
           - '2.5'
           - '2.6'

data/CHANGELOG-v1.md

@@ -1,5 +1,10 @@
 # Release Notes for Extended Ruby Classes v1.x
 
+## v1.10.0
+
+- [DEPRECATION] `Array.resolve_range_str` is deprecated.
+- [DEPRECATION] `String.resolve_range` is deprecated.
+
 ## v1.9.0
 
 - Tests

data/CHANGELOG-v2.md

@@ -0,0 +1,8 @@
+# Release Notes for Extended Ruby Classes v2.x
+
+## v2.0.0
+
+- Removed deprecated `Array.resolve_range_str`.
+- Removed deprecated `String.resolve_range`.
+- Drop Ruby version 2.3 support.
+- Added Range Resolver class.

data/README.md

@@ -21,7 +21,7 @@ gem install thefox-ext
 or via `Gemfile`:
 
 ```ruby
-gem 'thefox-ext', '~>1.9'
+gem 'thefox-ext', '~>2.0'
 ```
 
 Use it in your sources:
@@ -40,10 +40,9 @@ require 'thefox-ext'
 - Date
 	- `today?`
 	- Get week array for a specific date.
-- Array
-	- Range String Resolver
 - Hash
 	- Recursive Merge
+- Range String Resolver
 
 ## Project Links
 

data/bin/dev

@@ -4,10 +4,7 @@
 require 'thefox-ext'
 require 'pp'
 
-# pp '5{1,2}'.resolve_range()
-# pp '1,2{1-3,5,6,7},4,5{1,2}'.resolve_range()
-# pp [1, 2].resolve_range_str('3, 4')
-# pp Array.resolve_range_str('3,4')
-# pp '3, 4'.resolve_range()
-# pp '3, 4'.resolve_range()
-# pp '3, 4'.resolve_range2()
+s = '99-110/4'
+s = '99-110/*'
+rr = TheFox::Range::Resolver.new(s)
+pp rr.to_a

data/bin/test.sh

@@ -10,4 +10,5 @@ which bundler &> /dev/null || { echo 'ERROR: bundler not found in PATH'; exit 1;
 
 cd "${SCRIPT_BASEDIR}/.."
 
+echo 'run tests'
 bundler exec ./test/suite_all.rb $*

data/lib/thefox-ext.rb

@@ -8,6 +8,18 @@ require 'thefox-ext/ext/integer'
 require 'thefox-ext/ext/nil'
 require 'thefox-ext/ext/string'
 require 'thefox-ext/ext/true'
-require 'thefox-ext/ext/array'
 
 require 'thefox-ext/console'
+require 'thefox-ext/range/resolver'
+require 'thefox-ext/range/lexer/lexer'
+require 'thefox-ext/range/lexer/base'
+require 'thefox-ext/range/lexer/scope'
+require 'thefox-ext/range/lexer/separator'
+require 'thefox-ext/range/lexer/operator'
+require 'thefox-ext/range/lexer/block'
+require 'thefox-ext/range/lexer/block_down'
+require 'thefox-ext/range/lexer/block_up'
+require 'thefox-ext/range/lexer/block_stack'
+require 'thefox-ext/range/lexer/range'
+require 'thefox-ext/range/lexer/interval'
+require 'thefox-ext/range/lexer/number'

data/lib/thefox-ext/ext/string.rb

@@ -63,71 +63,4 @@ class String
       self.force_encoding('ISO-8859-1').encode('UTF-8')
     end
   end
-
-  # Resolve a range string to an array.
-  # A range string can be like '1, 3..5, 9-11, 12+, 14++, 17+++'.
-  # Which will be resolved to [1, 3, 4, 5, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].
-  def resolve_range(prefix = '')
-    # puts '-> resolve_range: %s {%s}' % [self, prefix]
-
-    rv = Array.new
-
-    items1 = self.split(',')
-    # pp items1
-
-    items2 = []
-    is_sub_range = false
-    sub_item = []
-    items1.each do |item|
-      if item.count('{') > 0
-        is_sub_range = true
-      end
-      if is_sub_range
-        sub_item.push(item)
-      else
-        items2.push(item)
-      end
-      if item.count('}') > 0
-        is_sub_range = false
-        items2.push(sub_item.join(','))
-        sub_item = []
-      end
-    end
-
-    # pp items2
-
-    items2.map{ |item|
-      item_striped = item.strip
-      if range_match = item_striped.match(/(\d+)\{([\d\-\+,]+)\}/)
-        range_match[2].resolve_range(range_match[1])
-      elsif /\.\./.match(item_striped) # ( . )( . ) <--- BOOBS
-        Range.new(*item_striped.split('..', 2).map{ |range| range.to_i })
-      elsif /-/.match(item_striped)
-        Range.new(*item_striped.split('-', 2).map{ |range| range.to_i })
-      elsif /\+/.match(item_striped)
-        items = item_striped.split('+')
-        range_begin = items[0].to_i
-        range_end = range_begin + item_striped.count('+')
-        Range.new(range_begin, range_end)
-      else
-        item_striped.to_i
-      end
-    }.each{ |range|
-      if range.is_a?(Range)
-        rv.push(*range.to_a)
-      elsif range.is_a?(Array)
-        rv.push(*range)
-      else
-        rv << range
-      end
-    }
-
-    if !prefix.empty?
-      rv = rv.map { |i|
-        (prefix + i.to_s).to_i
-      }
-    end
-
-    rv
-  end
 end

data/lib/thefox-ext/range/lexer/base.rb

@@ -0,0 +1,69 @@
+
+module TheFox
+module Range
+module Lexer
+  class Base
+    def initialize(symbole = nil)
+      # puts '-> Base.initialize'
+      @symbole = symbole
+      @prev_item = nil
+      @next_item = nil
+
+      @parent_item = nil
+      @children = []
+    end
+
+    def chain(item)
+      self.next_item = item
+      item.prev_item = self
+    end
+
+    def symbole()
+      @symbole
+    end
+
+    def prev_item()
+      @prev_item
+    end
+    def prev_item=(prev_item)
+      @prev_item = prev_item
+    end
+
+    def next_item()
+      @next_item
+    end
+    def next_item=(next_item)
+      @next_item = next_item
+    end
+
+    def parent_item()
+      @parent_item
+    end
+    def parent_item=(parent_item)
+      @parent_item = parent_item
+    end
+    def has_parent_item()
+      !@parent_item.nil?
+    end
+
+    def children()
+      @children
+    end
+    def add_child(child)
+      @children.push(child)
+    end
+    def has_children()
+      @children.length > 1
+    end
+
+    def dup()
+      # puts '-> Base.dup'
+      o = super()
+      o.prev_item = nil
+      o.next_item = nil
+      o
+    end
+  end # Base
+end # Lexer
+end # Range
+end # TheFox

data/lib/thefox-ext/range/lexer/block.rb

@@ -0,0 +1,10 @@
+
+module TheFox
+module Range
+module Lexer
+  # { }
+  class Block < Scope
+  end # Block
+end # Lexer
+end # Range
+end # TheFox

data/lib/thefox-ext/range/lexer/block_down.rb

@@ -0,0 +1,21 @@
+
+module TheFox
+module Range
+module Lexer
+  # {
+  class BlockDown < Block
+    def initialize(level)
+      super()
+      # puts '-> BlockDown.initialize(%d)' % [level]
+      @level = level
+    end
+
+    # :nocov:
+    def inspect()
+      'BlockDown(%d)' % [@level]
+    end
+    # :nocov:
+  end # BlockDown
+end # Lexer
+end # Range
+end # TheFox

data/lib/thefox-ext/range/lexer/block_stack.rb

@@ -0,0 +1,44 @@
+
+require 'pp'
+
+module TheFox
+module Range
+module Lexer
+  # 0123456789
+  class BlockStack
+    def initialize()
+      # puts '-> BlockStack.initialize()'
+      @stack = []
+    end
+
+    # :nocov:
+    def inspect()
+      'BlockStack(%d)' % [@stack.length]
+    end
+    # :nocov:
+
+    def push(item)
+      @stack.push(item)
+    end
+
+    def pop()
+      @stack.pop
+    end
+
+    def curr()
+      @stack.last
+    end
+
+    def length()
+      @stack.length
+    end
+
+    def add_child(item)
+      if !@stack.last.nil? && !item.nil?
+        @stack.last.add_child(item)
+      end
+    end
+  end # BlockStack
+end # Lexer
+end # Range
+end # TheFox

data/lib/thefox-ext/range/lexer/block_up.rb

@@ -0,0 +1,21 @@
+
+module TheFox
+module Range
+module Lexer
+  # }
+  class BlockUp < Block
+    def initialize(level)
+      super()
+      # puts '-> BlockUp.initialize(%d)' % [level]
+      @level = level
+    end
+
+    # :nocov:
+    def inspect()
+      'BlockUp(%d)' % [@level]
+    end
+    # :nocov:
+  end # BlockUp
+end # Lexer
+end # Range
+end # TheFox

data/lib/thefox-ext/range/lexer/interval.rb

@@ -0,0 +1,32 @@
+
+module TheFox
+  module Range
+  module Lexer
+    # /n
+    class Interval < Base
+      def initialize()
+        super()
+        # puts '-> Interval.initialize()'
+        @number = nil
+      end
+
+      # :nocov:
+      def inspect()
+        if @number.nil?
+          'Interval()'
+        else
+          'Interval(%s)' % [@number.inspect]
+        end
+      end
+      # :nocov:
+
+      def number=(number)
+        @number = number
+      end
+      def number()
+        @number
+      end
+    end # Interval
+  end # Lexer
+  end # Range
+  end # TheFox

data/lib/thefox-ext/range/lexer/lexer.rb

@@ -0,0 +1,284 @@
+
+require 'pp'
+
+module TheFox
+module Range
+module Lexer
+  class Lexer
+    def initialize(chars)
+      # puts '-> Lexer.initialize'
+      @chars = chars
+      # pp @chars
+    end
+
+    def resolve()
+      # puts
+      # puts '-> Lexer.resolve L1'
+
+      position = 0
+      prev_item = nil
+      block_level = 0
+      items1 = []
+      @chars.each do |char|
+        position += 1
+
+        curr_item = case char
+          when ','
+            Separator.new()
+          when '{'
+            block_level += 1
+            BlockDown.new(block_level)
+          when '}'
+            org_level = block_level
+            block_level -= 1
+            BlockUp.new(org_level)
+          when '+'
+            Operator.new()
+          when '-', '.'
+            Range.new(char)
+          when '/'
+            Interval.new()
+          when '0'..'9'
+            Number.new(char)
+          else
+            raise 'Unknown character at position %d: %s' % [position, char]
+          end
+
+        if !prev_item.nil?
+          prev_item.chain(curr_item)
+        end
+        items1.push(curr_item)
+        prev_item = curr_item
+      end
+
+      # pp items1.map{ |item| item.inspect }
+
+      # puts
+      # puts '-> Lexer.resolve L2'
+      curr_item = nil
+      prev_item = nil
+      items2 = []
+      items1.each do |item|
+        # puts '--> L2 item: %s' % [item.inspect]
+
+        append_dup = false
+
+        case item
+        when Number
+          if curr_item.nil?
+            # New Number
+            curr_item = item.dup
+            if !prev_item.nil?
+              prev_item.chain(curr_item)
+            end
+            items2.push(curr_item)
+            prev_item = curr_item
+          else
+            # Append Number
+            if curr_item.is_a?(Number)
+              curr_item.append(item.char)
+            else
+              raise 'Do not know what to do'
+            end
+          end
+        when Range
+          if prev_item.is_a?(Range) && prev_item.symbole == '.' && item.symbole == '.'
+            # skip
+          else
+            append_dup = true
+          end
+        else
+          # puts '--> L2 ELSE'
+
+          append_dup = true
+        end
+
+        if append_dup
+          curr_item = item.dup
+          if !prev_item.nil?
+            prev_item.chain(curr_item)
+          end
+          items2.push(curr_item)
+          prev_item = curr_item
+
+          curr_item = nil
+        end
+      end
+
+      # pp items2.map{ |item| item.inspect }
+
+      # puts
+      # puts '-> Lexer.resolve L3'
+      append_dub_f = nil
+      append_prev_f = nil
+      prev_item = nil
+      block_stack = BlockStack.new
+      items3 = []
+      items2.each do |item|
+        # puts '--> L3  %20s  bs=%d' % [item.inspect, block_stack.length]
+
+        append_dup = false
+        append_prev = false
+
+        case item
+        when Number
+          if item.next_item.is_a?(Range) || item.prev_item.is_a?(Range) || item.prev_item.is_a?(Interval)
+            # skip
+          else
+            append_dup = true
+          end
+        when Range
+          if item.prev_item.is_a?(Number) && item.next_item.is_a?(Number)
+            # puts '--> Range normal'
+            append_dub_f = -> (curr_item){
+              curr_item.left_item = item.prev_item.dup
+              curr_item.right_item = item.next_item.dup
+
+              curr_item.left_item.parent_item = block_stack.curr
+              curr_item.right_item.parent_item = block_stack.curr
+
+              block_stack.add_child(curr_item.left_item)
+              block_stack.add_child(curr_item.right_item)
+            }
+            append_dup = true
+          else
+            raise 'Invalid Range: %s %s' % [
+              item.prev_item.inspect,
+              item.next_item.inspect,
+            ]
+          end
+        when Interval
+          if !item.next_item.is_a?(Number)
+            raise 'Invalid Interval: %s' % [item.next_item.inspect]
+          end
+
+          append_dub_f = ->(curr_item){ curr_item.number = item.next_item.dup }
+          append_dup = true
+        when Operator
+          if prev_item.is_a?(Number)
+            append_prev_f = -> (curr_item){ curr_item.inc }
+            append_prev = true
+          end
+        when BlockDown
+          #block_stack.push(item.dup)
+          append_dub_f = ->(curr_item){ block_stack.push(curr_item) }
+          append_dup = true
+        when BlockUp
+          block_stack.pop
+          append_dup = true
+        else
+          # puts '--> L3 ELSE'
+          append_dup = true
+        end
+
+        # Append Dup
+        if append_dup
+          # Dup
+          curr_item = item.dup
+          # Function
+          if !append_dub_f.nil?
+            append_dub_f.call(curr_item)
+            append_dub_f = nil
+          end
+          # Chain
+          if !prev_item.nil?
+            prev_item.chain(curr_item)
+          end
+          # Block
+          if !item.is_a?(Block)
+            # puts '---> set Parent: %s' % [block_stack.curr.inspect]
+            curr_item.parent_item = block_stack.curr
+            block_stack.add_child(curr_item)
+          end
+          # Append
+          items3.push(curr_item)
+          # Prev Item
+          prev_item = curr_item
+        end
+
+        # Append Prev
+        if append_prev && !prev_item.nil?
+          # Dup
+          curr_item = prev_item.dup
+          # Function
+          if !append_prev_f.nil?
+            append_prev_f.call(curr_item)
+            append_prev_f = nil
+          end
+          # Chain
+          prev_item.chain(curr_item)
+          # Block
+          if !item.is_a?(Block)
+            curr_item.parent_item = block_stack.curr
+            block_stack.add_child(curr_item)
+          end
+          # Append
+          items3.push(curr_item)
+          # Prev Item
+          prev_item = curr_item
+        end
+
+        # Block
+        if item.is_a?(Block)
+          # puts '--> L3 set parent block for block'
+          item.parent_item = block_stack.curr
+          block_stack.add_child(item)
+        end
+      end
+
+      # pp items3.map{ |item| item.inspect }
+
+      # puts
+      # puts '-> Lexer.resolve L4 [convert to int]'
+      items4 = []
+      items3.each do |item|
+        # puts '--> L4  %20s   %20s   c: %d' % [item.inspect, item.parent_item.inspect, item.children.length]
+
+        case item
+        when Number
+          if item.next_item.is_a?(BlockDown)
+            # skip
+            # puts '---> skip'
+          else
+            items4.push(item.char.to_i)
+          end
+        when Range
+          r_begin = item.left_item.char.to_i
+          r_end = item.right_item.char.to_i
+          r = ::Range.new(r_begin, r_end)
+
+          if item.next_item.is_a?(Interval)
+            # Interval Range
+            n = item.next_item.number.char.to_i
+            c = 0
+            r.each do |i|
+              if c == 0
+                items4.push(i)
+              end
+              c += 1
+              if c == n
+                c = 0
+              end
+            end
+          else
+            # Normal Range
+            items4.push(*r.to_a)
+          end
+        when Interval
+          # puts '---> skip Interval'
+        when Separator
+          # puts '---> skip Separator'
+        when Block
+          # puts '---> skip Block'
+        else
+          raise 'Implementation missing for: %s' % [item.inspect]
+        end
+      end
+
+      # pp items4
+      items4
+    end
+  end # Lexer
+end # Lexer
+end # Range
+end # TheFox

data/lib/thefox-ext/range/lexer/number.rb

@@ -0,0 +1,56 @@
+
+require 'pp'
+
+module TheFox
+module Range
+module Lexer
+  # 0123456789
+  class Number < Base
+    def initialize(char)
+      super()
+      # puts '-> Number.initialize(%s)' % [char]
+      @char = char
+    end
+
+    # :nocov:
+    def inspect()
+      'Number(%s,^%s)' % [@char, @parent_item.inspect]
+    end
+    # :nocov:
+
+    def char()
+      # puts '-> %s.char' % [self.inspect]
+      if self.has_parent_item
+        # puts '-> %s.char has parent' % [self.inspect]
+        if self.parent_item.is_a?(Block)
+          # puts '-> %s.char parent is a %s' % [self.inspect, self.parent_item.inspect]
+          if self.parent_item.prev_item.is_a?(Number)
+            # puts '-> %s.char parent Prev is a %s' % [self.inspect, self.parent_item.prev_item.inspect]
+            '%s%s' % [self.parent_item.prev_item.char, @char]
+          else
+            raise 'Parent Prev item for %s is not a Block: %s' % [
+              self.inspect,
+              self.parent_item.prev_item.inspect,
+            ]
+          end
+        else
+          raise 'Parent item for %s is not a Block: %s' % [self.inspect, self.parent_item.inspect]
+        end
+      else
+        # puts '-> %s.char char' % [self.inspect]
+        @char
+      end
+    end
+
+    def append(char)
+      @char += char
+    end
+
+    def inc()
+      f = '%%0%dd' % [@char.length]
+      @char = f % [@char.to_i + 1]
+    end
+  end # Number
+end # Lexer
+end # Range
+end # TheFox

data/lib/thefox-ext/range/lexer/operator.rb

@@ -0,0 +1,20 @@
+
+module TheFox
+module Range
+module Lexer
+  # +
+  class Operator < Base
+    def initialize()
+      super()
+      # puts '-> Operator.initialize'
+    end
+
+    # :nocov:
+    def inspect()
+      'Operator()'
+    end
+    # :nocov:
+  end # Operator
+end # Lexer
+end # Range
+end # TheFox

data/lib/thefox-ext/range/lexer/range.rb

@@ -0,0 +1,41 @@
+
+module TheFox
+module Range
+module Lexer
+  # -
+  class Range < Base
+    def initialize(symbole)
+      super(symbole)
+      # puts '-> Range.initialize(%s)' % [symbole]
+
+      @left_item = nil
+      @right_item = nil
+    end
+
+    def left_item()
+      @left_item
+    end
+    def left_item=(left_item)
+      @left_item = left_item
+    end
+
+    def right_item()
+      @right_item
+    end
+    def right_item=(right_item)
+      @right_item = right_item
+    end
+
+    # :nocov:
+    def inspect()
+      if !@left_item.nil? && !@right_item.nil?
+        'Range(%s, %s, %s)' % [@symbole, @left_item.inspect, @right_item.inspect]
+      else
+        'Range(%s)' % [@symbole]
+      end
+    end
+    # :nocov:
+  end # Range
+end # Lexer
+end # Range
+end # TheFox

data/lib/thefox-ext/range/lexer/scope.rb

@@ -0,0 +1,9 @@
+
+module TheFox
+module Range
+module Lexer
+  class Scope < Base
+  end # Scope
+end # Lexer
+end # Range
+end # TheFox

data/lib/thefox-ext/range/lexer/separator.rb

@@ -0,0 +1,19 @@
+
+module TheFox
+module Range
+module Lexer
+  class Separator < Scope
+    def initialize()
+      super()
+      # puts '-> Separator.initialize()'
+    end
+
+    # :nocov:
+    def inspect()
+      'Separator'
+    end
+    # :nocov:
+  end # Separator
+end # Lexer
+end # Range
+end # TheFox

data/lib/thefox-ext/range/resolver.rb

@@ -0,0 +1,39 @@
+
+require 'pp'
+
+module TheFox
+module Range
+  # Resolve a range string to an array.
+  # A range string can be like '1, 3..5, 9-11, 12+, 14++, 17+++'.
+  # Which will be resolved to [1, 3, 4, 5, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20].
+  # '1' -> [1]
+  # '1,3,99' -> [1, 3, 99]
+  # '1-5' -> [1, 2, 3, 4, 5]
+  # '1+,5++' -> [1, 2, 5, 6, 7]
+  # '1-10/2' -> [1, 3, 5, 7, 9]
+  # '1{1}' -> [11]
+  # '1{5-7}' -> [15, 16, 17]
+  # '1{1,02}' -> [11, 102]
+  # '2{3{4,5},6}' -> [234, 235, 26]
+  # '1-3/1' -> [1, 2, 3]
+  # '1-10/2' -> [1, 3, 5, 7, 9]
+  # '2{10-20/2}' -> [210, 212, 214, 216, 218, 220]
+  class Resolver
+    def initialize(original = nil)
+      # puts '-> TheFox::Range::Resolver.initialize'
+      @original = original
+    end
+
+    def to_a
+      # puts '-> TheFox::Range::Resolver.to_a'
+
+      if @original.is_a?(String)
+        lexer = Lexer::Lexer.new(@original.split(''))
+        lexer.resolve
+      else
+        []
+      end
+    end
+  end # Resolver
+end # Range
+end # TheFox

data/lib/thefox-ext/version.rb

@@ -1,8 +1,8 @@
 
 module TheFox
   module Ext
-    VERSION = '1.9.0'
-    DATE = '2021-04-05'
+    VERSION = '2.0.0'
+    DATE = '2021-04-19'
     HOMEPAGE = 'https://github.com/TheFox/ext.rb'
   end
 end

data/thefox-ext.gemspec

@@ -19,9 +19,9 @@ Gem::Specification.new do |spec|
 
 	spec.files         = `git ls-files -z`.split("\x0").reject{ |f| f.match(%r{^(test|spec|features)/}) }
 	spec.require_paths = ['lib']
-	spec.required_ruby_version = ['>=2.3.0']
+	spec.required_ruby_version = ['>=2.4.0']
 
 	spec.add_development_dependency 'minitest', '~>5.8'
-	spec.add_development_dependency 'simplecov', '~>0.13'
+	spec.add_development_dependency 'simplecov', '~>0.18'
 	spec.add_development_dependency 'simplecov-phpunit', '~>1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: thefox-ext
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 2.0.0
 platform: ruby
 authors:
 - Christian Mayer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2021-04-05 00:00:00.000000000 Z
+date: 2021-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -30,14 +30,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.13'
+        version: '0.18'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.13'
+        version: '0.18'
 - !ruby/object:Gem::Dependency
   name: simplecov-phpunit
   requirement: !ruby/object:Gem::Requirement
@@ -64,6 +64,7 @@ files:
 - ".github/workflows/release.yml"
 - ".gitignore"
 - CHANGELOG-v1.md
+- CHANGELOG-v2.md
 - Gemfile
 - LICENSE
 - README.md
@@ -75,7 +76,6 @@ files:
 - bin/uninstall.sh
 - lib/thefox-ext.rb
 - lib/thefox-ext/console.rb
-- lib/thefox-ext/ext/array.rb
 - lib/thefox-ext/ext/date.rb
 - lib/thefox-ext/ext/false.rb
 - lib/thefox-ext/ext/hash.rb
@@ -83,6 +83,19 @@ files:
 - lib/thefox-ext/ext/nil.rb
 - lib/thefox-ext/ext/string.rb
 - lib/thefox-ext/ext/true.rb
+- lib/thefox-ext/range/lexer/base.rb
+- lib/thefox-ext/range/lexer/block.rb
+- lib/thefox-ext/range/lexer/block_down.rb
+- lib/thefox-ext/range/lexer/block_stack.rb
+- lib/thefox-ext/range/lexer/block_up.rb
+- lib/thefox-ext/range/lexer/interval.rb
+- lib/thefox-ext/range/lexer/lexer.rb
+- lib/thefox-ext/range/lexer/number.rb
+- lib/thefox-ext/range/lexer/operator.rb
+- lib/thefox-ext/range/lexer/range.rb
+- lib/thefox-ext/range/lexer/scope.rb
+- lib/thefox-ext/range/lexer/separator.rb
+- lib/thefox-ext/range/resolver.rb
 - lib/thefox-ext/version.rb
 - thefox-ext.code-workspace
 - thefox-ext.gemspec
@@ -98,14 +111,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.3.0
+      version: 2.4.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.3
+rubygems_version: 3.2.15
 signing_key: 
 specification_version: 4
 summary: Extended Ruby Classes

data/lib/thefox-ext/ext/array.rb

@@ -1,38 +0,0 @@
-
-class Array
-
-  # DEPRECATED: will be removed in v1.10.0.
-  def self.resolve_range_str(original_str, prefix = '')
-    warn "[DEPRECATION] `Array.resolve_range_str` is deprecated. Please use `String.resolve_range` instead."
-
-    rv = Array.new
-    if !original_str.is_a?(String)
-      return rv
-    end
-
-    original_str.split(',').map{ |item|
-      item_striped = item.strip
-      if /\.\./.match(item_striped) # ( . )( . ) <--- BOOBS
-        Range.new(*item_striped.split('..', 2).map{ |range| range.to_i })
-      elsif /-/.match(item_striped)
-        Range.new(*item_striped.split('-', 2).map{ |range| range.to_i })
-      elsif /\+/.match(item_striped)
-        items = item_striped.split('+')
-        range_begin = items[0].to_i
-        range_end = range_begin + item_striped.count('+')
-        Range.new(range_begin, range_end)
-      else
-        item_striped.to_i
-      end
-    }.each{ |range|
-      if range.is_a?(Range)
-        rv.push(*range.to_a)
-      else
-        rv << range
-      end
-    }
-
-    rv
-  end
-
-end