TbpgrUtils

require 'tbpgr_utils'
[*'a'..'c'].>>.ord # => [97, 98, 99]
[*'aa'..'ac'].>>.gsub("a", "c") # => ['cc', 'cb', 'cc']

require 'tbpgr_utils'
[*1..6].average # => 3.5
[1.5, 2.5].average # => 2.0
[*'a'..'z'].average # => raise TypeError

require 'tbpgr_utils'
[*1..6].exchange!(1, 5) # => [1, 6, 3, 4, 5, 2]
[*1..6].exchange!(1, -1) # => [1, 6, 3, 4, 5, 2]
[*1..6].exchange!(1, 6) # => [*1..6]
[].exchange!(1, 2) # => []

require 'tbpgr_utils'
[['header1', 'header2', 'header3'],['line1_1', 'line1_2', 'line1_3']].to_table

[['header1', 'header2', 'header3'],['line1_1', 'line1_2', 'line1_3']].to_html_table

[['not_header1', 'not_header2', 'not_header3'],['line1_1', 'line1_2', 'line1_3']].to_html_table({no_header: true})

require 'tbpgr_utils'

alpha = %w{one two three}
numbers = %w{1 4 3}
[alpha, numbers].together do |first, second|
  print "#{first}:#{second}\n"  # => output one:1, two:2, three:3
end

require 'tbpgr_utils'

# same elements size case
alpha = %w{one two three}
numbers = %w{1 2 3}
print [alpha, numbers].together_at 2 # => output ['three', 3]

# different elements size case
alpha = %w{one two three}
numbers = %w{1 2}
print [alpha, numbers].together_at 2 # => output ['three', nil]

require 'tbpgr_utils'

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together_clear # => [[], []]

require 'tbpgr_utils'

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]]

require 'tbpgr_utils'

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]]

require 'tbpgr_utils'

alpha = %w{one two three}
numbers = %w{1 2 3}
[alpha, numbers].together_concat [4, 5, 6]

print alpha # => ["one", "two", "three", 4, 5, 6]
print numbers # => ["1", "2", "3", 4, 5, 6]

require 'tbpgr_utils'

child1 = [1, 2, 3, 4]
child2 = [2, 3, 4, 5]
lists = [child1, child2]
ret = lists.together_delete 2
print lists # => output [[1, 3, 4], [3, 4, 5]]

require 'tbpgr_utils'

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]]

require 'tbpgr_utils'

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]]

require 'tbpgr_utils'

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]]

require 'tbpgr_utils'

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]]

require 'tbpgr_utils'

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]]

require 'tbpgr_utils'

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]]

require 'tbpgr_utils'

lists = [[2, 2, 4, 4], [6, 4, 6, 8]]
ret = lists.together_delete_if {|first, second|(first + second).odd?}
print ret # => nil

require 'tbpgr_utils'

lists = [[], []]
ret = lists.together_empty?
print ret # => true

require 'tbpgr_utils'

lists = [[1], []]
ret = lists.together_empty?
print ret # => false

require 'tbpgr_utils'

lists = [[*1..5], [*6..10]]
ret = lists.together_fill(99)
print ret # => [[99, 99, 99, 99, 99], [99, 99, 99, 99, 99]]

require 'tbpgr_utils'

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]]

require 'tbpgr_utils'

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]]

require 'tbpgr_utils'

lists = [[*1..5], [*6..10]]
ret = lists.together_first
print ret # => [1, 6]

require 'tbpgr_utils'

lists = [[*1..5], [*6..10]]
ret = lists.together_first 2
print ret # => [[1, 2], [6, 7]]

require 'tbpgr_utils'

lists = [[*1..5], [*6..10]]
ret = lists.together_first 0
print ret # => [[], []]

require 'tbpgr_utils'

lists = [[*1..5], [*6..10]]
ret = lists.together_first 6
print ret # => [[*1..5], [*6..10]]

require 'tbpgr_utils'

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 5
print ret # => true

require 'tbpgr_utils'

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 9
print ret # => true

require 'tbpgr_utils'

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 10
print ret # => false

require 'tbpgr_utils'

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 5, true
print ret # => [true, true]

require 'tbpgr_utils'

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 9, true
print ret # => [false, true]

require 'tbpgr_utils'

lists = [[*1..5], [*5..9]]
ret = lists.together_include? 10, true
print ret # => [false, false]

require 'tbpgr_utils'

lists = [[*1..5], [*5..9]]
ret = lists.together_index 5
print ret # => [4, 0]

require 'tbpgr_utils'

lists = [[*1..5], [*5..9]]
ret = lists.together_index 4
print ret # => [3, nil]

require 'tbpgr_utils'

lists = [[*1..5], [*5..9]]
ret = lists.together_index 10
print ret # => [nil, nil]

require 'tbpgr_utils'

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]]

require 'tbpgr_utils'

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]]

require 'tbpgr_utils'

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]],

require 'tbpgr_utils'

lists = [[*1..5], [*6..10]]
ret = lists.together_last
print ret # => [5, 10]

require 'tbpgr_utils'

lists = [[*1..5], [*6..10]]
ret = lists.together_last 2
print ret # => [[4, 5], [9, 10]]

