tbpgr_utils 0.0.29 → 0.0.30

data/README.md

@@ -32,6 +32,7 @@ Or install it yourself as:
 |[TbpgrUtils Array#together_empty?](#arraytogether_empty)                                                           |together version of Array#empty?. together_empty? has alias :tempty?                                                 |
 |[TbpgrUtils Array#together_fill](#arraytogether_fill)                                                              |together version of Array#fill. together_fill has alias :tfill                                                       |
 |[TbpgrUtils Array#together_first](#arraytogether_first)                                                            |together version of Array#first. together_first has alias :tfirst                                                    |
+|[TbpgrUtils Array#together_include?](#arraytogether_include)                                                       |together version of Array#include?. together_include? has alias :tinclude?                                           |
 |[TbpgrUtils Array#together_map](#arraytogether_mapor-tmap-together_collect-tcollect)                               |together version of Enumerable#map. together_map has aliases [:tmap, :together_collect, :tcollect]                   |
 |[TbpgrUtils Array#together_map!](#arraytogether_map-1or-tmap-1-together_collect-1-tcollect-1)                      |together version of Enumerable#map!. together_map! has aliases [:tmap!, :together_collect!, :tcollect!]              |
 |[TbpgrUtils Array#together_reduce](#arraytogether_reduceor-treduce-together_inject-tinject)                        |together version of Enumerable#reduce. together_reduce has aliases [:treduce, :together_inject, :tinject]            |
@@ -41,7 +42,7 @@ Or install it yourself as:
 |[AttributesInitializable::ClassMethods.attr_accessor_init](#attributesinitializableclassmethodsattr_accessor_init) |generate attr_accessor + initializer                                                                                 |
 |[AttributesInitializable::ClassMethods.attr_reader_init](#attributesinitializableclassmethodsattr_reader_init)     |generate attr_reader + initializer                                                                                   |
 |[AttributesInitializable::ClassMethods.attr_writer init](#attributesinitializableclassmethodsattr_writer_init)     |generate attr_writer + initializer                                                                                   |
-|[TbpgrUtils File.insert_bom](#fileinsert_bom)                                                                      |insert BOM to UTF-8 File                                                                                              |
+|[TbpgrUtils File.insert_bom](#fileinsert_bom)                                                                      |insert BOM to UTF-8 File                                                                                             |
 |[Ghostable module](#ghostable)                                                                                     |help to create ghost method(dynamic method define by ussing method_missing + pattern-method-name)                    |
 |[TbpgrUtils Kernel#bulk_define_methods](#kernelbulk_define_methods)                                                |define methods to classes. methods have simple return value.                                                         |
 |[TestToolbox Kernel#capture_stdout](#kernelcapture_stdout)                                                         |capture STDOUT                                                                                                       |
@@ -328,6 +329,55 @@ print ret # => [[*1..5], [*6..10]]
 
 [back to list](#list)
 
+### Array#together_include?
+together_include? is bulk version of Array#include?
+
+together_include? has alias :tinclude?
+
+both include single ret case
+~~~ruby
+  lists = [[*1..5], [*5..9]]
+  ret = lists.together_include? 5
+  print ret # => true
+~~~
+
+one include single ret case
+~~~ruby
+  lists = [[*1..5], [*5..9]]
+  ret = lists.together_include? 9
+  print ret # => true
+~~~
+
+both not include single ret case
+~~~ruby
+  lists = [[*1..5], [*5..9]]
+  ret = lists.together_include? 10
+  print ret # => false
+~~~
+
+both include multi ret case
+~~~ruby
+  lists = [[*1..5], [*5..9]]
+  ret = lists.together_include? 5, true
+  print ret # => [true, true]
+~~~
+
+one include multi ret case
+~~~ruby
+  lists = [[*1..5], [*5..9]]
+  ret = lists.together_include? 9, true
+  print ret # => [false, true]
+~~~
+
+both not include multi ret case
+~~~ruby
+  lists = [[*1..5], [*5..9]]
+  ret = lists.together_include? 10, true
+  print ret # => [false, false]
+~~~
+
+[back to list](#list)
+
 ### Array#together_map(or tmap, together_collect, tcollect)
 ~~~ruby
 require 'tbpgr_utils'
@@ -1071,6 +1121,7 @@ if you are Sublime Text2 user, you can use snippet for TbpgrUtils.
 https://github.com/tbpgr/tbpgr_utils_snippets
 
 ## History
+* version 0.0.30 : add Array#together_include?(alias tinclude?).
 * version 0.0.29 : add Array#together_first(alias tfirst).
 * version 0.0.28 : add Array#together_fill(alias tfill). add File.insert_bom.
 * version 0.0.27 : add Array#together_empty?(alias tempty?)

data/lib/open_classes/array.rb

@@ -1,484 +1,524 @@
-# encoding: utf-8
-require 'open_classes/object'
-require 'open_classes/module'
-
-# Array
-class Array
-  # Arrays loop together.
-  #
-  #   alpha = %w{one two three}
-  #   numbers = %w{1 2 3}
-  #   [alpha, numbers].together do |first, second|
-  #     print "#{first}:#{second}\n"  # => output one:1, two:2, three:3
-  #   end
-  def together
-    if_not_contain_array_rails_type_error
-    first.each_with_index do |i_v, i|
-      eval_each_str = get_args_str_for_together i
-      instance_eval "yield(#{eval_each_str})"
-    end
-  end
-
-  # Arrays loop together with index.
-  #
-  #   alpha = %w{one two three}
-  #   numbers = %w{1 2 3}
-  #   [alpha, numbers].together_with_index do |first, second, index|
-  #     print "#{index.to_s}:#{first}:#{second}\n"  # => output 0:one:1, 1:two:2, 2:three:3
-  #   end
-  def together_with_index
-    if_not_contain_array_rails_type_error
-    first.each_with_index do |i_v, i|
-      eval_each_str = get_args_str_for_together i, true
-      instance_eval "yield(#{eval_each_str})"
-    end
-  end
-
-  # Arrays together map.
-  #
-  # together_map has aliases [:tmap, :together_collect, :tcollect]
-  #
-  # if you want to single Array return
-  #   alpha = %w{one two three}
-  #   numbers = %w{1 2 3}
-  #   print [alpha, numbers].together_map do |first, second|
-  #     "#{first}:#{second}\n"
-  #   end # => output one:1, two:2, three:3
-  #
-  # if you want to multi Array return
-  #   alpha = %w{one two three}
-  #   numbers = %w{1 2 3}
-  #   print [alpha, numbers].together_map do |first, second|
-  #     ["#{first}:#{second}", "#{second}:#{first}"]
-  #   end # => output [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']]
-  def together_map
-    if_not_contain_array_rails_type_error
-    ret = []
-    first.each_with_index do |i_v, i|
-      eval_each_str = get_args_str_for_together i
-      each_ret = instance_eval "yield(#{eval_each_str})"
-      ret = set_together_each_return_map(ret, each_ret, i)
-    end
-    ret
-  end
-
-
-  # Arrays together map!.
-  #
-  # together_map! has aliases [:tmap!, :together_collect!, :tcollect!]
-  #
-  # if you want to single Array return
-  #   alpha = %w{one two three}
-  #   numbers = %w{1 2 3}
-  #   ary = [alpha, numbers]
-  #   ret = ary.together_map! do |first, second|
-  #     "#{first}:#{second}"
-  #   end
-  #   print ret # => output ['one:1', 'two:2', 'three:3']
-  #   print ary # => output ['one:1', 'two:2', 'three:3']
-  #
-  # if you want to multi Array return
-  #   alpha = %w{one two three}
-  #   numbers = %w{1 2 3}
-  #   ary = [alpha, numbers]
-  #   ret = ary.together_map! do |first, second|
-  #     ["#{first}:#{second}", "#{second}:#{first}"]
-  #   end
-  #   print ret # => output [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']]
-  #   print ary # => output [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']]
-  def together_map!
-    if_not_contain_array_rails_type_error
-    ret = []
-    first.each_with_index do |i_v, i|
-      eval_each_str = get_args_str_for_together i
-      each_ret = instance_eval "yield(#{eval_each_str})"
-      ret = set_together_each_return_map(ret, each_ret, i)
-    end
-    clear
-    ret.each { |v|self << v }
-  end
-
-  # Arrays loop together select.
-  #
-  # together_select has aliases [:tselect, :together_find_all, :tfindall]
-  #
-  # if you want to single Array return
-  #   firsts = [1, 2, 3, 4]
-  #   seconds =  [4, 2, 3, 1]
-  #   ret = [firsts, seconds].together_select{|first, second|first == second}
-  #   print ret # => output  [[2, 3], [2, 3]]
-  #
-  # if you want to multi Array return
-  #   firsts = [1, 2, 3, 4]
-  #   seconds =  [4, 2, 3, 1]
-  #   ret = [firsts, seconds].together_select{|first, second|[first.odd?, second.even?]}
-  #   print ret # => output  [[1, 3], [4, 2]]
-  def together_select
-    if_not_contain_array_rails_type_error
-    ret = []
-    first.each_with_index do |i_v, i|
-      eval_each_str = get_args_str_for_together i
-      each_ret = instance_eval "yield(#{eval_each_str})"
-      ret = set_together_each_return_select(ret, each_ret, i)
-    end
-    ret
-  end
-
-  # Arrays loop together reduce.
-  #
-  # together_reduce has aliases [:treduce, :together_inject, :tinject]
-  #
-  # if you want to single return
-  #   firsts = [1, 2, 3, 4]
-  #   seconds =  [4, 2, 3, 1]
-  #   ret = [firsts, seconds].together_reduce{|memo, first, second|memo + first + second}
-  #   print ret # => output  20
-  #
-  # if you want to single return with init value
-  #   firsts = [1, 2, 3, 4]
-  #   seconds =  [4, 2, 3, 1]
-  #   ret = [firsts, seconds].together_reduce(10){|memo, first, second|memo + first + second}
-  #   print ret # => output  30
-  #
-  # if you want to single return with init string value
-  #   firsts = %w{a b c}
-  #   seconds =  %w{1 2 3}
-  #   ret = [firsts, seconds].together_reduce('start-'){|memo, first, second|memo + first + second}
-  #   print ret # => output 'start-a1b2c3'
-  #
-  # if you want to single return with init Array value
-  #   firsts = [1, 2, 3, 4]
-  #   seconds =  [4, 2, 3, 1]
-  #   ret = [firsts, seconds].together_reduce([]){|memo, first, second|memo << first + second}
-  #   print ret # => output [5, 4, 6, 5]
-  #
-  # if you want to single return with init Hash value
-  #   firsts = [1, 2, 3, 4]
-  #   seconds =  [4, 2, 3, 1]
-  #   ret = [firsts, seconds].together_reduce({}){|memo, first, second|memo[first] = second;memo}
-  #   print ret # => output {1=>4, 2=>2, 3=>3, 4=>1}
-  def together_reduce(init = nil)
-    if_not_contain_array_rails_type_error
-    memo = initial_memo init
-    first.each_with_index do |i_v, i|
-      eval_each_str = get_args_str_for_together i
-      memo = instance_eval "yield(memo, #{eval_each_str})"
-    end
-    memo
-  end
-
-  # Arrays bulk concat.
-  #
-  # together_concat has alias :tconcat
-  #
-  #   alpha = %w{one two three}
-  #   numbers = %w{1 2 3}
-  #   [alpha, numbers].together do |first, second|
-  #     print "#{first}:#{second}\n"  # => output one:1, two:2, three:3
-  #   end
-  def together_concat(other)
-    if_not_contain_array_rails_type_error
-    each { |list|list.concat other }
-  end
-
-  # Arrays bulk at.
-  #
-  # together_at has alias :tat
-  #
-  # same elements size case
-  #   alpha = %w{one two three}
-  #   numbers = %w{1 2 3}
-  #   [alpha, numbers].together_at 2 # => output ['three', 3]
-  #
-  # different elements size case
-  #   alpha = %w{one two three}
-  #   numbers = %w{1 2}
-  #   [alpha, numbers].together_at 2 # => output ['three', nil]
-  def together_at(index)
-    if_not_contain_array_rails_type_error
-    reduce([]) { |ats, list|ats << list.at(index) }
-  end
-
-  # Arrays bulk clear.
-  #
-  # together_clear has alias :tclear
-  #
-  # same elements size case
-  #   alpha = %w{one two three}
-  #   numbers = %w{1 2 3}
-  #   [alpha, numbers].together_clear # => output [[],[]]
-  def together_clear
-    if_not_contain_array_rails_type_error
-    each { |list|list.clear }
-  end
-
-  # Arrays bulk compact.(immutable)
-  #
-  # together_compact has alias :tcompact
-  #
-  # same elements size case
-  #   alpha = ['a','b','c', nil,'d']
-  #   numbers = [1, 2, nil, 3]
-  #   lists = [alpha, numbers]
-  #   ret = lists.together_compact
-  #   print lists # => output [['a','b','c', nil,'d'], [1, 2, nil, 3]]
-  #   print ret # => output [['a','b','c','d'], [1, 2, 3]]
-  def together_compact
-    if_not_contain_array_rails_type_error
-    reduce([]) { |ret, list|ret << list.compact }
-  end
-
-  # Arrays bulk compact!.(mutable)
-  #
-  # together_compact! has alias :tcompact!
-  #
-  # same elements size case
-  #   alpha = ['a','b','c', nil,'d']
-  #   numbers = [1, 2, nil, 3]
-  #   lists = [alpha, numbers]
-  #   ret = lists.together_compact!
-  #   print lists # => output [['a','b','c','d'], [1, 2, 3]]
-  #   print ret # => output [['a','b','c','d'], [1, 2, 3]]
-  def together_compact!
-    if_not_contain_array_rails_type_error
-    each { |list|list.compact! }
-  end
-
-  # Arrays bulk delete.
-  #
-  # together_delete has alias :tdelete
-  #
-  # if delete target is exist
-  #   child1 = [1, 2, 3, 4]
-  #   child2 = [2, 3, 4, 5]
-  #   lists = [child1, child2]
-  #   ret = lists.together_delete 2
-  #   print ret # => 2
-  #   print lists # => output [[1, 3, 4], [3, 4, 5]]
-  #
-  # if delete target is not exist
-  #   child1 = [1, 2, 3, 4]
-  #   child2 = [2, 3, 4, 5]
-  #   lists = [child1, child2]
-  #   ret = lists.together_delete 6
-  #   print ret # => nil
-  #   print lists # => output [[1, 2, 3, 4], [2, 3, 4, 5]]
-  #
-  # if delete target is not exist and use block
-  #   child1 = [1, 2, 3, 4]
-  #   child2 = [2, 3, 4, 5]
-  #   lists = [child1, child2]
-  #   ret = lists.together_delete(6) { 999 }
-  #   print ret # => 999
-  #   print lists # => output [[1, 2, 3, 4], [2, 3, 4, 5]]
-  def together_delete(value)
-    if_not_contain_array_rails_type_error
-    ret = []
-    each { |list|ret << list.delete(value) }
-    default_return = block_given? ? yield : nil
-    ret.compact.size == 0 ? default_return : value
-  end
-
-  # Arrays bulk delete_at.
-  #
-  # together_delete_at has alias :tdelete_at
-  #
-  # if delete_at target is exist
-  #   child1 = [1, 2, 3, 4]
-  #   child2 = [2, 3, 4, 5]
-  #   lists = [child1, child2]
-  #   ret = lists.together_delete_at 2
-  #   print ret # => [3, 4]
-  #   print lists # => output [[1, 2, 4], [2, 3, 5]]
-  #
-  # if delete_at target is not exist
-  #   child1 = [1, 2, 3, 4]
-  #   child2 = [2, 3, 4, 5]
-  #   lists = [child1, child2]
-  #   ret = lists.together_delete_at 6
-  #   print ret # => [nil, nil]
-  #   print lists # => output [[1, 2, 3, 4], [2, 3, 4, 5]]
-  #
-  # if delete_at target is exist(minus index)
-  #   child1 = [1, 2, 3, 4]
-  #   child2 = [2, 3, 4, 5]
-  #   lists = [child1, child2]
-  #   ret = lists.together_delete_at -3
-  #   print ret # => [2, 3]
-  #   print lists # => output [[1, 3, 4], [2, 4, 5]]
-  def together_delete_at(index)
-    if_not_contain_array_rails_type_error
-    reduce([]) { |ret, list|ret << list.delete_at(index) }
-  end
-
-  # Arrays bulk delete_if.
-  #
-  # together_delete_if has alias :tdelete_if
-  #
-  # if delete_if target is exist. return self.
-  #   lists = [[1, 2, 3, 4], [6, 4, 6, 8]]
-  #   ret = lists.together_delete_if {|first, second|(first + second).odd?}
-  #   print ret # => [[2, 4], [4, 8]]
-  #
-  # if delete_if target is not exist. return nil.
-  #   lists = [[2, 2, 4, 4], [6, 4, 6, 8]]
-  #   ret = lists.together_delete_if {|first, second|(first + second).odd?}
-  #   print ret # => nil
-  def together_delete_if(&block)
-    if_not_contain_array_rails_type_error
-    have_deleted = false
-    first.each_with_index do |i_v, i|
-      eval_each_str = get_args_str_for_together i
-      is_delete = instance_eval "yield(#{eval_each_str})"
-      if is_delete
-        each { |e|e.delete_at i }
-        have_deleted = true
-      end
-    end
-    have_deleted ? self : nil
-  end
-
-  # Arrays bulk empty?.
-  #
-  # together_empty? has alias :tempty?
-  #
-  # empty case
-  #   lists = [[], []]
-  #   ret = lists.together_empty?
-  #   print ret # => true
-  #
-  # not empty case
-  #   lists = [[1], []]
-  #   ret = lists.together_empty?
-  #   print ret # => false
-  def together_empty?
-    if_not_contain_array_rails_type_error
-    is_empty = true
-    each { |list|is_empty = is_empty && list.empty? }
-    is_empty
-  end
-
-  # Arrays bulk fill.
-  #
-  # together_fill has alias :tfill
-  #
-  # not use block case
-  #   lists = [[*1..5], [*6..10]]
-  #   ret = lists.together_fill(99)
-  #   print ret # => [[99, 99, 99, 99, 99], [99, 99, 99, 99, 99]]
-  #
-  # use block, no args case
-  #   lists = [[*1..5], [*6..10]]
-  #   ret = lists.together_fill { |i|(i + 1) + 1 }
-  #   print ret # => [[2, 3, 4, 5, 6], [2, 3, 4, 5, 6]]
-  #
-  # use block, has args case
-  #   lists = [[*1..5], [*6..10]]
-  #   ret = lists.together_fill(2) { |i|(i + 1) + 1 }
-  #   print ret # => [[1, 2, 4, 5, 6], [6, 7, 4, 5, 6]]
-  def together_fill(fill_value = nil, &block)
-    if_not_contain_array_rails_type_error
-    if block
-      fill_value = 0 if fill_value.nil?
-      first.each_with_index do |i_v, i|
-        next if i < fill_value
-        each { |list|list[i] = yield(i) }
-      end
-    else
-      each { |list|list.fill fill_value }
-    end
-    self
-  end
-
-  # Arrays bulk first.
-  #
-  # together_first has alias :tfirst
-  #
-  # no args case
-  #   lists = [[*1..5], [*6..10]]
-  #   ret = lists.together_first
-  #   print ret # => [1, 6]
-  #
-  # has args 2 case
-  #   lists = [[*1..5], [*6..10]]
-  #   ret = lists.together_first 2
-  #   print ret # => [[1, 2], [6, 7]]
-  #
-  # has args 0 case
-  #   lists = [[*1..5], [*6..10]]
-  #   ret = lists.together_first 0
-  #   print ret # => [[], []]
-  #
-  # has args over size case
-  #   lists = [[*1..5], [*6..10]]
-  #   ret = lists.together_first 6
-  #   print ret # => [[*1..5], [*6..10]]
-  def together_first(index = nil)
-    if_not_contain_array_rails_type_error
-    each_return = index == 0 ? '[]' : index.nil? ? 'list.first' : 'list[0..index - 1]'
-    reduce([]) { |ret, list|ret << eval(each_return, binding) }
-  end
-
-  private
-
-  def if_not_contain_array_rails_type_error
-    each { |f|fail TypeError, "you have to use [Array1, Array2, ...] | #{f.class} is invalid" unless f.class == Array }
-  end
-
-  def get_args_for_together(i)
-    eval_each = []
-    each_with_index { |j_v, j|eval_each << "self[#{j}][#{i}]" }
-    eval_each
-  end
-
-  def get_args_str_for_together(i, with_index = false)
-    each_eval = with_index ? get_args_for_together(i) << i : get_args_for_together(i)
-    each_eval.join(',')
-  end
-
-  def set_together_each_return_map(ret, each_ret, index)
-    if together_return_multi?(each_ret)
-      size.times { |i|ret << [] } if index == 0
-      (0..(size - 1)).each { |i|ret[i] << each_ret[i] }
-    else
-      ret << each_ret
-    end
-    ret
-  end
-
-  def set_together_each_return_select(ret, each_ret, index)
-    unless together_return_multi?(each_ret)
-      tmp_each_ret = []
-      size.times { tmp_each_ret << each_ret }
-      each_ret = tmp_each_ret
-    end
-    size.times { |i|ret << [] } if index == 0
-    (0..(size - 1)).each { |i|ret[i] << self[i][index] if each_ret[i] }
-    ret
-  end
-
-  def initial_memo(init)
-    return init unless init.nil?
-    first.first.is_a?(Numeric) ? 0 : first.first.is_a?(String) ? '' : nil
-  end
-
-  def together_return_multi?(list)
-    (list.class == Array && list.size == size).to_bool
-  end
-
-  alias_method :tconcat, :together_concat
-  alias_method :tat, :together_at
-  alias_method :tclear, :together_clear
-  alias_method :tcompact, :together_compact
-  alias_method :tcompact!, :together_compact!
-  alias_method :tdelete, :together_delete
-  alias_method :tdelete_at, :together_delete_at
-  alias_method :tdelete_if, :together_delete_if
-  alias_method :tempty?, :together_empty?
-  alias_method :tfill, :together_fill
-  alias_method :tfirst, :together_first
-  alias_methods [:together_collect, :tmap, :tcollect], :together_map
-  alias_methods [:together_collect!, :tmap!, :tcollect!], :together_map!
-  alias_methods [:together_find_all, :tselect, :tfindall], :together_select
-  alias_methods [:together_inject, :treduce, :tinject], :together_reduce
-end
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+
+# Array
+class Array
+  # Arrays loop together.
+  #
+  #   alpha = %w{one two three}
+  #   numbers = %w{1 2 3}
+  #   [alpha, numbers].together do |first, second|
+  #     print "#{first}:#{second}\n"  # => output one:1, two:2, three:3
+  #   end
+  def together
+    if_not_contain_array_rails_type_error
+    first.each_with_index do |i_v, i|
+      eval_each_str = get_args_str_for_together i
+      instance_eval "yield(#{eval_each_str})"
+    end
+  end
+
+  # Arrays loop together with index.
+  #
+  #   alpha = %w{one two three}
+  #   numbers = %w{1 2 3}
+  #   [alpha, numbers].together_with_index do |first, second, index|
+  #     print "#{index.to_s}:#{first}:#{second}\n"  # => output 0:one:1, 1:two:2, 2:three:3
+  #   end
+  def together_with_index
+    if_not_contain_array_rails_type_error
+    first.each_with_index do |i_v, i|
+      eval_each_str = get_args_str_for_together i, true
+      instance_eval "yield(#{eval_each_str})"
+    end
+  end
+
+  # Arrays together map.
+  #
+  # together_map has aliases [:tmap, :together_collect, :tcollect]
+  #
+  # if you want to single Array return
+  #   alpha = %w{one two three}
+  #   numbers = %w{1 2 3}
+  #   print [alpha, numbers].together_map do |first, second|
+  #     "#{first}:#{second}\n"
+  #   end # => output one:1, two:2, three:3
+  #
+  # if you want to multi Array return
+  #   alpha = %w{one two three}
+  #   numbers = %w{1 2 3}
+  #   print [alpha, numbers].together_map do |first, second|
+  #     ["#{first}:#{second}", "#{second}:#{first}"]
+  #   end # => output [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']]
+  def together_map
+    if_not_contain_array_rails_type_error
+    ret = []
+    first.each_with_index do |i_v, i|
+      eval_each_str = get_args_str_for_together i
+      each_ret = instance_eval "yield(#{eval_each_str})"
+      ret = set_together_each_return_map(ret, each_ret, i)
+    end
+    ret
+  end
+
+
+  # Arrays together map!.
+  #
+  # together_map! has aliases [:tmap!, :together_collect!, :tcollect!]
+  #
+  # if you want to single Array return
+  #   alpha = %w{one two three}
+  #   numbers = %w{1 2 3}
+  #   ary = [alpha, numbers]
+  #   ret = ary.together_map! do |first, second|
+  #     "#{first}:#{second}"
+  #   end
+  #   print ret # => output ['one:1', 'two:2', 'three:3']
+  #   print ary # => output ['one:1', 'two:2', 'three:3']
+  #
+  # if you want to multi Array return
+  #   alpha = %w{one two three}
+  #   numbers = %w{1 2 3}
+  #   ary = [alpha, numbers]
+  #   ret = ary.together_map! do |first, second|
+  #     ["#{first}:#{second}", "#{second}:#{first}"]
+  #   end
+  #   print ret # => output [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']]
+  #   print ary # => output [['1:one', '2:two', '3:three'], ['one:1', 'two:2', 'three:3']]
+  def together_map!
+    if_not_contain_array_rails_type_error
+    ret = []
+    first.each_with_index do |i_v, i|
+      eval_each_str = get_args_str_for_together i
+      each_ret = instance_eval "yield(#{eval_each_str})"
+      ret = set_together_each_return_map(ret, each_ret, i)
+    end
+    clear
+    ret.each { |v|self << v }
+  end
+
+  # Arrays loop together select.
+  #
+  # together_select has aliases [:tselect, :together_find_all, :tfindall]
+  #
+  # if you want to single Array return
+  #   firsts = [1, 2, 3, 4]
+  #   seconds =  [4, 2, 3, 1]
+  #   ret = [firsts, seconds].together_select{|first, second|first == second}
+  #   print ret # => output  [[2, 3], [2, 3]]
+  #
+  # if you want to multi Array return
+  #   firsts = [1, 2, 3, 4]
+  #   seconds =  [4, 2, 3, 1]
+  #   ret = [firsts, seconds].together_select{|first, second|[first.odd?, second.even?]}
+  #   print ret # => output  [[1, 3], [4, 2]]
+  def together_select
+    if_not_contain_array_rails_type_error
+    ret = []
+    first.each_with_index do |i_v, i|
+      eval_each_str = get_args_str_for_together i
+      each_ret = instance_eval "yield(#{eval_each_str})"
+      ret = set_together_each_return_select(ret, each_ret, i)
+    end
+    ret
+  end
+
+  # Arrays loop together reduce.
+  #
+  # together_reduce has aliases [:treduce, :together_inject, :tinject]
+  #
+  # if you want to single return
+  #   firsts = [1, 2, 3, 4]
+  #   seconds =  [4, 2, 3, 1]
+  #   ret = [firsts, seconds].together_reduce{|memo, first, second|memo + first + second}
+  #   print ret # => output  20
+  #
+  # if you want to single return with init value
+  #   firsts = [1, 2, 3, 4]
+  #   seconds =  [4, 2, 3, 1]
+  #   ret = [firsts, seconds].together_reduce(10){|memo, first, second|memo + first + second}
+  #   print ret # => output  30
+  #
+  # if you want to single return with init string value
+  #   firsts = %w{a b c}
+  #   seconds =  %w{1 2 3}
+  #   ret = [firsts, seconds].together_reduce('start-'){|memo, first, second|memo + first + second}
+  #   print ret # => output 'start-a1b2c3'
+  #
+  # if you want to single return with init Array value
+  #   firsts = [1, 2, 3, 4]
+  #   seconds =  [4, 2, 3, 1]
+  #   ret = [firsts, seconds].together_reduce([]){|memo, first, second|memo << first + second}
+  #   print ret # => output [5, 4, 6, 5]
+  #
+  # if you want to single return with init Hash value
+  #   firsts = [1, 2, 3, 4]
+  #   seconds =  [4, 2, 3, 1]
+  #   ret = [firsts, seconds].together_reduce({}){|memo, first, second|memo[first] = second;memo}
+  #   print ret # => output {1=>4, 2=>2, 3=>3, 4=>1}
+  def together_reduce(init = nil)
+    if_not_contain_array_rails_type_error
+    memo = initial_memo init
+    first.each_with_index do |i_v, i|
+      eval_each_str = get_args_str_for_together i
+      memo = instance_eval "yield(memo, #{eval_each_str})"
+    end
+    memo
+  end
+
+  # Arrays bulk concat.
+  #
+  # together_concat has alias :tconcat
+  #
+  #   alpha = %w{one two three}
+  #   numbers = %w{1 2 3}
+  #   [alpha, numbers].together do |first, second|
+  #     print "#{first}:#{second}\n"  # => output one:1, two:2, three:3
+  #   end
+  def together_concat(other)
+    if_not_contain_array_rails_type_error
+    each { |list|list.concat other }
+  end
+
+  # Arrays bulk at.
+  #
+  # together_at has alias :tat
+  #
+  # same elements size case
+  #   alpha = %w{one two three}
+  #   numbers = %w{1 2 3}
+  #   [alpha, numbers].together_at 2 # => output ['three', 3]
+  #
+  # different elements size case
+  #   alpha = %w{one two three}
+  #   numbers = %w{1 2}
+  #   [alpha, numbers].together_at 2 # => output ['three', nil]
+  def together_at(index)
+    if_not_contain_array_rails_type_error
+    reduce([]) { |ats, list|ats << list.at(index) }
+  end
+
+  # Arrays bulk clear.
+  #
+  # together_clear has alias :tclear
+  #
+  # same elements size case
+  #   alpha = %w{one two three}
+  #   numbers = %w{1 2 3}
+  #   [alpha, numbers].together_clear # => output [[],[]]
+  def together_clear
+    if_not_contain_array_rails_type_error
+    each { |list|list.clear }
+  end
+
+  # Arrays bulk compact.(immutable)
+  #
+  # together_compact has alias :tcompact
+  #
+  # same elements size case
+  #   alpha = ['a','b','c', nil,'d']
+  #   numbers = [1, 2, nil, 3]
+  #   lists = [alpha, numbers]
+  #   ret = lists.together_compact
+  #   print lists # => output [['a','b','c', nil,'d'], [1, 2, nil, 3]]
+  #   print ret # => output [['a','b','c','d'], [1, 2, 3]]
+  def together_compact
+    if_not_contain_array_rails_type_error
+    reduce([]) { |ret, list|ret << list.compact }
+  end
+
+  # Arrays bulk compact!.(mutable)
+  #
+  # together_compact! has alias :tcompact!
+  #
+  # same elements size case
+  #   alpha = ['a','b','c', nil,'d']
+  #   numbers = [1, 2, nil, 3]
+  #   lists = [alpha, numbers]
+  #   ret = lists.together_compact!
+  #   print lists # => output [['a','b','c','d'], [1, 2, 3]]
+  #   print ret # => output [['a','b','c','d'], [1, 2, 3]]
+  def together_compact!
+    if_not_contain_array_rails_type_error
+    each { |list|list.compact! }
+  end
+
+  # Arrays bulk delete.
+  #
+  # together_delete has alias :tdelete
+  #
+  # if delete target is exist
+  #   child1 = [1, 2, 3, 4]
+  #   child2 = [2, 3, 4, 5]
+  #   lists = [child1, child2]
+  #   ret = lists.together_delete 2
+  #   print ret # => 2
+  #   print lists # => output [[1, 3, 4], [3, 4, 5]]
+  #
+  # if delete target is not exist
+  #   child1 = [1, 2, 3, 4]
+  #   child2 = [2, 3, 4, 5]
+  #   lists = [child1, child2]
+  #   ret = lists.together_delete 6
+  #   print ret # => nil
+  #   print lists # => output [[1, 2, 3, 4], [2, 3, 4, 5]]
+  #
+  # if delete target is not exist and use block
+  #   child1 = [1, 2, 3, 4]
+  #   child2 = [2, 3, 4, 5]
+  #   lists = [child1, child2]
+  #   ret = lists.together_delete(6) { 999 }
+  #   print ret # => 999
+  #   print lists # => output [[1, 2, 3, 4], [2, 3, 4, 5]]
+  def together_delete(value)
+    if_not_contain_array_rails_type_error
+    ret = []
+    each { |list|ret << list.delete(value) }
+    default_return = block_given? ? yield : nil
+    ret.compact.size == 0 ? default_return : value
+  end
+
+  # Arrays bulk delete_at.
+  #
+  # together_delete_at has alias :tdelete_at
+  #
+  # if delete_at target is exist
+  #   child1 = [1, 2, 3, 4]
+  #   child2 = [2, 3, 4, 5]
+  #   lists = [child1, child2]
+  #   ret = lists.together_delete_at 2
+  #   print ret # => [3, 4]
+  #   print lists # => output [[1, 2, 4], [2, 3, 5]]
+  #
+  # if delete_at target is not exist
+  #   child1 = [1, 2, 3, 4]
+  #   child2 = [2, 3, 4, 5]
+  #   lists = [child1, child2]
+  #   ret = lists.together_delete_at 6
+  #   print ret # => [nil, nil]
+  #   print lists # => output [[1, 2, 3, 4], [2, 3, 4, 5]]
+  #
+  # if delete_at target is exist(minus index)
+  #   child1 = [1, 2, 3, 4]
+  #   child2 = [2, 3, 4, 5]
+  #   lists = [child1, child2]
+  #   ret = lists.together_delete_at -3
+  #   print ret # => [2, 3]
+  #   print lists # => output [[1, 3, 4], [2, 4, 5]]
+  def together_delete_at(index)
+    if_not_contain_array_rails_type_error
+    reduce([]) { |ret, list|ret << list.delete_at(index) }
+  end
+
+  # Arrays bulk delete_if.
+  #
+  # together_delete_if has alias :tdelete_if
+  #
+  # if delete_if target is exist. return self.
+  #   lists = [[1, 2, 3, 4], [6, 4, 6, 8]]
+  #   ret = lists.together_delete_if {|first, second|(first + second).odd?}
+  #   print ret # => [[2, 4], [4, 8]]
+  #
+  # if delete_if target is not exist. return nil.
+  #   lists = [[2, 2, 4, 4], [6, 4, 6, 8]]
+  #   ret = lists.together_delete_if {|first, second|(first + second).odd?}
+  #   print ret # => nil
+  def together_delete_if(&block)
+    if_not_contain_array_rails_type_error
+    have_deleted = false
+    first.each_with_index do |i_v, i|
+      eval_each_str = get_args_str_for_together i
+      is_delete = instance_eval "yield(#{eval_each_str})"
+      if is_delete
+        each { |e|e.delete_at i }
+        have_deleted = true
+      end
+    end
+    have_deleted ? self : nil
+  end
+
+  # Arrays bulk empty?.
+  #
+  # together_empty? has alias :tempty?
+  #
+  # empty case
+  #   lists = [[], []]
+  #   ret = lists.together_empty?
+  #   print ret # => true
+  #
+  # not empty case
+  #   lists = [[1], []]
+  #   ret = lists.together_empty?
+  #   print ret # => false
+  def together_empty?
+    if_not_contain_array_rails_type_error
+    is_empty = true
+    each { |list|is_empty = is_empty && list.empty? }
+    is_empty
+  end
+
+  # Arrays bulk fill.
+  #
+  # together_fill has alias :tfill
+  #
+  # not use block case
+  #   lists = [[*1..5], [*6..10]]
+  #   ret = lists.together_fill(99)
+  #   print ret # => [[99, 99, 99, 99, 99], [99, 99, 99, 99, 99]]
+  #
+  # use block, no args case
+  #   lists = [[*1..5], [*6..10]]
+  #   ret = lists.together_fill { |i|(i + 1) + 1 }
+  #   print ret # => [[2, 3, 4, 5, 6], [2, 3, 4, 5, 6]]
+  #
+  # use block, has args case
+  #   lists = [[*1..5], [*6..10]]
+  #   ret = lists.together_fill(2) { |i|(i + 1) + 1 }
+  #   print ret # => [[1, 2, 4, 5, 6], [6, 7, 4, 5, 6]]
+  def together_fill(fill_value = nil, &block)
+    if_not_contain_array_rails_type_error
+    if block
+      fill_value = 0 if fill_value.nil?
+      first.each_with_index do |i_v, i|
+        next if i < fill_value
+        each { |list|list[i] = yield(i) }
+      end
+    else
+      each { |list|list.fill fill_value }
+    end
+    self
+  end
+
+  # Arrays bulk first.
+  #
+  # together_first has alias :tfirst
+  #
+  # no args case
+  #   lists = [[*1..5], [*6..10]]
+  #   ret = lists.together_first
+  #   print ret # => [1, 6]
+  #
+  # has args 2 case
+  #   lists = [[*1..5], [*6..10]]
+  #   ret = lists.together_first 2
+  #   print ret # => [[1, 2], [6, 7]]
+  #
+  # has args 0 case
+  #   lists = [[*1..5], [*6..10]]
+  #   ret = lists.together_first 0
+  #   print ret # => [[], []]
+  #
+  # has args over size case
+  #   lists = [[*1..5], [*6..10]]
+  #   ret = lists.together_first 6
+  #   print ret # => [[*1..5], [*6..10]]
+  def together_first(index = nil)
+    if_not_contain_array_rails_type_error
+    each_return = index == 0 ? '[]' : index.nil? ? 'list.first' : 'list[0..index - 1]'
+    reduce([]) { |ret, list|ret << eval(each_return, binding) }
+  end
+
+  # Arrays bulk include?.
+  #
+  # together_include? has alias :tinclude?
+  #
+  # both include single ret case
+  #   lists = [[*1..5], [*5..9]]
+  #   ret = lists.together_include? 5
+  #   print ret # => true
+  #
+  # one include single ret case
+  #   lists = [[*1..5], [*5..9]]
+  #   ret = lists.together_include? 9
+  #   print ret # => true
+  #
+  # both not include single ret case
+  #   lists = [[*1..5], [*5..9]]
+  #   ret = lists.together_include? 10
+  #   print ret # => false
+  #
+  # both include multi ret case
+  #   lists = [[*1..5], [*5..9]]
+  #   ret = lists.together_include? 5, true
+  #   print ret # => [true, true]
+  #
+  # one include multi ret case
+  #   lists = [[*1..5], [*5..9]]
+  #   ret = lists.together_include? 9, true
+  #   print ret # => [false, true]
+  #
+  # both not include multi ret case
+  #   lists = [[*1..5], [*5..9]]
+  #   ret = lists.together_include? 10, true
+  #   print ret # => [false, false]
+  def together_include?(value, is_multi = false)
+    if_not_contain_array_rails_type_error
+    return reduce([]) { |ret, list|ret << list.include?(value) } if is_multi
+    reduce(false) { |ret, list|ret = ret || list.include?(value) }
+  end
+
+  private
+
+  def if_not_contain_array_rails_type_error
+    each { |f|fail TypeError, "you have to use [Array1, Array2, ...] | #{f.class} is invalid" unless f.class == Array }
+  end
+
+  def get_args_for_together(i)
+    eval_each = []
+    each_with_index { |j_v, j|eval_each << "self[#{j}][#{i}]" }
+    eval_each
+  end
+
+  def get_args_str_for_together(i, with_index = false)
+    each_eval = with_index ? get_args_for_together(i) << i : get_args_for_together(i)
+    each_eval.join(',')
+  end
+
+  def set_together_each_return_map(ret, each_ret, index)
+    if together_return_multi?(each_ret)
+      size.times { |i|ret << [] } if index == 0
+      (0..(size - 1)).each { |i|ret[i] << each_ret[i] }
+    else
+      ret << each_ret
+    end
+    ret
+  end
+
+  def set_together_each_return_select(ret, each_ret, index)
+    unless together_return_multi?(each_ret)
+      tmp_each_ret = []
+      size.times { tmp_each_ret << each_ret }
+      each_ret = tmp_each_ret
+    end
+    size.times { |i|ret << [] } if index == 0
+    (0..(size - 1)).each { |i|ret[i] << self[i][index] if each_ret[i] }
+    ret
+  end
+
+  def initial_memo(init)
+    return init unless init.nil?
+    first.first.is_a?(Numeric) ? 0 : first.first.is_a?(String) ? '' : nil
+  end
+
+  def together_return_multi?(list)
+    (list.class == Array && list.size == size).to_bool
+  end
+
+  alias_method :tconcat, :together_concat
+  alias_method :tat, :together_at
+  alias_method :tclear, :together_clear
+  alias_method :tcompact, :together_compact
+  alias_method :tcompact!, :together_compact!
+  alias_method :tdelete, :together_delete
+  alias_method :tdelete_at, :together_delete_at
+  alias_method :tdelete_if, :together_delete_if
+  alias_method :tempty?, :together_empty?
+  alias_method :tfill, :together_fill
+  alias_method :tfirst, :together_first
+  alias_method :tinclude?, :together_include?
+  alias_methods [:together_collect, :tmap, :tcollect], :together_map
+  alias_methods [:together_collect!, :tmap!, :tcollect!], :together_map!
+  alias_methods [:together_find_all, :tselect, :tfindall], :together_select
+  alias_methods [:together_inject, :treduce, :tinject], :together_reduce
+end

data/lib/tbpgr_utils/version.rb

@@ -2,5 +2,5 @@
 
 # Tbpgr Utilities
 module TbpgrUtils
-  VERSION = '0.0.29'
+  VERSION = '0.0.30'
 end

data/spec/open_classes/array_spec.rb

@@ -1006,7 +1006,6 @@ describe Array do
     end
   end
 
-
   context :together_first do
     cases = [
       {
@@ -1085,4 +1084,99 @@ describe Array do
       end
     end
   end
+
+  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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tbpgr_utils
 version: !ruby/object:Gem::Version
-  version: 0.0.29
+  version: 0.0.30
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-02-05 00:00:00.000000000 Z
+date: 2014-02-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
-  requirement: &21487572 !ruby/object:Gem::Requirement
+  requirement: &27941640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 4.0.1
   type: :runtime
   prerelease: false
-  version_requirements: *21487572
+  version_requirements: *27941640
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &21487200 !ruby/object:Gem::Requirement
+  requirement: &27941196 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '1.3'
   type: :development
   prerelease: false
-  version_requirements: *21487200
+  version_requirements: *27941196
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &21486852 !ruby/object:Gem::Requirement
+  requirement: &27940872 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *21486852
+  version_requirements: *27940872
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &21486384 !ruby/object:Gem::Requirement
+  requirement: &29420712 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 2.14.1
   type: :development
   prerelease: false
-  version_requirements: *21486384
+  version_requirements: *29420712
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &21485892 !ruby/object:Gem::Requirement
+  requirement: &29420412 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -65,7 +65,7 @@ dependencies:
         version: 0.8.2
   type: :development
   prerelease: false
-  version_requirements: *21485892
+  version_requirements: *29420412
 description: Utilities
 email:
 - tbpgr@tbpgr.jp