grizzly-rb 1.0.0

data/examples/transactions.rb

@@ -0,0 +1,278 @@
+require 'bundler/inline'
+
+gemfile do
+  source 'https://rubygems.org'
+  gem 'faker'
+  gem 'byebug'
+  gem 'grizzly-rb', path: '.', require: 'grizzly'
+end
+
+require "bigdecimal"
+
+# Model Definitions
+
+Transaction = Struct.new(:date, :price, :shares, :holding, keyword_init: true) do
+  def to_s
+    line = "%s | %s | %4s | %2s x %s = %5s"
+    format line, date, holding.ticker, type, shares.abs, price, value
+  end
+
+  def type
+    shares.negative? ? 'SELL' : 'BUY'
+  end
+
+  def value
+    shares * price
+  end
+
+  def ticker
+    holding.ticker
+  end
+
+  def industry
+    holding.industry
+  end
+end
+
+Holding = Struct.new(:ticker, :industry, :name, keyword_init: true) do
+  def to_s
+    "#{ticker} - #{name}"
+  end
+end
+
+class Portfolio < Grizzly::Collection
+  def total_shares
+    sum(&:shares)
+  end
+
+  def average_cost
+    value / BigDecimal(total_shares)
+  end
+
+  def value
+    sum(&:value)
+  end
+end
+
+# Seed data - holdings and transactions
+
+@holdings = {}
+@holdings["MAG"] = Holding.new(ticker: "MAG", industry: "Finance", name: "Maggio Group")
+@holdings["ARM"] = Holding.new(ticker: "ARM", industry: "Finance", name: "Armstrong and Sons")
+@holdings["CON"] = Holding.new(ticker: "CON", industry: "Finance", name: "Conn LLC")
+@holdings["THP"] = Holding.new(ticker: "THP", industry: "Mining",  name: "Tremblay-Hilpert")
+@holdings["FTB"] = Holding.new(ticker: "FTB", industry: "Mining",  name: "Fritsch-Bosco")
+@holdings["MGK"] = Holding.new(ticker: "MGK", industry: "Mining",  name: "MacGyver-Kilback")
+@holdings["SKI"] = Holding.new(ticker: "SKI", industry: "Technology",  name: "Skiles LLC")
+@holdings["VFL"] = Holding.new(ticker: "VFL", industry: "Technology",  name: "Von-Flatley")
+
+def setup(holdings = @holdings)
+  transactions = []
+  until transactions.count >= 100 && transactions.group_by(&:holding).all? { |holding, t| t.sum(&:shares) > 0 }
+    next if (shares = Faker::Number.between(from: -2, to: 5)).zero?
+    transactions << Transaction.new(
+      date: Faker::Date.between(from: '2022-01-01', to: '2022-12-31'),
+      price: Faker::Number.between(from: 200, to: 300),
+      shares: shares,
+      holding: holdings[holdings.keys.sample]
+    )
+  end
+  transactions
+end
+
+portfolio = Portfolio.new(setup)
+
+# Using grizzly-rb library to print financial data.
+
+puts "=== TRANSACTIONS SORTED BY DATE ==="
+puts
+puts portfolio.sort_by!(&:date)
+puts
+
+# === TRANSACTIONS SORTED BY DATE ===
+
+# 2022-01-04 | THP |  BUY |  3 x 231 =   693
+# 2022-01-14 | SKI |  BUY |  2 x 207 =   414
+# 2022-01-27 | FTB |  BUY |  1 x 269 =   269
+# 2022-02-01 | MGK |  BUY |  3 x 252 =   756
+# 2022-02-02 | FTB | SELL |  2 x 294 =  -588
+# 2022-02-05 | FTB |  BUY |  2 x 251 =   502
+# 2022-02-05 | VFL |  BUY |  5 x 278 =  1390
+# 2022-02-14 | ARM |  BUY |  5 x 220 =  1100
+# 2022-02-16 | THP |  BUY |  3 x 278 =   834
+# 2022-02-17 | MAG |  BUY |  4 x 224 =   896
+# 2022-02-27 | SKI |  BUY |  5 x 269 =  1345
+# 2022-02-28 | MAG | SELL |  1 x 278 =  -278
+# 2022-03-01 | CON |  BUY |  3 x 293 =   879
+# 2022-03-06 | SKI |  BUY |  4 x 206 =   824
+# 2022-03-21 | VFL |  BUY |  3 x 218 =   654
+# 2022-03-30 | MGK |  BUY |  2 x 225 =   450
+# 2022-03-31 | MAG |  BUY |  3 x 287 =   861
+# 2022-04-06 | MGK |  BUY |  5 x 212 =  1060
+# 2022-04-08 | VFL |  BUY |  1 x 272 =   272
+# 2022-04-12 | CON | SELL |  1 x 280 =  -280
+# 2022-04-14 | VFL |  BUY |  4 x 252 =  1008
+# 2022-04-26 | VFL | SELL |  2 x 285 =  -570
+# 2022-04-26 | MAG |  BUY |  3 x 214 =   642
+# 2022-04-28 | VFL |  BUY |  1 x 289 =   289
+# 2022-04-28 | CON |  BUY |  4 x 263 =  1052
+# 2022-04-28 | SKI |  BUY |  2 x 231 =   462
+# 2022-05-01 | VFL |  BUY |  2 x 256 =   512
+# 2022-05-02 | CON |  BUY |  3 x 220 =   660
+# 2022-05-05 | THP | SELL |  2 x 214 =  -428
+# 2022-05-10 | SKI | SELL |  1 x 255 =  -255
+# 2022-05-16 | MGK |  BUY |  1 x 276 =   276
+# 2022-05-23 | MAG |  BUY |  3 x 236 =   708
+# 2022-05-24 | FTB |  BUY |  3 x 204 =   612
+# 2022-05-29 | THP |  BUY |  2 x 206 =   412
+# 2022-05-29 | ARM |  BUY |  2 x 211 =   422
+# 2022-06-04 | MAG |  BUY |  4 x 234 =   936
+# 2022-06-07 | CON |  BUY |  3 x 218 =   654
+# 2022-06-07 | VFL |  BUY |  4 x 287 =  1148
+# 2022-06-07 | THP | SELL |  2 x 241 =  -482
+# 2022-06-09 | SKI |  BUY |  5 x 290 =  1450
+# 2022-06-11 | MAG |  BUY |  2 x 292 =   584
+# 2022-06-15 | MAG |  BUY |  2 x 238 =   476
+# 2022-06-19 | MGK |  BUY |  2 x 206 =   412
+# 2022-06-20 | VFL |  BUY |  3 x 293 =   879
+# 2022-06-25 | CON |  BUY |  5 x 201 =  1005
+# 2022-07-01 | SKI |  BUY |  2 x 225 =   450
+# 2022-07-06 | VFL |  BUY |  4 x 212 =   848
+# 2022-07-07 | CON |  BUY |  4 x 219 =   876
+# 2022-07-08 | FTB |  BUY |  2 x 261 =   522
+# 2022-07-09 | CON |  BUY |  3 x 263 =   789
+# 2022-07-11 | SKI |  BUY |  2 x 288 =   576
+# 2022-07-13 | CON | SELL |  1 x 215 =  -215
+# 2022-07-15 | MGK |  BUY |  4 x 241 =   964
+# 2022-07-17 | CON |  BUY |  2 x 295 =   590
+# 2022-07-18 | CON |  BUY |  4 x 254 =  1016
+# 2022-07-22 | FTB | SELL |  2 x 295 =  -590
+# 2022-08-01 | MAG |  BUY |  3 x 247 =   741
+# 2022-08-02 | THP |  BUY |  2 x 208 =   416
+# 2022-08-03 | MGK | SELL |  1 x 239 =  -239
+# 2022-08-04 | MAG |  BUY |  1 x 293 =   293
+# 2022-08-08 | FTB |  BUY |  4 x 259 =  1036
+# 2022-08-09 | THP |  BUY |  5 x 249 =  1245
+# 2022-08-24 | SKI |  BUY |  1 x 228 =   228
+# 2022-08-26 | FTB |  BUY |  1 x 285 =   285
+# 2022-08-28 | CON |  BUY |  2 x 297 =   594
+# 2022-08-28 | SKI |  BUY |  5 x 283 =  1415
+# 2022-08-29 | VFL |  BUY |  1 x 251 =   251
+# 2022-09-01 | MGK |  BUY |  3 x 201 =   603
+# 2022-09-01 | THP |  BUY |  5 x 229 =  1145
+# 2022-09-02 | MGK |  BUY |  5 x 228 =  1140
+# 2022-09-07 | THP |  BUY |  1 x 215 =   215
+# 2022-09-13 | FTB |  BUY |  4 x 292 =  1168
+# 2022-09-15 | VFL |  BUY |  4 x 218 =   872
+# 2022-09-20 | THP | SELL |  1 x 279 =  -279
+# 2022-09-24 | SKI |  BUY |  4 x 214 =   856
+# 2022-09-28 | FTB |  BUY |  3 x 300 =   900
+# 2022-10-07 | THP |  BUY |  5 x 236 =  1180
+# 2022-10-15 | MGK |  BUY |  2 x 208 =   416
+# 2022-10-15 | VFL | SELL |  2 x 217 =  -434
+# 2022-10-18 | CON | SELL |  2 x 232 =  -464
+# 2022-10-19 | MAG |  BUY |  1 x 241 =   241
+# 2022-10-22 | SKI |  BUY |  2 x 225 =   450
+# 2022-10-22 | THP |  BUY |  5 x 289 =  1445
+# 2022-10-23 | ARM |  BUY |  2 x 235 =   470
+# 2022-11-01 | THP |  BUY |  4 x 267 =  1068
+# 2022-11-02 | MAG |  BUY |  2 x 206 =   412
+# 2022-11-10 | VFL | SELL |  1 x 289 =  -289
+# 2022-11-13 | THP | SELL |  1 x 209 =  -209
+# 2022-11-15 | THP |  BUY |  2 x 253 =   506
+# 2022-11-15 | CON |  BUY |  5 x 258 =  1290
+# 2022-11-19 | MAG |  BUY |  5 x 246 =  1230
+# 2022-11-22 | MGK | SELL |  1 x 292 =  -292
+# 2022-11-30 | SKI |  BUY |  5 x 273 =  1365
+# 2022-12-02 | CON | SELL |  1 x 245 =  -245
+# 2022-12-03 | VFL |  BUY |  5 x 295 =  1475
+# 2022-12-08 | MAG |  BUY |  3 x 217 =   651
+# 2022-12-13 | ARM |  BUY |  5 x 285 =  1425
+# 2022-12-14 | SKI | SELL |  1 x 237 =  -237
+# 2022-12-26 | ARM |  BUY |  3 x 214 =   642
+# 2022-12-30 | MAG |  BUY |  4 x 229 =   916
+
+
+puts "=== TRANSACTIONS FOR MAG ==="
+puts
+mag = portfolio.select { |t| t.holding == @holdings["MAG"] }
+puts "%s %10.2f, shares: %4s, cost average: %8.2f" % [@holdings["MAG"], portfolio.value, portfolio.total_shares, portfolio.average_cost]
+puts mag
+puts
+
+# === TRANSACTIONS FOR MAG ===
+
+# MAG - Maggio Group   56640.00, shares:  230, cost average:   246.26
+# 2022-02-17 | MAG |  BUY |  4 x 224 =   896
+# 2022-02-28 | MAG | SELL |  1 x 278 =  -278
+# 2022-03-31 | MAG |  BUY |  3 x 287 =   861
+# 2022-04-26 | MAG |  BUY |  3 x 214 =   642
+# 2022-05-23 | MAG |  BUY |  3 x 236 =   708
+# 2022-06-04 | MAG |  BUY |  4 x 234 =   936
+# 2022-06-11 | MAG |  BUY |  2 x 292 =   584
+# 2022-06-15 | MAG |  BUY |  2 x 238 =   476
+# 2022-08-01 | MAG |  BUY |  3 x 247 =   741
+# 2022-08-04 | MAG |  BUY |  1 x 293 =   293
+# 2022-10-19 | MAG |  BUY |  1 x 241 =   241
+# 2022-11-02 | MAG |  BUY |  2 x 206 =   412
+# 2022-11-19 | MAG |  BUY |  5 x 246 =  1230
+# 2022-12-08 | MAG |  BUY |  3 x 217 =   651
+# 2022-12-30 | MAG |  BUY |  4 x 229 =   916
+
+
+puts "=== PORTFOLIO GROUPED BY TICKER === "
+puts
+portfolio
+  .sort_by(&:ticker)
+  .group_by(&:holding)
+  .each do |holding, portfolio|
+    puts "%-25s %10.2f, shares: %4s, cost average: %8.2f" % [holding.name, portfolio.value, portfolio.total_shares, portfolio.average_cost]
+  end
+puts '-' * 74
+puts "%-25s %10.2f, shares: %4s, cost average: %8.2f" % ["Portfolio total value:", portfolio.value, portfolio.total_shares, portfolio.average_cost]
+puts
+
+# === PORTFOLIO GROUPED BY TICKER ===
+
+# Portfolio total value:      56640.00, shares:  230, cost average:   246.26
+# Armstrong and Sons           4059.00, shares:   17, cost average:   238.76
+# Conn LLC                     8201.00, shares:   33, cost average:   248.52
+# Fritsch-Bosco                4116.00, shares:   16, cost average:   257.25
+# Maggio Group                 9309.00, shares:   39, cost average:   238.69
+# MacGyver-Kilback             5546.00, shares:   25, cost average:   221.84
+# Skiles LLC                   9343.00, shares:   37, cost average:   252.51
+# Tremblay-Hilpert             7761.00, shares:   31, cost average:   250.35
+# Von-Flatley                  8305.00, shares:   32, cost average:   259.53
+
+
+puts "=== PORTFOLIO GROUPED BY INDUSTRY ==="
+puts
+
+portfolio
+  .sort_by { |transaction| [transaction.industry, transaction.ticker] }
+  .group_by(&:industry)
+  .each do |(industry, portfolio)|
+    puts "%-25s %10.2f, shares: %4s, cost average: %8.2f" % [industry, portfolio.value, portfolio.total_shares, portfolio.average_cost]
+    portfolio
+      .group_by(&:holding)
+      .each do |(holding, portfolio)|
+        puts "  - %-21s %10.2f, shares: %4s, cost average: %8.2f" % [holding.name, portfolio.value, portfolio.total_shares, portfolio.average_cost]
+      end
+    puts
+  end
+
+# === PORTFOLIO GROUPED BY INDUSTRY ===
+
+# Finance                     21569.00, shares:   89, cost average:   242.35
+#   - Armstrong and Sons       4059.00, shares:   17, cost average:   238.76
+#   - Conn LLC                 8201.00, shares:   33, cost average:   248.52
+#   - Maggio Group             9309.00, shares:   39, cost average:   238.69
+
+# Mining                      17423.00, shares:   72, cost average:   241.99
+#   - Fritsch-Bosco            4116.00, shares:   16, cost average:   257.25
+#   - MacGyver-Kilback         5546.00, shares:   25, cost average:   221.84
+#   - Tremblay-Hilpert         7761.00, shares:   31, cost average:   250.35
+
+# Technology                  17648.00, shares:   69, cost average:   255.77
+#   - Skiles LLC               9343.00, shares:   37, cost average:   252.51
+#   - Von-Flatley              8305.00, shares:   32, cost average:   259.53