require 'tbpgr_utils'

lists = [[*1..5], [*6..10]]
ret = lists.together_last 0
print ret # => [[], []]

require 'tbpgr_utils'

lists = [[*1..5], [*6..10]]
ret = lists.together_last 6
print ret # => [[*1..5], [*6..10]]

require 'tbpgr_utils'

alpha = %w{one two three}
numbers = %w{1 2 3}
ret = [alpha, numbers].together_map {|first, second|"#{first}:#{second}"}
print ret # => output [one:1, two:2, three:3]

require 'tbpgr_utils'

alpha = %w{one two three}
numbers = %w{1 2 3}
ret = [alpha, numbers].together_map {|first, second|[["#{first}:ret"], ["#{second}:ret"]]}
print ret # => output [["one:ret", "two:ret", "three:ret"],["1:ret", "2:ret", "3:ret"]]

require 'tbpgr_utils'

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']

require 'tbpgr_utils'

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']]

require 'tbpgr_utils'

lists = [[1, 2], [5, 6]]
ret = lists.together_pop
print ret # => [2, 6]
print lists # => [1, 5]

require 'tbpgr_utils'

lists = [[], []]
ret = lists.together_pop
print ret # => [nil, nil]
print lists # => [[], []]

require 'tbpgr_utils'

lists = [[1, 2], [5, 6]]
ret = lists.together_pop 2
print ret # => [[1, 2], [5, 6]]
print lists # => [[], []]

require 'tbpgr_utils'

lists = [[], []]
ret = lists.together_pop 2
print ret # => [[], []]
print lists # => [[], []]

require 'tbpgr_utils'

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

require 'tbpgr_utils'

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

require 'tbpgr_utils'

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'

require 'tbpgr_utils'

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]

require 'tbpgr_utils'

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}

require 'tbpgr_utils'

lists = [[1, 2], [5, 6]]
ret = lists.together_reverse
print ret # => [[2, 1], [6, 5]]
print lists # => [[1, 2], [5, 6]]

require 'tbpgr_utils'

lists = [[1, 2], []]
ret = lists.together_reverse
print ret # => [[2, 1], []]
print lists # => [[1, 2], []]

require 'tbpgr_utils'

lists = [[1, 2], [5, 6]]
ret = lists.together_reverse!
print ret # => [[2, 1], [6, 5]]
print lists # => [[2, 1], [6, 5]]

require 'tbpgr_utils'

lists = [[1, 2], []]
ret = lists.together_reverse!
print ret # => [[2, 1], []]
print lists # => [[2, 1], []]

require 'tbpgr_utils'

lists = [[1, 2], [5, 6]]
ret = lists.together_sample
print ret # => [1 or 2, 5 or 6]

require 'tbpgr_utils'

lists = [[], []]
ret = lists.together_sample
print ret # => [nil, nil]

require 'tbpgr_utils'

lists = [[1, 2], [5, 6]]
ret = lists.together_sample 2
print ret # => [[1 or 2, 1 or 2], [5 or 6, 5 or 6]] 

require 'tbpgr_utils'

lists = [[], []]
ret = lists.together_sample 2
print ret # => [[], []]

require 'tbpgr_utils'

lists = [[1, 2], [5, 6]]
ret = lists.together_sample 3
print ret # => [[1 or 2, 1 or 2], [5 or 6, 5 or 6]] 

require 'tbpgr_utils'

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]]

require 'tbpgr_utils'

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]]

require 'tbpgr_utils'

lists = [[1, 2], [5, 6]]
ret = lists.together_shift
print ret # => [1, 5]
print lists # => [2, 6]

require 'tbpgr_utils'

lists = [[], []]
ret = lists.together_shift
print ret # => [nil, nil]
print lists # => [[], []]

require 'tbpgr_utils'

lists = [[1, 2], [5, 6]]
ret = lists.together_shift 2
print ret # => [[1, 2], [5, 6]]
print lists # => [[], []]

require 'tbpgr_utils'

lists = [[], []]
ret = lists.together_shift 2
print ret # => [[], []]
print lists # => [[], []]

require 'tbpgr_utils'

lists = [[1, 2], [5, 6]]
ret = lists.together_shuffle
print ret # => [[1 or 2, 1 or 2], [5 or 6, 5 or 6]]

require 'tbpgr_utils'

lists = [[*1..5], [*6..10]]
ret = lists.together_slice 2
print ret # => [3, 8]

require 'tbpgr_utils'

lists = [[*1..5], [*6..10]]
ret = lists.together_slice 2, 2
print ret # => [[3, 4], [8, 9]]

require 'tbpgr_utils'

lists = [[*1..5], [*6..10]]
ret = lists.together_slice (2..3)
print ret # => [[3, 4], [8, 9]]

require 'tbpgr_utils'

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

require 'tbpgr_utils'

([*1..6] + [2,3]).uniq_size # => 6
[*1..6].uniq_size # => 6
[].uniq_size # => 0

require 'attr_enumerable'
class Person
  attr_reader :name, :age
  def initialize(name, age)
    @name, @age = name, age
  end
end

class Persons
  attr_reader :persons
  include AttrEnumerable
  def initialize(persons = [])
    @persons = persons
  end

  def <<(person)
    @persons << person
  end
