merge_enum 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 83c9df67a3bf180ed443689aa752ffb05daa2776
-  data.tar.gz: eafcdd7dfa4844eab8b96e1bb0dd31670ee19e58
+  metadata.gz: 7a7cbcc12b63d8c7a55b8d4c4d3f8de7a749c400
+  data.tar.gz: 197e9e1c595d09167bf84fec15ee6488febd3f15
 SHA512:
-  metadata.gz: 6feac7d52703573869924e008a5dbea02ea08a2ec204a4e935147e1bc5e367cb4827c1d643790ba7bb77bc77e891fdc40e3b7db1db052e9a58866be60df973f4
-  data.tar.gz: 21a08e2bcf620c15a2e95e3aa978738c86b4a005dece07d97a1fd22a2c827d24bbc3fec8615644ffe084800fe1ee77124e51fc8ecf16574a086a286cbff5a5dd
+  metadata.gz: 6f3eb08663c8186902352a71b5b007bdb08f4214087a0f18b578d48e3a01af04bd760824db481a351aa4c7d6e27f5dda7c9b949f887d829d5141bb5650663a1f
+  data.tar.gz: ea1d6992ceeff7c5832f8c01e6187a40672379db773f4215841005d07666114f1ce7adb49af717ffebf95e0235727f7c61b09bf3f66449a890081798abccbc0d

data/Gemfile

@@ -3,5 +3,5 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in merge_enum.gemspec
 gemspec
 
-gem 'rspec'
+gem 'rspec', '~> 3.0.0.beta2'
 

data/README.md

@@ -1,5 +1,5 @@
 # MergeEnum
-###### ver 0.2.2
+###### ver 0.3.0
 
 複数のEnumerale(*1)を連結（合成）するEnumerableです。  
 要素が必要になった時点で追加するように動作します。  
@@ -67,7 +67,7 @@ Or install it yourself as:
 
 * `MergeEnum::MergeEnumerable.new(enum_1, enum_2, ... , options = {})`  
     `enum_x`  : Enumerable(*1)、もしくは、Enumerable(*1)を返すProcオブジェクト  
-    `options` : ハッシュ形式のオプション `{ first: <Integer:要素を取得する最大サイズ> }`
+    `options` : ハッシュ形式のオプション `{ first: <Integer:要素を取得する最大サイズ>, compact: <bool|Proc:nilを判定して除去する> }`
 
 * `Enumerable#merge_enum(enum_2, enum_3, ... , options = {})`  
     レシーバ自身を`enum_1`として、`MergeEnumerable.new(enum_1, enum_2, enum_3, ... , options)`を返します

data/lib/merge_enum/merge_enumerable.rb

@@ -16,34 +16,63 @@ module MergeEnum
 
     def each &block
       return self.to_enum unless block_given?
-      cnt = 0
+
+      # options
       opt_fst = @options[:first]
+      opt_fst = opt_fst.to_i if opt_fst
+      opt_cmpct = @options[:compact]
+      opt_cmpct_proc = if opt_cmpct.is_a? Proc
+                         if opt_cmpct.arity == 0
+                           -> (e) { opt_cmpct.call }
+                         else
+                           opt_cmpct
+                         end
+                       elsif opt_cmpct
+                         -> (e) { e.nil? }
+                       else
+                         -> (e) { false }
+                       end
+
+      # local variables
+      cnt = 0
       fst = nil
+
       @collections.each do |c|
         if opt_fst
           fst = opt_fst - cnt
           break if fst <= 0
         end
+
+        # get enumerable
         called_first = false
         if c.is_a? Proc
-          if c.arity == 0
+          case c.arity
+          when 0
             c = c.call
-          else
+          when 1
             c = c.call fst
             called_first = true
+          else
+            c = c.call fst, opt_cmpct
+            called_first = true
           end
         end
+
         if fst
-          c = c.first fst unless called_first
+          # with first option
+          c = c.first fst unless called_first or opt_cmpct
           _cnt = 0
-          c.each.with_index 1 do |e, i|
+          c.each do |e|
+            next if opt_cmpct_proc.call e
             block.call e
-            _cnt = i
+            _cnt += 1
             break if fst <= _cnt
           end
           cnt += _cnt
         else
+          # without first option
           c.each do |e|