data/grizzly-group.gemspec

@@ -0,0 +1,28 @@
+require_relative 'lib/grizzly/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "grizzly-rb"
+  spec.version       = Grizzly::VERSION
+  spec.authors       = ["Alexandre Barret"]
+  spec.email         = ["alexbarret@duck.com"]
+
+  spec.summary       = "An Array subclass for Ruby"
+  spec.homepage      = "https://github.com/AlexB52/grizzly-rb"
+  spec.license       = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/AlexB52/grizzly-rb"
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+end

data/lib/grizzly/collection.rb

@@ -0,0 +1,77 @@
+
+module Grizzly
+  class Collection < Array
+    include Grizzly::Enumerable
+
+    %i[
+      each collect! map! sort_by! * pop shift drop_while take_while bsearch_index
+      bsearch combination delete_if each_index keep_if find_index index permutation
+      repeated_combination repeated_permutation reverse_each rindex max min
+    ].each do |method_name|
+      define_method(method_name) do |*args, &block|
+        subgroup super(*args, &block)
+      end
+    end
+
+    %i[
+      values_at rotate compact reverse intersection & | + union - difference
+      flatten drop take
+    ].each do |method_name|
+      define_method(method_name) do |*args|
+        new_collection super(*args)
+      end
+    end
+
+    def transpose(*args)
+      result = super
+      if self.all? { |collection| collection.is_a?(self.class) }
+        result = result.map { |collection| new_collection(collection) }
+      end
+      new_collection(result)
+    end
+
+    def product(*args)
+      result = super
+      return result if is_self?(result)
+      return result unless result.is_a?(Array)
+
+      result.map {|product| new_collection(product)}
+    end
+
+    def last(*args)
+      result = super
+      return result if args == []
+
+      subgroup(result)
+    end
+
+    def slice(*args)
+      result = super
+      return result if args.count == 1 && args.first.is_a?(Integer)
+
+      subgroup(result)
+    end
+
+    def slice!(*args)
+      result = super
+      return result if args.count == 1 && args.first.is_a?(Integer)
+
+      subgroup(result)
+    end
+
+    def [](*args)
+      result = super
+      return result if args.count == 1 && args.first.is_a?(Integer)
+
+      subgroup(result)
+    end
+
+    def sample(*args, **karg)
+      subgroup(super)
+    end
+
+    def shuffle(*args, **kargs)
+      new_collection(super)
+    end
+  end
+end