end

persons = Persons.new([Person.new("tanaka", 84), Person.new("suzuki", 103)])
persons.at_name 0 # => 'tanaka'
persons.at_name 1 # => 'suzuki'
persons.at_name -1 # => 'suzuki'
persons.at_age 0 # => 84
persons.at_age 2 # => nil

persons = Persons.new([])
persons.at_name 0 # => nil

require 'attr_enumerable'
class Person
  attr_reader :name, :age
  def initialize(name, age)
    @name, @age = name, age
  end
end

class Persons
  attr_reader :persons
  include AttrEnumerable
  def initialize(persons = [])
    @persons = persons
  end

  def <<(person)
    @persons << person
  end
end

persons = Persons.new([Person.new("tanaka", 84), Person.new(nil, 99), Person.new("suzuki", nil)])
persons.compact_name # => ['tanaka', 'suzuki']
persons.compact_age # => [84, 99]

persons = Persons.new([])
persons.compact_name 0 # => []

require 'attr_enumerable'
class Person
  attr_reader :name, :age
  def initialize(name, age)
    @name, @age = name, age
  end
end

class Persons
  attr_reader :persons
  include AttrEnumerable
  def initialize(persons = [])
    @persons = persons
  end

  def <<(person)
    @persons << person
  end
end

persons = Persons.new([Person.new("tanaka", 84), Person.new(nil, 99), Person.new("suzuki", nil)])
persons.concat_name(["sato", "matsumoto"]) # => ['tanaka', nil, 'suzuki', "sato", "matsumoto"]
persons.concat_age([20, 1]) # => [84, 99, nil, 20, 1]

persons = Persons.new([])
persons.concat_name(["sato", "matsumoto"]) # => ["sato", "matsumoto"]

require 'attr_enumerable'
class Person
  attr_reader :name, :age
  def initialize(name, age)
    @name, @age = name, age
  end
end

class Persons
  attr_reader :persons
  include AttrEnumerable
  def initialize(persons = [])
    @persons = persons
  end

  def <<(person)
    @persons << person
  end
end

persons = Persons.new([Person.new("tanaka", 84), Person.new("tanaka", 99), Person.new("suzuki", 99)])
persons.delete_name("tanaka") # => persons =  Persons.new(Person.new("suzuki", 99)])
persons = Persons.new([Person.new("tanaka", 84), Person.new("tanaka", 99), Person.new("suzuki", 99)])
persons.delete_age(99) # => persons =  Persons.new([Person.new("tanaka", 84)])

require 'attr_enumerable'
class Person
  attr_reader :name, :age
  def initialize(name, age)
    @name, @age = name, age
  end
end

class Persons
  attr_reader :persons
  include AttrEnumerable
  def initialize(persons = [])
    @persons = persons
  end

  def <<(person)
    @persons << person
  end
end

persons = Persons.new([Person.new("tanaka", 84), Person.new("suzuki", 103)])
persons.each_name do |name|
  puts name # => "tanaka", "suzuki"
end

persons.each_age do |age|
  puts age # => 84, 103
end

require 'attr_enumerable'
class Person
  attr_reader :name, :age
  def initialize(name, age)
    @name, @age = name, age
  end
end

class Persons
  attr_reader :persons
  include AttrEnumerable
  def initialize(persons = [])
    @persons = persons
  end

  def <<(person)
    @persons << person
  end
end

persons = Persons.new([Person.new("tanaka", 84), Person.new("suzuki", 103)])
persons.each_name_with_index do |name, i|
  puts "#{name}:#{i}" # => "tanaka:0", "suzuki:1"
end

persons.each_age_with_index do |age, i|
  puts "#{age.to_s}:#{i}" # => "84:0", "103:0"
end

require 'attr_enumerable'

class Person
  attr_reader :name, :age
  def initialize(name, age)
    @name, @age = name, age
  end
end

class Persons
  attr_reader :persons
  include AttrEnumerable
  def initialize(persons = [])
    @persons = persons
  end

  def <<(person)
    @persons << person
  end
end

persons = Persons.new([Person.new("tanaka", 84), Person.new("tanaka", 20), Person.new("suzuki", 20)])
print persons.first_name # => 'tanaka'
print persons.first_name(2) # => ['tanaka', 'tanaka']
print persons.first_age(4) # => [84, 20, 20]

persons = Persons.new([])
print persons.first_age(4) # => []

require 'attr_enumerable'

class Person
  attr_reader :name, :age
  def initialize(name, age)
    @name, @age = name, age
  end
end

class Persons
  attr_reader :persons
  include AttrEnumerable
  def initialize(persons = [])
    @persons = persons
  end

  def <<(person)
    @persons << person
  end
end

persons = Persons.new([Person.new("tanaka", 84), Person.new("tanaka", 20), Person.new("suzuki", 20)])
print persons.last_name # => 'suzuki'
print persons.last_name(2) # => ['suzuki', 'tanaka']
print persons.last_age(4) # => [84, 20, 20]

persons = Persons.new([])
print persons.last_age(4) # => []

require 'attr_enumerable'

