tbpgr_utils 0.0.36 → 0.0.37

data/spec/open_classes/array/together_first_spec.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'tbpgr_utils'
+
+describe Array do
+  context :together_first do
+    cases = [
+      {
+        case_no: 1,
+        case_title: 'not args case',
+        inputs: [[*1..5], [*6..10]],
+        method_name: :together_first,
+        expected: [1, 6],
+        has_args: false,
+      },
+      {
+        case_no: 2,
+        case_title: 'has args 2 case',
+        inputs: [[*1..5], [*6..10]],
+        args: 2,
+        method_name: :together_first,
+        expected: [[1, 2], [6, 7]],
+        has_args: true,
+      },
+      {
+        case_no: 3,
+        case_title: 'has args 0 case',
+        inputs: [[*1..5], [*6..10]],
+        args: 0,
+        method_name: :together_first,
+        expected: [[], []],
+        has_args: true,
+      },
+      {
+        case_no: 4,
+        case_title: 'has args over size case',
+        inputs: [[*1..5], [*6..10]],
+        args: 6,
+        method_name: :together_first,
+        expected: [[*1..5], [*6..10]],
+        has_args: true,
+      },
+      {
+        case_no: 5,
+        case_title: 'not args case(alias tfirst)',
+        inputs: [[*1..5], [*6..10]],
+        method_name: :tfirst,
+        expected: [1, 6],
+        has_args: false,
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          # nothing
+
+          # -- when --
+          if c[:has_args]
+            actual = c[:inputs].send c[:method_name], c[:args]
+          else
+            actual = c[:inputs].send c[:method_name]
+          end
+
+          # -- then --
+          expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        # implement each case after
+      end
+    end
+  end
+end

data/spec/open_classes/array/together_include_spec.rb

@@ -0,0 +1,100 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'tbpgr_utils'
+
+describe Array do
+  context :together_include? do
+    cases = [
+      {
+        case_no: 1,
+        case_title: 'both include single ret case',
+        inputs: [[*1..5], [*5..9]],
+        value: 5,
+        method_name: :together_include?,
+        expected: true,
+        is_multi: false,
+      },
+      {
+        case_no: 2,
+        case_title: 'one include single ret case',
+        inputs: [[*1..5], [*5..9]],
+        value: 9,
+        method_name: :together_include?,
+        expected: true,
+        is_multi: false,
+      },
+      {
+        case_no: 3,
+        case_title: 'both not include single ret case',
+        inputs: [[*1..5], [*5..9]],
+        value: 10,
+        method_name: :together_include?,
+        expected: false,
+        is_multi: false,
+      },
+      {
+        case_no: 4,
+        case_title: 'both include multi ret case',
+        inputs: [[*1..5], [*5..9]],
+        value: 5,
+        method_name: :together_include?,
+        expected: [true, true],
+        is_multi: true,
+      },
+      {
+        case_no: 5,
+        case_title: 'one include multi ret case',
+        inputs: [[*1..5], [*5..9]],
+        value: 9,
+        method_name: :together_include?,
+        expected: [false, true],
+        is_multi: true,
+      },
+      {
+        case_no: 6,
+        case_title: 'both not include multi ret case',
+        inputs: [[*1..5], [*5..9]],
+        value: 10,
+        method_name: :together_include?,
+        expected: [false, false],
+        is_multi: true,
+      },
+      {
+        case_no: 7,
+        case_title: 'both include single ret case(alias tinclude?)',
+        inputs: [[*1..5], [*5..9]],
+        value: 5,
+        method_name: :tinclude?,
+        expected: true,
+        is_multi: false,
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          # nothing
+
+          # -- when --
+          actual = c[:inputs].send c[:method_name], c[:value], c[:is_multi]
+
+          # -- then --
+          expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        # implement each case after
+      end
+    end
+  end
+end

data/spec/open_classes/array/together_index_spec.rb

@@ -0,0 +1,69 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'tbpgr_utils'
+
+describe Array do
+  context :together_index do
+    cases = [
+      {
+        case_no: 1,
+        case_title: 'both index exist case',
+        inputs: [[*1..5], [*5..9]],
+        value: 5,
+        method_name: :together_index,
+        expected: [4, 0],
+      },
+      {
+        case_no: 2,
+        case_title: 'one index exist case',
+        inputs: [[*1..5], [*5..9]],
+        value: 4,
+        method_name: :together_index,
+        expected: [3, nil],
+      },
+      {
+        case_no: 3,
+        case_title: 'both not exist index case',
+        inputs: [[*1..5], [*5..9]],
+        value: 10,
+        method_name: :together_index,
+        expected: [nil, nil],
+      },
+      {
+        case_no: 4,
+        case_title: 'both index exist case(alias tindex)',
+        inputs: [[*1..5], [*5..9]],
+        value: 5,
+        method_name: :tindex,
+        expected: [4, 0],
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          # nothing
+
+          # -- when --
+          actual = c[:inputs].send c[:method_name], c[:value]
+
+          # -- then --
+          expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        # implement each case after
+      end
+    end
+  end
+end

data/spec/open_classes/array/together_insert_spec.rb

@@ -0,0 +1,65 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'tbpgr_utils'
+
+describe Array do
+  context :together_insert do
+    cases = [
+      {
+        case_no: 1,
+        case_title: 'both insert exist case',
+        inputs: [[*1..5], [*5..9]],
+        exec_code: 'together_insert(1, 55, 66)',
+        expected: [[1, 55, 66, 2, 3, 4, 5], [5, 55, 66, 6, 7, 8, 9]],
+      },
+      {
+        case_no: 2,
+        case_title: 'both insert exist and minus index case',
+        inputs: [[*1..5], [*5..9]],
+        exec_code: 'together_insert(-2, 55, 66)',
+        expected: [[1, 2, 3, 4, 55, 66, 5], [5, 6, 7, 8, 55, 66, 9]],
+      },
+      {
+        case_no: 3,
+        case_title: 'both insert exist and over index case',
+        inputs: [[*1..5], [*5..9]],
+        exec_code: 'together_insert(6, 55, 66)',
+        expected: [[1, 2, 3, 4, 5, nil, 55, 66], [5, 6, 7, 8, 9, nil, 55, 66]],
+      },
+      {
+        case_no: 4,
+        case_title: 'both insert exist case(alias tinsert)',
+        inputs: [[*1..5], [*5..9]],
+        exec_code: 'tinsert(1, 55, 66)',
+        expected: [[1, 55, 66, 2, 3, 4, 5], [5, 55, 66, 6, 7, 8, 9]],
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          # nothing
+
+          # -- when --
+          actual = eval "#{c[:inputs]}.#{c[:exec_code]}", binding
+
+          # -- then --
+          expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        # implement each case after
+      end
+    end
+  end
+end

data/spec/open_classes/array/together_last_spec.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'tbpgr_utils'
+
+describe Array do
+  context :together_last do
+    cases = [
+      {
+        case_no: 1,
+        case_title: 'not args case',
+        inputs: [[*1..5], [*6..10]],
+        method_name: :together_last,
+        expected: [5, 10],
+        has_args: false,
+      },
+      {
+        case_no: 2,
+        case_title: 'has args 2 case',
+        inputs: [[*1..5], [*6..10]],
+        args: 2,
+        method_name: :together_last,
+        expected: [[4, 5], [9, 10]],
+        has_args: true,
+      },
+      {
+        case_no: 3,
+        case_title: 'has args 0 case',
+        inputs: [[*1..5], [*6..10]],
+        args: 0,
+        method_name: :together_last,
+        expected: [[], []],
+        has_args: true,
+      },
+      {
+        case_no: 4,
+        case_title: 'has args over size case',
+        inputs: [[*1..5], [*6..10]],
+        args: 6,
+        method_name: :together_last,
+        expected: [[*1..5], [*6..10]],
+        has_args: true,
+      },
+      {
+        case_no: 5,
+        case_title: 'not args case(alias tlast)',
+        inputs: [[*1..5], [*6..10]],
+        method_name: :tlast,
+        expected: [5, 10],
+        has_args: false,
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          # nothing
+
+          # -- when --
+          if c[:has_args]
+            actual = c[:inputs].send c[:method_name], c[:args]
+          else
+            actual = c[:inputs].send c[:method_name]
+          end
+
+          # -- then --
+          expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        # implement each case after
+      end
+    end
+  end
+end

data/spec/open_classes/array/together_map_spec.rb

@@ -0,0 +1,171 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'tbpgr_utils'
+
+describe Array do
+  context :together_map do
+    cases = [
+      {
+        case_no: 1,
+        case_title: 'valid case',
+        method_name: :together_map,
+        inputs: [[1, 2, 3], %w{one two three}],
+        expected: ['1:one', '2:two', '3:three'],
+      },
+      {
+        case_no: 2,
+        case_title: 'contain nil case',
+        method_name: :together_map,
+        inputs: [[1, 2, 3], %w{one two}],
+        expected: ['1:one', '2:two', '3:'],
+      },
+      {
+        case_no: 3,
+        case_title: 'valid case',
+        method_name: :together_map,
+        inputs: [[1, 2, 3], %w{one two three}],
+        expected: [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']],
+        is_multi: true,
+      },
+      {
+        case_no: 4,
+        case_title: 'valid case(alias together_collect)',
+        method_name: :together_collect,
+        inputs: [[1, 2, 3], %w{one two three}],
+        expected: ['1:one', '2:two', '3:three'],
+      },
+      {
+        case_no: 5,
+        case_title: 'valid case(alias tmap)',
+        method_name: :tmap,
+        inputs: [[1, 2, 3], %w{one two three}],
+        expected: ['1:one', '2:two', '3:three'],
+      },
+      {
+        case_no: 6,
+        case_title: 'valid case(alias tcollect)',
+        method_name: :tcollect,
+        inputs: [[1, 2, 3], %w{one two three}],
+        expected: ['1:one', '2:two', '3:three'],
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          # nothing
+
+          # -- when/then --
+          if c[:is_multi]
+            actual = c[:inputs].method(c[:method_name]).call { |first, second|["#{first}:#{second}", "#{second}:#{first}"] }
+          else
+            actual = c[:inputs].method(c[:method_name]).call { |first, second|"#{first}:#{second}" }
+          end
+
+          expect(actual).to eq(c[:expected])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        # implement each case after
+      end
+    end
+  end
+
+  context :together_map! do
+    cases = [
+      {
+        case_no: 1,
+        case_title: 'valid case',
+        method_name: :together_map!,
+        inputs: [[1, 2, 3], %w{one two three}],
+        expected_ret: ['1:one', '2:two', '3:three'],
+        expected_self: ['1:one', '2:two', '3:three'],
+      },
+      {
+        case_no: 2,
+        case_title: 'contain nil case',
+        method_name: :together_map!,
+        inputs: [[1, 2, 3], %w{one two}],
+        expected_ret: ['1:one', '2:two', '3:'],
+        expected_self: ['1:one', '2:two', '3:'],
+      },
+      {
+        case_no: 3,
+        case_title: 'valid case',
+        method_name: :together_map!,
+        inputs: [[1, 2, 3], %w{one two three}],
+        expected_ret: [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']],
+        expected_self: [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']],
+        is_multi: true,
+      },
+      {
+        case_no: 4,
+        case_title: 'valid case(alias together_collect!)',
+        method_name: :together_collect!,
+        inputs: [[1, 2, 3], %w{one two three}],
+        expected_ret: [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']],
+        expected_self: [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']],
+        is_multi: true,
+      },
+      {
+        case_no: 5,
+        case_title: 'valid case(alias tmap!)',
+        method_name: :tmap!,
+        inputs: [[1, 2, 3], %w{one two three}],
+        expected_ret: [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']],
+        expected_self: [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']],
+        is_multi: true,
+      },
+      {
+        case_no: 6,
+        case_title: 'valid case(alias tcollect!)',
+        method_name: :tcollect!,
+        inputs: [[1, 2, 3], %w{one two three}],
+        expected_ret: [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']],
+        expected_self: [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']],
+        is_multi: true,
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          # nothing
+
+          # -- when/then --
+          if c[:is_multi]
+            actual = c[:inputs].method(c[:method_name]).call { |first, second|["#{first}:#{second}", "#{second}:#{first}"] }
+          else
+            actual = c[:inputs].method(c[:method_name]).call { |first, second|"#{first}:#{second}" }
+          end
+
+          expect(actual).to eq(c[:expected_ret])
+          expect(c[:inputs]).to eq(c[:expected_self])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        # implement each case after
+      end
+    end
+  end
+end

data/spec/open_classes/array/together_pop_spec.rb

@@ -0,0 +1,105 @@
+# encoding: utf-8
+require 'spec_helper'
+require 'tbpgr_utils'
+
+describe Array do
+  context :together_pop do
+    cases = [
+      {
+        case_no: 1,
+        case_title: 'not empty case',
+        inputs: [[1, 2], [5, 6]],
+        method_name: 'together_pop',
+        expected_ret: [2, 6],
+        expected_self: [[1], [5]],
+      },
+      {
+        case_no: 2,
+        case_title: 'one empty case',
+        inputs: [[1, 2], []],
+        method_name: 'together_pop',
+        expected_ret: [2, nil],
+        expected_self: [[1], []],
+      },
+      {
+        case_no: 3,
+        case_title: 'both empty case',
+        inputs: [[], []],
+        method_name: 'together_pop',
+        expected_ret: [nil, nil],
+        expected_self: [[], []],
+      },
+      {
+        case_no: 4,
+        case_title: 'not empty, has args case',
+        inputs: [[1, 2], [5, 6]],
+        method_name: 'together_pop',
+        args: 2,
+        expected_ret: [[1, 2], [5, 6]],
+        expected_self: [[], []],
+        has_args: true,
+      },
+      {
+        case_no: 5,
+        case_title: 'one empty, has args case',
+        inputs: [[1, 2], []],
+        method_name: 'together_pop',
+        args: 2,
+        expected_ret: [[1, 2], []],
+        expected_self: [[], []],
+        has_args: true,
+      },
+      {
+        case_no: 6,
+        case_title: 'both empty, has args case',
+        inputs: [[], []],
+        method_name: 'together_pop',
+        args: 2,
+        expected_ret: [[], []],
+        expected_self: [[], []],
+        has_args: true,
+      },
+      {
+        case_no: 7,
+        case_title: 'not empty case(alias tpop)',
+        inputs: [[1, 2], [5, 6]],
+        method_name: 'tpop',
+        expected_ret: [2, 6],
+        expected_self: [[1], [5]],
+      },
+    ]
+
+    cases.each do |c|
+      it "|case_no=#{c[:case_no]}|case_title=#{c[:case_title]}" do
+        begin
+          case_before c
+
+          # -- given --
+          # nothing
+
+          # -- when --
+          actual = \
+            if c[:has_args]
+              c[:inputs].send c[:method_name], c[:args]
+            else
+              c[:inputs].send c[:method_name]
+            end
+
+          # -- then --
+          expect(actual).to eq(c[:expected_ret])
+          expect(c[:inputs]).to eq(c[:expected_self])
+        ensure
+          case_after c
+        end
+      end
+
+      def case_before(c)
+        # implement each case before
+      end
+
+      def case_after(c)
+        # implement each case after
+      end
+    end
+  end
+end