data/lib/grizzly/enumerable.rb

@@ -0,0 +1,120 @@
+module Grizzly
+  module Enumerable
+    include ::Enumerable
+
+    %i[
+      max min minmax_by sort_by find_all filter_map reject reject! filter filter!
+      select select! take_while reverse_each min_by max_by find_index drop_while
+      chunk chunk_while each_slice each_cons each_entry each_with_index flat_map
+      collect_concat find detect uniq collect map
+    ].each do |method_name|
+      define_method(method_name) do |*args, &block|
+        subgroup super(*args, &block)
+      end
+    end
+
+    %i[minmax sort].each do |method_name|
+      define_method(method_name) do |*args, &block|
+        subgroup super(*args, &block)
+      end
+    end
+
+    %i[to_enum slice_when slice_before slice_after].each do |method_name|
+      define_method(method_name) do |*args, &block|
+        new_enumerator super(*args, &block)
+      end
+    end
+
+    def grep(*args)
+      raise NotImplementedError, "#{__method__} can't be supported. See https://bugs.ruby-lang.org/issues/11808"
+    end
+
+    def grep_v(*args)
+      raise NotImplementedError, "#{__method__} can't be supported. See https://bugs.ruby-lang.org/issues/11808"
+    end
+
+    def zip(*other_arrays)
+      result = super
+      return result unless result.is_a?(Array)
+
+      type = :self
+      other_arrays.each do |array|
+        case array
+        when self.class
+        when Grizzly::Collection
+          type = :group
+        else
+          type = :array
+          break
+        end
+      end
+
+      case type
+      when :self  then result.map { |a| new_collection(a) }
+      when :group then result.map { |a| Grizzly::Collection.new(a) }
+      else             result
+      end
+    end
+
+    def partition(*args)
+      result = super
+      return new_enumerator(result) if result.is_a?(::Enumerator)
+      return result unless result.is_a?(Array)
+
+      [new_collection(result[0]), new_collection(result[1])]
+    end
+
+    def group_by(*args)
+      result = super
+      return new_enumerator(result) if result.is_a?(::Enumerator)
+      return result unless result.is_a?(Hash)
+
+      result.each do |key, value|
+        result[key] = new_collection(value)
+      end
+    end
+
+    def first(*args)
+      result = super
+      return result if args == []
+
+      subgroup(result)
+    end
+
+    # Lazy related methods
+
+    def lazy
+      new_lazy_enumerator(super)
+    end
+
+    private
+
+    def subgroup(result)
+      return result if is_self?(result)
+      return new_enumerator(result) if result.is_a?(::Enumerator)
+      return result unless result.is_a?(Array)
+
+      new_collection(result)
+    end
+
+    def instantiating_class
+      self.class
+    end
+
+    def new_collection(array)
+      instantiating_class.new(array)
+    end
+
+    def new_enumerator(enum)
+      Grizzly::Enumerator.new(enum, instantiating_class: instantiating_class)
+    end
+
+    def new_lazy_enumerator(lazy)
+      Grizzly::LazyEnumerator.new(lazy, instantiating_class: instantiating_class)
+    end
+
+    def is_self?(obj)
+      obj.object_id.eql? object_id
+    end
+  end
+end