class Person
  attr_reader :name, :age
  def initialize(name, age)
    @name, @age = name, age
  end
end

class Persons
  attr_reader :persons
  include AttrEnumerable
  def initialize(persons = [])
    @persons = persons
  end

  def <<(person)
    @persons << person
  end
end

persons = Persons.new([Person.new("tanaka", 84), Person.new("suzuki", 103)])
print persons.reverse_name # => ['suzuki', 'tanaka']

print persons.reverse_age # => [103, 84]

require 'attr_enumerable'

class Person
  attr_reader :name, :age
  def initialize(name, age)
    @name, @age = name, age
  end
end

class Persons
  attr_reader :persons
  include AttrEnumerable
  def initialize(persons = [])
    @persons = persons
  end

  def <<(person)
    @persons << person
  end
end

persons = Persons.new([Person.new("tanaka", 84), Person.new("suzuki", 103)])
print persons.map_name { |v|v.upcase } # => ['TANAKA', 'SUZUKI']
print persons.map_age { |v|v += 1 } # => [85, 104]

require 'attr_enumerable'

class Person
  attr_reader :name, :age
  def initialize(name, age)
    @name, @age = name, age
  end
end

class Persons
  attr_reader :persons
  include AttrEnumerable
  def initialize(persons = [])
    @persons = persons
  end

  def <<(person)
    @persons << person
  end
end

persons = Persons.new([Person.new("tanaka", 84), Person.new("suzuki", 103)])
print persons.reduce_name('') { |a, e|a = "#{a}#{e.upcase}"; a } # => 'TANAKASUZUKI'
print persons.reduce_age { |a, e|a += e + 1; a } # => 189

require 'attr_enumerable'

class Person
  attr_reader :name, :age
  def initialize(name, age)
    @name, @age = name, age
  end
end

class Persons
  attr_reader :persons
  include AttrEnumerable
  def initialize(persons = [])
    @persons = persons
  end

  def <<(person)
    @persons << person
  end
end

persons = Persons.new([Person.new("tanaka", 84), Person.new("suzuki", 103)])
print persons.sample_name # => 'tanaka' or 'suzuki'
print persons.sample_name(2) # => ['tanaka', 'suzuki'] or ['suzuki', 'tanaka']
print persons.sample_age(2) # => [84, 103] or [103, 84]

require 'attr_enumerable'

class Person
  attr_reader :name, :age
  def initialize(name, age)
    @name, @age = name, age
  end
end

class Persons
  attr_reader :persons
  include AttrEnumerable
  def initialize(persons = [])
    @persons = persons
  end

  def <<(person)
    @persons << person
  end
end

persons = Persons.new([Person.new("tanaka", 84), Person.new("tanaka", 20), Person.new("suzuki", 20)])
print persons.select_name { |v|v == 'tanaka' } # => ['tanaka' ,'tanaka']
print persons.select_age { |v|v == 20 } # => [20 ,20]

require 'attr_enumerable'

class Person
  attr_reader :name, :age
  def initialize(name, age)
    @name, @age = name, age
  end
end

class Persons
  attr_reader :persons
  include AttrEnumerable
  def initialize(persons = [])
    @persons = persons
  end

  def <<(person)
    @persons << person
  end
end

persons = Persons.new([Person.new("tanaka", 84), Person.new("suzuki", 103)])
print persons.shuffle_name # => ['tanaka', 'suzuki'] or['suzuki', 'tanaka']
print persons.shuffle_age # => [84, 103] or [103, 84]

require 'attr_enumerable'

class Person
  attr_reader :name, :age
  def initialize(name, age)
    @name, @age = name, age
  end
end

class Persons
  attr_reader :persons
  include AttrEnumerable
  def initialize(persons = [])
    @persons = persons
  end

  def <<(person)
    @persons << person
  end
end

persons = Persons.new([Person.new("tanaka", 84), Person.new("suzuki", 33), Person.new("suzuki", 103)])
print persons.slice_name(1) # => 'suzuki'
print persons.slice_age(0, 2) # => [84, 33]
print persons.slice_age(1..2) # => [33, 103]

require 'attributes_initializable'
require 'attributes_hashable'

class Hoge
  include AttributesInitializable
  attr_accessor_init :hoge, :hige
  include AttributesHashable
end

hoge = Hoge.new do |h|
  h.hoge = 'hoge'
  h.hige = 'hige'
end

hoge.to_hash # => {:hoge=>"hoge", :hige=>"hige"}

# After include AttributesHashable, you can use Hash.try_convert.
Hash.try_convert hoge # => {:hoge=>"hoge", :hige=>"hige"}

require 'attributes_initializable'

class AccessorSample
  include AttributesInitializable
  attr_accessor_init :atr1, :atr2
end

atr_sample1 = AccessorSample.new :atr1 => 'atr1', :atr2 => 'atr2'
p atr_sample1.atr1 # => atr1
p atr_sample1.atr2 # => atr2

atr_sample2 = AccessorSample.new do |a|
  a.atr1 = 'atr1'
  a.atr2 = 'atr2'
end
p atr_sample2.atr1 # => atr1
p atr_sample2.atr2 # => atr2

