tbpgr_utils 0.0.36 → 0.0.37

data/README.md

@@ -2,6 +2,7 @@
 
 [![Build Status](https://travis-ci.org/tbpgr/tbpgr_utils.png?branch=master)](https://travis-ci.org/tbpgr/tbpgr_utils)
 [![Coverage Status](https://coveralls.io/repos/tbpgr/tbpgr_utils/badge.png)](https://coveralls.io/r/tbpgr/tbpgr_utils)
+[![Code Climate](https://codeclimate.com/github/tbpgr/tbpgr_utils.png)](https://codeclimate.com/github/tbpgr/tbpgr_utils)
 
 TbpgrUtils is Utilities.
 
@@ -45,6 +46,7 @@ Or install it yourself as:
 |[TbpgrUtils Array#together_reduce](#arraytogether_reduceor-treduce-together_inject-tinject)                        |together version of Enumerable#reduce. together_reduce has aliases [:treduce, :together_inject, :tinject]            |
 |[TbpgrUtils Array#together_reverse](#arraytogether_reverseor-treverse)                                             |together version of Array#reverse. together_reverse has alias :treverse                                              |
 |[TbpgrUtils Array#together_reverse!](#arraytogether_reverseor-treverse-1)                                          |together version of Array#reverse!. together_reverse! has alias :treverse!                                           |
+|[TbpgrUtils Array#together_sample](#arraytogether_sampleor-tsample)                                                |together version of Array#sample. together_sample has alias :tsample                                                 |
 |[TbpgrUtils Array#together_select](#arraytogether_selector-tselect-together_find_all-tfindall)                     |together version of Enumerable#select. together_select has aliases [:tselect, :together_find_all, :tfindall]         |
 |[TbpgrUtils Array#together_shift](#arraytogether_shift)                                                            |together version of Array#shift. together_shift has alias :tshift                                                    |
 |[TbpgrUtils Array#together_with_index](#arraytogether_with_index)                                                  |loop all arrays by block with index                                                                                  |
@@ -628,7 +630,6 @@ print ret # => [[2, 1], []]
 print lists # => [[1, 2], []]
 ~~~
 
-
 [back to list](#list)
 
 ### Array#together_reverse!(or :treverse!)
@@ -652,6 +653,43 @@ print lists # => [[2, 1], []]
 
 [back to list](#list)
 
+### Array#together_sample(or :tsample)
+together_sample has alias :tsample
+
+not empty case
+~~~ruby
+lists = [[1, 2], [5, 6]]
+ret = lists.together_sample
+print ret # => [1 or 2, 5 or 6]
+~~~
+
+empty case
+~~~ruby
+lists = [[], []]
+ret = lists.together_sample
+print ret # => [nil, nil]
+~~~
+
+not empty case with args
+lists = [[1, 2], [5, 6]]
+ret = lists.together_sample 2
+print ret # => [[1 or 2, 1 or 2], [5 or 6, 5 or 6]] 
+~~~
+
+not empty case with args
+lists = [[], []]
+ret = lists.together_sample 2
+print ret # => [[], []]
+~~~
+
+not empty, over size case with args
+lists = [[1, 2], [5, 6]]
+ret = lists.together_sample 3
+print ret # => [[1 or 2, 1 or 2], [5 or 6, 5 or 6]] 
+~~~
+
+[back to list](#list)
+
 ### Array#together_select(or tselect, together_find_all, tfindall)
 ~~~ruby
 require 'tbpgr_utils'
@@ -1331,6 +1369,7 @@ if you are Sublime Text2 user, you can use snippet for TbpgrUtils.
 https://github.com/tbpgr/tbpgr_utils_snippets
 
 ## History
+* version 0.0.37 : add Array#together_sample(alias tsample).
 * version 0.0.36 : add Array#together_reverse,Array#together_reverse!(alias treverse, alias treverse!).
 * version 0.0.35 : add Array#together_pop(alias tpop).
 * version 0.0.34 : add Array#together_last(alias tlast).

data/lib/open_classes/array/together.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+require 'open_classes/array/together_helper'
+
+# Array
+class Array
+  include TogetherHelper
+  # 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
+end

data/lib/open_classes/array/together_at.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+require 'open_classes/array/together_helper'
+
+# Array
+class Array
+  include TogetherHelper
+
+  # 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
+
+  alias_method :tat, :together_at
+end

data/lib/open_classes/array/together_clear.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+require 'open_classes/array/together_helper'
+
+# Array
+class Array
+  include TogetherHelper
+
+  # 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
+
+  alias_method :tclear, :together_clear
+end

data/lib/open_classes/array/together_compact.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+require 'open_classes/array/together_helper'
+
+# Array
+class Array
+  include TogetherHelper
+
+  # 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
+
+  alias_method :tcompact, :together_compact
+  alias_method :tcompact!, :together_compact!
+end

data/lib/open_classes/array/together_concat.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+require 'open_classes/array/together_helper'
+
+# Array
+class Array
+  include TogetherHelper
+
+  # 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
+
+  alias_method :tconcat, :together_concat
+end

data/lib/open_classes/array/together_delete.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+require 'open_classes/array/together_helper'
+
+# Array
+class Array
+  include TogetherHelper
+
+  # 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
+
+  alias_method :tdelete, :together_delete
+end

data/lib/open_classes/array/together_delete_at.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+require 'open_classes/array/together_helper'
+
+# Array
+class Array
+  include TogetherHelper
+
+  # 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
+
+  alias_method :tdelete_at, :together_delete_at
+end

data/lib/open_classes/array/together_delete_if.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+require 'open_classes/array/together_helper'
+
+# Array
+class Array
+  include TogetherHelper
+
+  # 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
+
+  alias_method :tdelete_if, :together_delete_if
+end

data/lib/open_classes/array/together_empty.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+require 'open_classes/array/together_helper'
+
+# Array
+class Array
+  include TogetherHelper
+
+  # 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
+
+  alias_method :tempty?, :together_empty?
+end

data/lib/open_classes/array/together_fill.rb

@@ -0,0 +1,43 @@
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+require 'open_classes/array/together_helper'
+
+# Array
+class Array
+  include TogetherHelper
+
+  # 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
+
+  alias_method :tfill, :together_fill
+end

data/lib/open_classes/array/together_first.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+require 'open_classes/array/together_helper'
+
+# Array
+class Array
+  include TogetherHelper
+
+  # 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.first(index)'
+    reduce([]) { |ret, list|ret << eval(each_return, binding) }
+  end
+
+  alias_method :tfirst, :together_first
+end

data/lib/open_classes/array/together_helper.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+
+# TogetherHelper
+module TogetherHelper
+  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 together_return_multi?(list)
+    (list.class == Array && list.size == size).to_bool
+  end
+end

data/lib/open_classes/array/together_include.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+require 'open_classes/array/together_helper'
+
+# Array
+class Array
+  include TogetherHelper
+
+  # 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
+
+  alias_method :tinclude?, :together_include?
+end

data/lib/open_classes/array/together_index.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+require 'open_classes/array/together_helper'
+
+# Array
+class Array
+  include TogetherHelper
+
+  # Arrays bulk index.
+  #
+  # together_index has alias :tindex
+  #
+  # both index exist case
+  #   lists = [[*1..5], [*5..9]]
+  #   ret = lists.together_index 5
+  #   print ret # => [4, 0]
+  #
+  # one include single ret case
+  #   lists = [[*1..5], [*5..9]]
+  #   ret = lists.together_index 4
+  #   print ret # => [3, nil]
+  #
+  # both not include single ret case
+  #   lists = [[*1..5], [*5..9]]
+  #   ret = lists.together_index 10
+  #   print ret # => [nil, nil]
+  def together_index(value)
+    if_not_contain_array_rails_type_error
+    reduce([]) { |ret, list|ret << list.index(value) }
+  end
+
+  alias_method :tindex, :together_index
+end

data/lib/open_classes/array/together_insert.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+require 'open_classes/array/together_helper'
+
+# Array
+class Array
+  include TogetherHelper
+
+  # Arrays bulk insert.
+  #
+  # together_insert has alias :tinsert
+  #
+  # both insert exist case
+  #   lists = [[*1..5], [*5..9]]
+  #   ret = lists.together_insert(1, 55, 66)
+  #   print ret # => [[1, 55, 66, 2, 3, 4, 5], [5, 55, 66, 6, 7, 8, 9]]
+  #
+  # both insert exist and minus index case
+  #   lists = [[*1..5], [*5..9]]
+  #   ret = lists.together_insert(-2, 55, 66)
+  #   print ret # => [[1, 2, 3, 4, 55, 66, 5], [5, 6, 7, 8, 55, 66, 9]]
+  #
+  # both insert exist case
+  #   lists = [[*1..5], [*5..9]]
+  #   ret = lists.together_insert(6, 55, 66)
+  #   print ret # => [[1, 2, 3, 4, 5, nil, 55, 66], [5, 6, 7, 8, 9, nil, 55, 66]],
+  def together_insert(index, *args)
+    if_not_contain_array_rails_type_error
+    each { |list|list.insert(index, *args) }
+  end
+
+  alias_method :tinsert, :together_insert
+end

data/lib/open_classes/array/together_last.rb

@@ -0,0 +1,40 @@
+# encoding: utf-8
+require 'open_classes/object'
+require 'open_classes/module'
+require 'open_classes/array/together_helper'
+
+# Array
+class Array
+  include TogetherHelper
+
+  # Arrays bulk last.
+  #
+  # together_last has alias :tlast
+  #
+  # no args case
+  #   lists = [[*1..5], [*6..10]]
+  #   ret = lists.together_last
+  #   print ret # => [5, 10]
+  #
+  # has args 2 case
+  #   lists = [[*1..5], [*6..10]]
+  #   ret = lists.together_last 2
+  #   print ret # => [[4, 5], [9, 10]]
+  #
+  # has args 0 case
+  #   lists = [[*1..5], [*6..10]]
+  #   ret = lists.together_last 0
+  #   print ret # => [[], []]
+  #
+  # has args over size case
+  #   lists = [[*1..5], [*6..10]]
+  #   ret = lists.together_last 6
+  #   print ret # => [[*1..5], [*6..10]]
+  def together_last(index = nil)
+    if_not_contain_array_rails_type_error
+    each_return = index == 0 ? '[]' : index.nil? ? 'list.last' : 'list.last(index)'
+    reduce([]) { |ret, list|ret << eval(each_return, binding) }
+  end
+
+  alias_method :tlast, :together_last
+end