data/lib/grizzly/enumerator-backup.rb

@@ -0,0 +1,114 @@
+require 'forwardable'
+
+module Grizzly
+  class Enumerator
+    extend Forwardable
+
+    def_delegators :@enum, *%i{
+      + first feed to_a
+      next next_values
+      peek peek_values
+    }
+
+    attr_reader :enum, :obj, :method_name, :args
+    def initialize(obj, method_name = :each, *args, size: nil, &block)
+      @obj = obj
+      @args = args
+      @size = size
+      @method_name = method_name
+      if block_given?
+        @enum = ::Enumerator.new(obj, &block)
+      else
+        @enum = obj.to_enum(method_name, *args)
+      end
+    end
+
+    def each(*args, &block)
+      unless block_given?
+        return args.any? ? new_enumerator(enum, __method__, *args) : self
+      end
+
+      enum.each(*args, &block)
+    end
+
+    def with_index(offset = 0, &block)
+      unless block_given?
+        return new_enumerator(self, __method__, offset)
+      end
+
+      enum.with_index(offset, &block)
+    end
+
+    def each_with_index(&block)
+      with_index(&block)
+    end
+
+    def with_object(object, &block)
+      unless block_given?
+        return new_enumerator(self, __method__, object)
+      end
+
+      enum.with_object(object, &block)
+    end
+    alias :each_with_object :with_object
+
+    def inspect
+      enum.inspect.gsub('Enumerator', self.class.to_s)
+    end
+
+    def size
+      return obj.call if obj.respond_to?(:call)
+
+      @size || enum.size || obj.size if obj.respond_to?(:size)
+    end
+
+    def rewind
+      enum.rewind && self
+    end
+
+    private
+
+    def new_enumerator(obj, method_name, *args)
+      self.class.new obj, method_name, *args, size: size
+    end
+  end
+
+  # class Enumerator < Enumerator
+  #   extend Forwardable
+
+  #   OVERRIDE_METHODS = %i{with_index with_object each_with_index each_with_object}
+  #   ENUMERATOR_METHODS = Enumerator.public_instance_methods(false)
+  #   ENUMERABLE_METHODS = Enumerable.public_instance_methods
+
+  #   alias :old_enum :to_enum
+
+  #   def_delegators :@enum, *ENUMERATOR_METHODS
+
+  #   ENUMERABLE_METHODS.each do |method_name|
+  #     define_method(method_name) do |*args, &block|
+  #       return to_enum(__method__, *args) unless block
+
+  #       @object.send(__method__, *args, &block)
+  #     end
+  #   end
+
+  #   OVERRIDE_METHODS.each do |method_name|
+  #     define_method(method_name) do |*args, &block|
+  #       return to_enum(__method__, *args) unless block
+
+  #       @enum.send(:each, *args, &block)
+  #     end
+  #   end
+
+  #   attr_reader :object, :enum
+
+  #   def initialize(object, method_name, *args)
+  #     @object = object
+  #     @enum = object.to_enum(method_name, *args)
+  #   end
+
+  #   def to_enum(method_name, *args)
+  #     self.class.new @object, method_name, *args
+  #   end
+  # end
+end