class AccessorSample
  attr_accessor :atr1, :atr2

  def initialize(values = nil, &block)
    return yield self if block
    @atr1 = values[:atr1]
    @atr2 = values[:atr2]
  end
end

atr_sample1 = AccessorSample.new :atr1 => 'atr1', :atr2 => 'atr2'
p atr_sample1.atr1 # => atr1
p atr_sample1.atr2 # => atr2

atr_sample2 = AccessorSample.new do |a|
  a.atr1 = 'atr1'
  a.atr2 = 'atr2'
end
p atr_sample2.atr1 # => atr1
p atr_sample2.atr2 # => atr2

require 'attributes_initializable'

class AccessorSample
  include AttributesInitializable
  attr_reader_init :atr1, :atr2
end

atr_sample1 = AccessorSample.new :atr1 => 'atr1', :atr2 => 'atr2'
p atr_sample1.atr1 # => atr1
p atr_sample1.atr2 # => atr2

# can not use writer.
# atr_sample2 = AccessorSample.new do |a|
#   a.atr1 = 'atr1'
#   a.atr2 = 'atr2'
# end

class AccessorSample
  attr_reader :atr1, :atr2

  def initialize(values = nil, &block)
    return yield self if block
    @atr1 = values[:atr1]
    @atr2 = values[:atr2]
  end
end

atr_sample1 = AccessorSample.new :atr1 => 'atr1', :atr2 => 'atr2'
p atr_sample1.atr1 # => atr1
p atr_sample1.atr2 # => atr2

# can not use writer.
# atr_sample2 = AccessorSample.new do |a|
#   a.atr1 = 'atr1'
#   a.atr2 = 'atr2'
# end

require 'attributes_initializable'

class AccessorSample
  include AttributesInitializable
  attr_writer_init :atr1, :atr2
end

atr_sample1 = AccessorSample.new :atr1 => 'atr1', :atr2 => 'atr2'
# can not use reader
# p atr_sample1.atr1 # => atr1
# p atr_sample1.atr2 # => atr2
atr_sample1.instance_variable_get "@atr1" # => atr1
atr_sample1.instance_variable_get "@atr2" # => atr2

atr_sample2 = AccessorSample.new do |a|
  a.atr1 = 'atr1'
  a.atr2 = 'atr2'
end

# can not use reader
# p atr_sample2.atr1 # => atr1
# p atr_sample2.atr2 # => atr2
atr_sample2.instance_variable_get "@atr1" # => atr1
atr_sample2.instance_variable_get "@atr2" # => atr2

class AccessorSample
  attr_writer :atr1, :atr2

  def initialize(values = nil, &block)
    return yield self if block
    @atr1 = values[:atr1]
    @atr2 = values[:atr2]
  end
end

atr_sample1 = AccessorSample.new :atr1 => 'atr1', :atr2 => 'atr2'
# can not use reader
# p atr_sample1.atr1 # => atr1
# p atr_sample1.atr2 # => atr2
atr_sample1.instance_variable_get "@atr1" # => atr1
atr_sample1.instance_variable_get "@atr2" # => atr2

atr_sample2 = AccessorSample.new do |a|
  a.atr1 = 'atr1'
  a.atr2 = 'atr2'
end
# can not use reader
# p atr_sample2.atr1 # => atr1
# p atr_sample2.atr2 # => atr2
atr_sample2.instance_variable_get "@atr1" # => atr1
atr_sample2.instance_variable_get "@atr2" # => atr2

require "end_erb"

def hoge
  hash = {
    hoge: '@hoge@',
    hige: '@hige@',
  }
  EndERB.apply(hash)
end

puts hoge

__END__
hoge=<%=hash[:hoge]%>
hige=<%=hash[:hige]%>

require 'familyable'
persons = [
  a = Familyable::Person.new(id: 1, parent_ids: [2, 3]),
  b = Familyable::Person.new(id: 2, parent_ids: []),
  c = Familyable::Person.new(id: 3, parent_ids: [4],),
  d = Familyable::Person.new(id: 4, parent_ids: [3]),
  e = Familyable::Person.new(id: 5, parent_ids: [2]),
]

family = Familyable::Family.new(family: persons)
family.get_parents a # => return person [b, c]
family.get_children b # => return person [a, e]
family.get_brothers a # => return person [d, e]

require 'tbpgr_utils'
Fixnum.to_fixnum_html_table(1, 10, 2)

Fixnum.to_fixnum_table(1, 100, 10)

Fixnum.to_fixnum_table(1, 10, 2)

require 'ghostable'
module Checkable
  include Ghostable
  ghost_method /check_range_.*\?$/, :check_range do |method_name, *args, &block|
    method_name.to_s =~ /(check_range_)(\d+)(_to_)(\d*)/
    from = $2.to_i
    to = $4.to_i
    value = args.first
    (from..to).include? value
  end

  ghost_method /^contain_.*\?$/, :check_contain do |method_name, *args, &block|
    method_name.to_s =~ /^(contain_)(.*)(\?)/
    word = $2
    value = args.first
    value.include? word
  end
end

class SampleChecker
  include Checkable
end

sample = SampleChecker.new
sample.check_range_3_to_5?(4) # => return true
sample.check_range_3_to_5?(6) # => return false
sample.check_range_3_to_6?(6) # => return true