+            next if opt_cmpct_proc.call e
             block.call e
           end
         end

data/lib/merge_enum/version.rb

@@ -1,5 +1,5 @@
 # encoding: utf-8
 module MergeEnum
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end
 

data/spec/merge_enum/merge_enumerable_spec.rb

@@ -3,221 +3,364 @@ require File.expand_path(File.join('../', 'spec_helper'), File.dirname(__FILE__)
 
 describe MergeEnum::MergeEnumerable do
 
-  describe "No Arguments to MergeEnumerable" do
+  describe "No Arguments to MergeEnumerable:" do
     it "count" do
       enum = MergeEnum::MergeEnumerable.new
       expect(enum.count).to be 0
     end
-    it "option_first" do
-      enum = MergeEnum::MergeEnumerable.new first: 50
-      expect(enum.count).to be 0
-    end
-    it "option_first negative" do
-      enum = MergeEnum::MergeEnumerable.new first: -50
-      expect(enum.count).to be 0
-    end
-    it "option_first nil" do
-      enum = MergeEnum::MergeEnumerable.new first: nil
-      expect(enum.count).to be 0
-    end
-    it "option_first false" do
-      enum = MergeEnum::MergeEnumerable.new first: false
-      expect(enum.count).to be 0
-    end
-    it "option_first true" do
-      enum = MergeEnum::MergeEnumerable.new first: true
-      expect(enum.count).to be 0
+
+    describe "option_first is" do
+      it "positive" do
+        enum = MergeEnum::MergeEnumerable.new first: 50
+        expect(enum.count).to be 0
+      end
+      it "negative" do
+        enum = MergeEnum::MergeEnumerable.new first: -50
+        expect(enum.count).to be 0
+      end
+      it "nil" do
+        enum = MergeEnum::MergeEnumerable.new first: nil
+        expect(enum.count).to be 0
+      end
+      it "false" do
+        enum = MergeEnum::MergeEnumerable.new first: false
+        expect(enum.count).to be 0
+      end
+      it "true" do
+        enum = MergeEnum::MergeEnumerable.new first: true
+        expect{ enum.count }.to raise_error NoMethodError
+      end
+      it "illegal" do
+        enum = MergeEnum::MergeEnumerable.new first: "hoge"
+        expect(enum.count).to be 0
+      end
     end
-    it "option_first illegal" do
-      enum = MergeEnum::MergeEnumerable.new first: "hoge"
-      expect(enum.count).to be 0
+
+    describe "option_compact is" do
+      it "true" do
+        enum = MergeEnum::MergeEnumerable.new compact: true
+        expect(enum.count).to be 0
+      end
+      it "false" do
+        enum = MergeEnum::MergeEnumerable.new compact: false
+        expect(enum.count).to be 0
+      end
+      it "nil" do
+        enum = MergeEnum::MergeEnumerable.new compact: nil
+        expect(enum.count).to be 0
+      end
+      it "Proc" do
+        enum = MergeEnum::MergeEnumerable.new compact: Proc.new {}
+        expect(enum.count).to be 0
+      end
+      it "Lambda" do
+        enum = MergeEnum::MergeEnumerable.new compact: -> {}
+        expect(enum.count).to be 0
+      end
     end
   end
 
-  describe "Empty Array to MergeEnumerable" do
+  describe "Empty Array to MergeEnumerable:" do
     it "count" do
       enum = MergeEnum::MergeEnumerable.new []
       expect(enum.count).to be 0
     end
-    it "option_first" do
-      enum = MergeEnum::MergeEnumerable.new [], first: 50
-      expect(enum.count).to be 0
-    end
-    it "option_first negative" do
-      enum = MergeEnum::MergeEnumerable.new [], first: -50
-      expect(enum.count).to be 0
-    end
-    it "option_first nil" do
-      enum = MergeEnum::MergeEnumerable.new [], first: nil
-      expect(enum.count).to be 0
-    end
-    it "option_first false" do
-      enum = MergeEnum::MergeEnumerable.new [], first: false
-      expect(enum.count).to be 0
-    end
-    it "option_first true" do
-      enum = MergeEnum::MergeEnumerable.new [], first: true
-      expect{ enum.count }.to raise_error NoMethodError
+
+    describe "option_first" do
+      it "positive" do
+        enum = MergeEnum::MergeEnumerable.new [], first: 50
+        expect(enum.count).to be 0
+      end
+      it "negative" do
+        enum = MergeEnum::MergeEnumerable.new [], first: -50
+        expect(enum.count).to be 0
+      end
+      it "nil" do
+        enum = MergeEnum::MergeEnumerable.new [], first: nil
+        expect(enum.count).to be 0
+      end
+      it "false" do
+        enum = MergeEnum::MergeEnumerable.new [], first: false
+        expect(enum.count).to be 0
+      end
+      it "true" do
+        enum = MergeEnum::MergeEnumerable.new [], first: true
+        expect{ enum.count }.to raise_error NoMethodError
+      end
+      it "with to_i" do
+        enum = MergeEnum::MergeEnumerable.new 0...100, first: "hoge"
+        expect(enum.count).to be 0
+      end
+      it "with to_i" do
+        enum = MergeEnum::MergeEnumerable.new 0...100, first: "10hoge"
+        expect(enum.count).to be 10
+      end
     end
-    it "option_first illegal" do
-      enum = MergeEnum::MergeEnumerable.new [], first: "hoge"
-      expect{ enum.count }.to raise_error NoMethodError
+
+    describe "option_compact" do
+      it "true" do
+        enum = MergeEnum::MergeEnumerable.new [], compact: true
+        expect(enum.count).to be 0
+      end
+      it "false" do
+        enum = MergeEnum::MergeEnumerable.new [], compact: false
+        expect(enum.count).to be 0
+      end
+      it "nil" do
+        enum = MergeEnum::MergeEnumerable.new [], compact: nil
+        expect(enum.count).to be 0
+      end
+      it "Proc" do
+        enum = MergeEnum::MergeEnumerable.new [], compact: Proc.new {}
+        expect(enum.count).to be 0
+      end
+      it "Lambda" do
+        enum = MergeEnum::MergeEnumerable.new [], compact: -> {}
+        expect(enum.count).to be 0
+      end
     end
   end
 
-  describe "Illegal Argument to MergeEnumerable" do
+  describe "Illegal Argument to MergeEnumerable:" do
     it "illegal argument" do
       enum = MergeEnum::MergeEnumerable.new "hoge"
       expect{ enum.count }.to raise_error NoMethodError
     end
   end
 
-  describe "One Enumerable to MergeEnumerable" do
+  describe "One Enumerable to MergeEnumerable:" do
     it "count" do
       enum = MergeEnum::MergeEnumerable.new 0...100
       expect(enum.count).to be 100
     end
-    it "option_first limited" do
-      enum = MergeEnum::MergeEnumerable.new 0...100, first: 50
-      expect(enum.count).to be 50
+
+    describe "option_first" do
+      it "limited" do
+        enum = MergeEnum::MergeEnumerable.new 0...100, first: 50
+        expect(enum.count).to be 50
+      end
+      it "over" do
+        enum = MergeEnum::MergeEnumerable.new 0...100, first: 200
+        expect(enum.count).to be 100
+      end
     end
-    it "option_first over" do
-      enum = MergeEnum::MergeEnumerable.new 0...100, first: 200
-      expect(enum.count).to be 100
+
+    describe "option_compact" do
+      it "true" do
+        ary = (0...100).map { |e| e.odd? ? e : nil }
+        expect(ary.compact.count).to be 50
+        expect(ary.count).to be 100
+        enum = MergeEnum::MergeEnumerable.new ary, compact: true
+        expect(enum.count).to be 50
+      end
+      it "false" do
+        ary = (0...100).map { |e| e.odd? ? e : nil }
+        enum = MergeEnum::MergeEnumerable.new ary, compact: false
+        expect(enum.count).to be 100
+      end
+      it "nil" do
+        ary = (0...100).map { |e| e.odd? ? e : nil }
+        enum = MergeEnum::MergeEnumerable.new ary, compact: nil
+        expect(enum.count).to be 100
+      end
+      it "Proc with no args" do
+        ary = (0...100).map { |e| e.odd? ? e : nil }
+        _proc = Proc.new { true }
+        enum = MergeEnum::MergeEnumerable.new ary, compact: _proc
+        expect(enum.count).to be 0
+
+        _proc = Proc.new { false }
+        enum = MergeEnum::MergeEnumerable.new ary, compact: _proc
+        expect(enum.count).to be 100
+      end
+      it "Proc with args" do
+        ary = (0...100).map { |e| e.odd? ? e : nil }
+        _proc = Proc.new { |e| e.nil? }
+        enum = MergeEnum::MergeEnumerable.new ary, compact: _proc
+        expect(enum.count).to be 50
+
+        ary = 0...100
+        _proc = Proc.new { |e| e < 30 }
+        enum = MergeEnum::MergeEnumerable.new ary, compact: _proc
+        expect(enum.count).to be 70
+      end
+      it "Lambda with no args" do
+        ary = (0...100).map { |e| e.odd? ? e : nil }
+        _proc = -> { true }
+        enum = MergeEnum::MergeEnumerable.new ary, compact: _proc
+        expect(enum.count).to be 0
+        _proc = -> { false }
+        enum = MergeEnum::MergeEnumerable.new ary, compact: _proc
+        expect(enum.count).to be 100
+      end
+      it "Lambda with args" do
+        ary = (0...100).map { |e| e.odd? ? e : nil }
+        _proc = -> (e) { e.nil? }
+        enum = MergeEnum::MergeEnumerable.new ary, compact: _proc
+        expect(enum.count).to be 50
+
+        ary = 0...100
+        _proc = -> (e) { e < 30 }
+        enum = MergeEnum::MergeEnumerable.new ary, compact: _proc
+        expect(enum.count).to be 70
+      end
+      it "with option_first" do
+        ary = (0...100).map { |e| e.odd? ? e : nil }
+        _proc = -> (e) { e.nil? }
+        enum = MergeEnum::MergeEnumerable.new ary, first: 30, compact: _proc
+        expect(enum.count).to be 30
+
+        enum = MergeEnum::MergeEnumerable.new ary, first: 60, compact: _proc
+        expect(enum.count).to be 50
+      end
     end
   end
 
-  describe "Two Enumerables to MergeEnumerable" do
+  describe "Two Enumerables to MergeEnumerable:" do
     it "count" do
       enum = MergeEnum::MergeEnumerable.new 0...100, 200...250
       expect(enum.count).to be 150
     end
-    it "option_first limited at first" do
-      enum = MergeEnum::MergeEnumerable.new 0...100, 200...250, first: 50
-      expect(enum.count).to be 50
-    end
-    it "option_first limited at second" do
-      enum = MergeEnum::MergeEnumerable.new 0...100, 200...250, first: 130
-      expect(enum.count).to be 130
-    end
-    it "option_first over" do
-      enum = MergeEnum::MergeEnumerable.new 0...100, 200...250, first: 200
-      expect(enum.count).to be 150
+
+    describe "option_first" do
+      it "limited at first" do
+        enum = MergeEnum::MergeEnumerable.new 0...100, 200...250, first: 50
+        expect(enum.count).to be 50
+      end
+      it "limited at second" do
+        enum = MergeEnum::MergeEnumerable.new 0...100, 200...250, first: 130
+        expect(enum.count).to be 130
+      end
+      it "over" do
+        enum = MergeEnum::MergeEnumerable.new 0...100, 200...250, first: 200
+        expect(enum.count).to be 150
+      end
     end
   end
 
-  describe "Three Enumerables to MergeEnumerable" do
+  describe "Three Enumerables to MergeEnumerable:" do
     it "count" do
       enum = MergeEnum::MergeEnumerable.new 0...100, 200...250, 300...330
       expect(enum.count).to be 180
     end
-    it "option_first limited at first" do
-      enum = MergeEnum::MergeEnumerable.new 0...100, 200...250, 300...330, first: 50
-      expect(enum.count).to be 50
-    end
-    it "option_first limited at second" do
-      enum = MergeEnum::MergeEnumerable.new 0...100, 200...250, 300...330, first: 130
-      expect(enum.count).to be 130
-    end
-    it "option_first limited at third" do
-      enum = MergeEnum::MergeEnumerable.new 0...100, 200...250, 300...330, first: 170
-      expect(enum.count).to be 170
-    end
-    it "option_first over" do
-      enum = MergeEnum::MergeEnumerable.new 0...100, 200...250, 300...330, first: 200
-      expect(enum.count).to be 180
+
+    describe "option_first" do
+      it "limited at first" do
+        enum = MergeEnum::MergeEnumerable.new 0...100, 200...250, 300...330, first: 50
+        expect(enum.count).to be 50
+      end
+      it "limited at second" do
+        enum = MergeEnum::MergeEnumerable.new 0...100, 200...250, 300...330, first: 130
+        expect(enum.count).to be 130
+      end
+      it "limited at third" do
+        enum = MergeEnum::MergeEnumerable.new 0...100, 200...250, 300...330, first: 170
+        expect(enum.count).to be 170
+      end
+      it "over" do
+        enum = MergeEnum::MergeEnumerable.new 0...100, 200...250, 300...330, first: 200
+        expect(enum.count).to be 180
+      end
     end
   end
 
-  describe "Lambda to MergeEnumerable" do
-    it "option_first limited at first" do
-      enum = MergeEnum::MergeEnumerable.new(
-        -> { 0...100 },
-        -> { 200...250 },
-        first: 50
-      )
-      expect(enum.count).to be 50
-    end
-    it "option_first over" do
-      enum = MergeEnum::MergeEnumerable.new(
-        -> { 0...100 },
-        -> { 200...250 },
-        first: 200
-      )
-      expect(enum.count).to be 150
+  describe "Lambda to MergeEnumerable:" do
+    describe "option_first" do
+      it "limited at first" do
+        enum = MergeEnum::MergeEnumerable.new(
+          -> { 0...100 },
+          -> { 200...250 },
+          first: 50
+        )
+        expect(enum.count).to be 50
+      end
+      it "over" do
+        enum = MergeEnum::MergeEnumerable.new(
+          -> { 0...100 },
+          -> { 200...250 },
+          first: 200
+        )
+        expect(enum.count).to be 150
+      end
     end
   end
 
-  describe "Lambda with Arguments to MergeEnumerable" do
-    it "option_first limited at first" do
-      arg1, arg2 = nil, nil
-      enum = MergeEnum::MergeEnumerable.new(
-        -> (c) { arg1 = c; 0...100 },
-        -> (c) { raise "unexpect"; 200...250 },
-        first: 50
-      )
-      expect(enum.count).to be 50
-      expect(arg1).to be 50
-      expect(arg2).to be_nil
-    end
-    it "option_first over" do
-      arg1, arg2 = nil, nil
-      enum = MergeEnum::MergeEnumerable.new(
-        -> (c) { arg1 = c; 0...100 },
-        -> (c) { arg2 = c; 200...250 },
-        first: 200
-      )
-      expect(enum.count).to be 150
-      expect(arg1).to be 200
-      expect(arg2).to be 100
+  describe "Lambda with Arguments to MergeEnumerable:" do
+    describe "option_first" do
+      it "limited at first" do
+        arg1, arg2 = nil, nil
+        enum = MergeEnum::MergeEnumerable.new(
+          -> (c) { arg1 = c; 0...100 },
+          -> (c) { raise "unexpect"; 200...250 },
+          first: 50
+        )
+        expect(enum.count).to be 50
+        expect(arg1).to be 50
+        expect(arg2).to be_nil
+      end
+      it "over" do
+        arg1, arg2 = nil, nil
+        enum = MergeEnum::MergeEnumerable.new(
+          -> (c) { arg1 = c; 0...100 },
+          -> (c) { arg2 = c; 200...250 },
+          first: 200
+        )
+        expect(enum.count).to be 150
+        expect(arg1).to be 200
+        expect(arg2).to be 100
+      end
     end
   end
 
-  describe "Proc to MergeEnumerable" do
-    it "option_first limited at first" do
-      enum = MergeEnum::MergeEnumerable.new(
-        Proc.new { 0...100 },
-        Proc.new { 200...250 },
-        first: 50
-      )
-      expect(enum.count).to be 50
-    end
-    it "option_first over" do
-      enum = MergeEnum::MergeEnumerable.new(
-        Proc.new { 0...100 },
-        Proc.new { 200...250 },
-        first: 200
-      )
-      expect(enum.count).to be 150
+  describe "Proc to MergeEnumerable:" do
+    describe "option_first" do
+      it "limited at first" do
+        enum = MergeEnum::MergeEnumerable.new(
+          Proc.new { 0...100 },
+          Proc.new { 200...250 },
+          first: 50
+        )
+        expect(enum.count).to be 50
+      end
+      it "over" do
+        enum = MergeEnum::MergeEnumerable.new(
+          Proc.new { 0...100 },
+          Proc.new { 200...250 },
+          first: 200
+        )
+        expect(enum.count).to be 150
+      end
     end
   end
 
-  describe "Proc with Arguments to MergeEnumerable" do
-    it "option_first limited at first" do
-      arg1, arg2 = nil, nil
-      enum = MergeEnum::MergeEnumerable.new(
-        Proc.new { |c| arg1 = c; 0...100 },
-        Proc.new { |c| raise "unexpect"; 200...250 },
-        first: 50
-      )
-      expect(enum.count).to be 50
-      expect(arg1).to be 50
-      expect(arg2).to be_nil
-    end
-    it "option_first over" do
-      arg1, arg2 = nil, nil
-      enum = MergeEnum::MergeEnumerable.new(
-        Proc.new { |c| arg1 = c; 0...100 },
-        Proc.new { |c| arg2 = c; 200...250 },
-        first: 200
-      )
-      expect(enum.count).to be 150
-      expect(arg1).to be 200
-      expect(arg2).to be 100
+  describe "Proc with Arguments to MergeEnumerable:" do
+    describe "option_first" do
+      it "limited at first" do
+        arg1, arg2 = nil, nil
+        enum = MergeEnum::MergeEnumerable.new(
+          Proc.new { |c| arg1 = c; 0...100 },
+          Proc.new { |c| raise "unexpect"; 200...250 },
+          first: 50
+        )
+        expect(enum.count).to be 50
+        expect(arg1).to be 50
+        expect(arg2).to be_nil
+      end
+      it "over" do
+        arg1, arg2 = nil, nil
+        enum = MergeEnum::MergeEnumerable.new(
+          Proc.new { |c| arg1 = c; 0...100 },
+          Proc.new { |c| arg2 = c; 200...250 },
+          first: 200
+        )
+        expect(enum.count).to be 150
+        expect(arg1).to be 200
+        expect(arg2).to be 100
+      end
     end
   end
 
-  describe "Complex Enumerables to MergeEnumerable" do
+  describe "Complex Enumerables to MergeEnumerable:" do
     it "Enumerable, Proc, Lambda" do
       arg1, arg2 = nil, nil
       enum = MergeEnum::MergeEnumerable.new(
@@ -244,7 +387,7 @@ describe MergeEnum::MergeEnumerable do
     end
   end
 
-  describe "Equality Enumerator" do
+  describe "Equality Enumerator:" do
     it "equality enumerator" do
       enum = MergeEnum::MergeEnumerable.new(
         0...100,
@@ -260,8 +403,8 @@ describe MergeEnum::MergeEnumerable do
     end
   end
 
-  describe "Whitebox" do
-    it "call first method" do
+  describe "Whitebox:" do
+    it "call `first` method" do
       ary_1 = 0...100
       ary_2 = 200...250
       ary_3 = 300...330
@@ -272,13 +415,19 @@ describe MergeEnum::MergeEnumerable do
         first: 200
       )
       expect(ary_1).to receive(:first).with(200).and_return(ary_1)
-      ary_2.stub(:first) { raise "unexpected" }
+      allow(ary_2).to receive(:first).and_raise("unexpected")
       expect(ary_3).to receive(:first).with(50).and_return(ary_3)
       expect(enum.count).to be 180
     end
+    it "not call `first` method" do
+      ary = 0...100
+      allow(ary).to receive(:first).and_raise("unexpect")
+      enum = MergeEnum::MergeEnumerable.new ary, first: 10, compact: true
+      expect(enum.count).to be 10
+    end
   end
 
-  describe ":concat Method" do
+  describe "`concat` Method:" do
     it "equality enumerator" do
       enm_1 = 0...100
       enm_2 = -> (c) { 200...250 }
@@ -297,7 +446,7 @@ describe MergeEnum::MergeEnumerable do
     end
   end
 
-  describe ":concat! Method" do
+  describe "`concat!` Method:" do
     it "equality enumerator" do
       enm_1 = 0...100
       enm_2 = -> (c) { 200...250 }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: merge_enum
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - brightgenerous