data/lib/grizzly/enumerator.rb

@@ -0,0 +1,63 @@
+require 'forwardable'
+
+module Grizzly
+  class Enumerator
+    extend Forwardable
+    include ::Grizzly::Enumerable
+
+    def_delegators :@enum, *%i{
+      + first feed to_a
+      next next_values
+      peek peek_values
+      size
+    }
+
+    attr_reader :enum, :instantiating_class
+    def initialize(enum, instantiating_class: Array)
+      @enum = enum
+      @instantiating_class = instantiating_class
+    end
+
+    def each(*args, &block)
+      return self if args.empty? && !block_given?
+
+      unless block_given?
+        return new_enumerator(enum.each(*args))
+      end
+
+      enum.each(*args, &block)
+    end
+
+    def with_index(offset = 0, &block)
+      unless block_given?
+        return new_enumerator(@enum.with_index(offset))
+      end
+
+      enum.with_index(offset, &block)
+    end
+
+    def each_with_index(&block)
+      with_index(&block)
+    end
+
+    def rewind
+      enum.rewind && self
+    end
+
+    def with_object(object, &block)
+      unless block_given?
+        return new_enumerator(@enum.with_object(object))
+      end
+
+      enum.with_object(object, &block)
+    end
+
+    def each_with_object(object, &block)
+      with_object(object, &block)
+    end
+
+    def inspect
+      enum.inspect.gsub(/(?<!Grizzly::)Enumerator/, self.class.to_s)
+    end
+  end
+end