sample.contain_hoge? "test_hoge_test" # => return true
sample.contain_hoge? "test_hige_test" # => return false
sample.contain_hige? "test_hige_test" # => return true

require 'test_toolbox'

result = capture_stdout {puts "test"} # => "test"

# no stdout case. return empty.
result = capture_stdout {sleep 0.1} # => ""(empty)

require 'test_toolbox'

# default usage
dp_line __LINE__
# output is following. yy = line no.
# => --------------------|filename=|line=yy|--------------------\n

# output with filename
dp_line __LINE__, filename: __FILE__
# output is following. xx=filenamem, yy = line no.
# => --------------------|filename=xx|line=yy|--------------------\n

# output with specific line charactor.
dp_line __LINE__, filename: __FILE__, char: '@'
# output is following. xx=filenamem, yy = line no.
# => @@@@@@@@@@@@@@@@@@@@|filename=xx|line=yy$|@@@@@@@@@@@@@@@@@@@@\n

require 'tbpgr_utils'
h = {key1: "value1", key2: "value2"}
h.>>.upcase # => {key1: "VALUE1", key2: "VALUE2"}
h.>>.+('_hoge') # => {key1: "value1_hoge", key2: "value2_hoge"}

require 'tbpgr_utils'
{
  :key_1 => :value1,
  :key__2 => :value2,
  :key___3 => :value3,
}.html_table

require 'tbpgr_utils'
{
  :key_1 => :value1___________________,
  :key__2 => :value2,
  :key___3 => :value3,
}.table

|key_1  |value1___________________|
|key__2 |value2                   |
|key___3|value3                   |

require 'tbpgr_utils'
ret=[];
12345.each_digit_with_index { |v, i|ret << v + i };
print ret # => [1, 3, 5, 7, 9]

require 'tbpgr_utils'
ret=[];
12345.each_digit { |v|ret << v + 1 };
print ret # => [2,3,4,5,6]

require 'tbpgr_utils'
0.palindromic_prime? # => false
1.palindromic_prime? # => false
2.palindromic_prime? # => true
11.palindromic_prime? # => true
757.palindromic_prime? # => true
758.palindromic_prime? # => false

require 'tbpgr_utils'
ret=[];
12345.reverse_each_digit { |v|ret << v + 1 };
print ret # => [6, 5, 4, 3, 2]

require 'tbpgr_utils'
puts yes # return true
puts ok # return true
puts good # return true

puts no # return false
puts ng # return false
puts bad # return false

require 'tbpgr_utils'
bulk_define_methods [NilClass, FalseClass], :blank?, true
bulk_define_methods [TrueClass, Numeric], "blank?", false

puts nil.blank?   # => true
puts false.blank? # => true
puts true.blank?  # => false
puts 1.blank?     # => false

bulk_define_methods [NilClass, FalseClass], [:blank?, :present?], [true, false]
bulk_define_methods [TrueClass, Numeric], [:blank?, :present?], [false, true]

puts nil.blank?     # => true
puts nil.present?   # => false
puts false.blank?   # => true
puts false.present? # => false
puts true.blank?    # => false
puts true.present?  # => true
puts 1.blank?       # => false
puts 1.present?     # => true

class NilClass
 def blank?
   true
 end

 def present?
   false
 end
end

class FalseClass
 def blank?
   true
 end

 def present?
   false
 end
end

class BaseHogeForAncestors;end
class HogeForAncestors < BaseHogeForAncestors;end

puts HogeForAncestors.aa_ancestors

require 'tbpgr_utils'
n = 1
actual = evalb(binding) do
  <<-EOS
n = n + 1
n = n + 2
     EOS
end

print actual # => 4

a = 1
b = 2
a, b = exchange(a, b)
a # => 2
b # => 1

require 'tbpgr_utils'

class Person
  attr_accessor :name, :age
end

person = Person.new
person.hash_to_attributes({name: 'hoge', age: 33})

#<PersonForHashToAttributes:0x3957858 @age=33, @not_exists="hoge">

require 'tbpgr_utils'
null # => nil

print_eval 8/4, binding  # => 8/4 # => 2

message = 'msg'
print_eval "hoge-#{message}", binding # => "hoge-#{message}" # => "hoge-msg"

puts_eval 8/4, binding

message = 'msg'
puts_eval "hoge-#{message}", binding # => "hoge-#{message}" # => "hoge-msg"

message = "msg"
bulk_puts_eval binding, <<-EOS
"hoge-hige1" + "add" + message
"hoge-hige2" + "add" + message
EOS

require 'tbpgr_utils'
[*1..4].if_else_map(
        :odd?.to_proc,
        ->(odd){'odd'},
        ->(even){'even'}
      )
__END__
["odd", "even", "odd", "even"]

require 'tbpgr_utils'
[*?a..?z].if_else_map(
        :vowel?.to_proc,
        ->(alph){ "#{alph} is vowel" },
        ->(alph){ "#{alph} is not vowel" }
      )

__END__
["a is vowel",
 "b is not vowel",
 "c is not vowel",
 "d is not vowel",
 "e is vowel",
 "f is not vowel",
 "g is not vowel",
 "h is not vowel",
 "i is vowel",
 "j is not vowel",
 "k is not vowel",
 "l is not vowel",
 "m is not vowel",
 "n is not vowel",
 "o is vowel",
 "p is not vowel",
 "q is not vowel",
 "r is not vowel",
 "s is not vowel",
 "t is not vowel",
 "u is vowel",
 "v is not vowel",
 "w is not vowel",
 "x is not vowel",
 "y is not vowel",
 "z is not vowel"]

require 'tbpgr_utils'
[*1..3].kernel_send:Rational # => [(1/1), (2/1), (3/1)]
[*1..3].kernel_send:print # => 123
[*65..68].kernel_send :putc # => ABCD

require 'tbpgr_utils'
[*1..5].sum # => 15
[*?a..?e].sum # => "abcde"

require 'eval_helper_object'
require_code("hoge") # => 'require "hoge"'

class EvalHelperAttrAccessorInitTest
  include EvalHelper

  def hoge(args)
    attr_accessor_init_code(args)
  end
end

EvalHelperAttrAccessorInitTest.new.hoge('atr1')

attr_accessor :atr1

def initialize(atr1)
  @atr1 = atr1
end

class EvalHelperAttrAccessorInitTest
  include EvalHelper

  def hoge(args)
    attr_accessor_init_code(args)
  end
end

EvalHelperAttrAccessorInitTest.new.hoge(['atr1', 'atr2'])

attr_accessor :atr1, :atr2

def initialize(atr1, atr2)
  @atr1 = atr1
  @atr2 = atr2
end

require 'eval_helper'
class EvalHelperEacjBraceTest
  include EvalHelper

  def hoge(hash)
    each_do_code(hash[:target], hash[:proc])
  end
end

hash = {
  target: '[:a, :b]',
  proc: "puts \"\#{v}1\"\nputs \"\#{v}2\"\n",
}
EvalHelperEacjBraceTest.new.hoge(hash) # => return "[:a, :b].each do |v|\n  puts \"\#{v}1\"\n  puts \"\#{v}2\"\nend"

require 'eval_helper'
class EvalHelperEacjBraceTest
  include EvalHelper

  def hoge(hash)
    each_brace_code(hash[:target], hash[:proc])
  end
end

hash = {
  target: '[:a, :b]',
  proc: 'puts v',
}
EvalHelperEacjBraceTest.new.hoge(hash) # => return '[:a, :b].each { |v|puts v }'

require 'eval_helper'
class EvalHelperEachWithIndexBraceTest
  include EvalHelper

  def hoge(hash)
    each_with_index_brace_code(hash[:target], hash[:proc])
  end
end

hash = {
  target: '[:a, :b]',
  proc: 'puts "#{i}:#{v}"',
}
EvalHelperEachWithIndexBraceTest.new.hoge(hash) # => return '[:a, :b].each_with_index { |v, i|puts "#{i}:#{v}" }'

require 'eval_helper'
class EvalHelperEachWithIndexDoTest
  include EvalHelper

  def hoge(hash)
    each_with_index_do_code(hash[:target], hash[:proc])
  end
end

hash = {
  target: '[:a, :b]',
  proc: "puts \"\#{i}:\#{v}1\"\nputs \"\#{i}:\#{v}2\"\n",
}
EvalHelperEachWithIndexDoTest.new.hoge(hash) # => return "[:a, :b].each_with_index do |v, i|\n  puts \"\#{i}:\#{v}1\"\n  puts \"\#{i}:\#{v}2\"\nend"

require 'eval_helper'
class EvalHelperTest
  include EvalHelper

  def hoge(hash)
    msg = hash[:input]
    code = if_code(hash[:if_cond], hash[:if_proc], hash[:else_proc])
    instance_eval code
  end
end

hash = {
  input: "test",
  if_cond: "msg == 'test'",
  if_proc: "true",
  else_proc: "false",
}
EvalHelperTest.new.hoge(hash) # => return true

require 'eval_helper'
class EvalHelperTest
  include EvalHelper

  def hoge(hash)
    msg = hash[:input]
    code = if_code(hash[:if_cond], hash[:if_proc], hash[:else_proc])
    instance_eval code
  end
end

hash = {
  input: "not_test",
  if_cond: "msg == 'test'",
  if_proc: "true",
  else_proc: "false",
}
EvalHelperTest.new.hoge(hash) # => return false

require 'eval_helper'

class EvalHelperTest
  include EvalHelper

  def hoge(hash)
    msg = hash[:input]
    code = if_code_after(hash[:if_cond], hash[:if_proc])
    ret = 'dafault'
    instance_eval code
    ret
  end
end

hash = {
  input: "test",
  if_cond: "msg == 'test'",
  if_proc: "ret = 'true'",
}
EvalHelperTest.new.hoge(hash) # => return 'true'

require 'eval_helper'

class EvalHelperTest
  include EvalHelper

  def hoge(hash)
    msg = hash[:input]
    code = if_code_after(hash[:if_cond], hash[:if_proc])
    ret = 'ret = "true"'
    instance_eval code
    ret
  end
end

hash = {
  input: "not_test",
  if_cond: "msg == 'test'",
  if_proc: "ret = 'true'",
}
EvalHelperTest.new.hoge(hash) # => return 'default'

require 'eval_helper'
class EvalHelperRequireTest
  include EvalHelper

  def hoge(*args)
    require_code(args)
  end
end

args = 'tbpgr_utils'
EvalHelperRequireTest.new.hoge(args) # => return "require 'tbpgr_utils'\n"

require 'eval_helper'
class EvalHelperRequireTest
  include EvalHelper

  def hoge(*args)
    require_code(args)
  end
end

args =  ['tbpgr_utils', 'eval_helper']
EvalHelperRequireTest.new.hoge(args) # => return "require 'tbpgr_utils'\nrequire 'eval_helper'\n"

require 'eval_helper'
class EvalHelperRequireRelativeTest
  include EvalHelper

  def hoge(*args)
    require_relative_code(args)
  end
end

args = 'tbpgr_utils'
EvalHelperRequireRelativeTest.new.hoge(args) # => return "require_relative 'tbpgr_utils'\n"

require 'eval_helper'
class EvalHelperRequireRelativeTest
  include EvalHelper

  def hoge(*args)
    require_relative_code(args)
  end
end

args =  ['tbpgr_utils', 'eval_helper']
EvalHelperRequireRelativeTest.new.hoge(args) # => return "require_relative 'tbpgr_utils'\nrequire_relative 'eval_helper'\n"

require 'eval_helper'
class EvalHelperSetVariableTest
  include EvalHelper

  def hoge(name, value)
    set_variable_code(name, value)
  end
end

hash = {
  name: 'hoge',
  value: '"hoge"',
}
EvalHelperSetVariableTest.new.hoge(hash[:name], hash[:value])

hoge = "hoge"

require 'eval_helper'
class EvalHelperSetVariableTest
  include EvalHelper

  def hoge(name, value)
    set_variable_code(name, value)
  end
end

hash = {
  name: 'hoge_num',
  value: '1',
}
EvalHelperSetVariableTest.new.hoge(hash[:name], hash[:value])

hoge_num = 1

require 'eval_helper'
class EvalHelperSetVariablesTest
  include EvalHelper

  def hoge(variables)
    set_variables_code(variables)
  end
end

variables = [
  {
    name: 'name1',
    value: '"value1"',
  },
  {
    name: 'name2',
    value: '"value2"',
  },
]
EvalHelperSetVariablesTest.new.hoge(variables)

require 'eval_helper'

class EvalHelperTimesTest
  include EvalHelper

  def hoge(number, proc)
    times_code(number, proc)
  end
end

hash = {
  number: 2,
  proc: 'puts "#{i}times"',
}
EvalHelperTimesTest.new.hoge(hash[:number], hash[:proc])

require 'eval_helper'

class EvalHelperTimesTest
  include EvalHelper

  def hoge(number, proc)
    times_code(number, proc)
  end
end

hash = {
  number: 3,
  proc: 'puts "#{i}times"\nputs "#{i*2}times"',
}
EvalHelperTimesTest.new.hoge(hash[:number], hash[:proc])

require 'eval_helper'

class EvalHelperTernaryTest
  include EvalHelper

  def hoge(hash)
    msg = hash[:input]
    code = \
      if hash[:ret]
        ternary_operator(hash[:cond], hash[:true_case], hash[:false_case], hash[:ret])
      else
        ternary_operator(hash[:cond], hash[:true_case], hash[:false_case])
      end
    instance_eval code
  end
end

hash = {
  input: "test",
  cond: "msg == 'test'",
  true_case: "true",
  false_case: "false",
  ret: "ret",
}
EvalHelperTernaryTest.new.hoge(hash) # => return 'true'

require 'eval_helper'

class EvalHelperTernaryTest
  include EvalHelper

  def hoge(hash)
    msg = hash[:input]
    code = \
      if hash[:ret]
        ternary_operator(hash[:cond], hash[:true_case], hash[:false_case], hash[:ret])
      else
        ternary_operator(hash[:cond], hash[:true_case], hash[:false_case])
      end
    instance_eval code
  end
end

hash = {
  input: "not_test",
  cond: "msg == 'test'",
  true_case: "true",
  false_case: "false",
  ret: "ret",
}
EvalHelperTernaryTest.new.hoge(hash) # => return 'false'

require 'eval_helper'
class EvalHelperTest
  include EvalHelper

  def hoge(hash)
    msg = hash[:input]
    code = unless_code(hash[:unless_cond], hash[:unless_proc], hash[:else_proc])
    instance_eval code
  end
end

hash = {
  input: "not_test",
  unless_cond: "msg == 'test'",
  unless_proc: "true",
  else_proc: "false",
}
EvalHelperTest.new.hoge(hash) # => return true

require 'eval_helper'
class EvalHelperTest
  include EvalHelper

  def hoge(hash)
    msg = hash[:input]
    code = unless_code(hash[:unless_cond], hash[:unless_proc], hash[:else_proc])
    instance_eval code
  end
end

hash = {
  input: "test",
  unless_cond: "msg == 'test'",
  unless_proc: "true",
  else_proc: "false",
}
EvalHelperTest.new.hoge(hash) # => return false