Module: EvalHelper

Included in:
Object
Defined in:
lib/eval_helper.rb,
lib/eval_helper/if_code.rb,
lib/eval_helper/times_code.rb,
lib/eval_helper/unless_code.rb,
lib/eval_helper/each_do_code.rb,
lib/eval_helper/require_code.rb,
lib/eval_helper/if_code_after.rb,
lib/eval_helper/each_brace_code.rb,
lib/eval_helper/ternary_operator.rb,
lib/eval_helper/set_variable_code.rb,
lib/eval_helper/unless_code_after.rb,
lib/eval_helper/set_variables_code.rb,
lib/eval_helper/attr_init_class_code.rb,
lib/eval_helper/require_relative_code.rb,
lib/eval_helper/attr_accessor_init_code.rb,
lib/eval_helper/each_with_index_do_code.rb,
lib/eval_helper/each_with_index_brace_code.rb

Instance Method Summary collapse

Instance Method Details

#attr_accessor_init_code(attribute) ⇒ Object

create attr_accessor + initialize code, for eval

Examples

single case

class EvalHelperAttrAccessorInitTest
  include EvalHelper

  def hoge(args)
    attr_accessor_init_code(args)
  end
end

EvalHelperAttrAccessorInitTest.new.hoge('atr1')

result

attr_accessor :atr1

def initialize(atr1)
  @atr1 = atr1
end

multi case

class EvalHelperAttrAccessorInitTest
  include EvalHelper

  def hoge(args)
    attr_accessor_init_code(args)
  end
end

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

result

attr_accessor :atr1, :atr2

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



49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/eval_helper/attr_accessor_init_code.rb', line 49

def attr_accessor_init_code(attribute)
  return '' unless [String, Array].include? attribute.class
  atrs = []
  if attribute.is_a? String
    atrs << attribute
  elsif attribute.is_a? Array
    atrs = attribute
  end

  accessors = atrs.reduce([]) { |ret, v|ret << ":#{v}" }.join(', ')
  init_variables = atrs.reduce([]) { |ret, v|ret << "#{v}" }.join(', ')
  set_variables = atrs.reduce([]) { |ret, v|ret << "  @#{v} = #{v}" }.join("\n")
  ret_code = <<-EOS
attr_accessor #{accessors}

def initialize(#{init_variables})
#{set_variables}
end
  EOS
end

#attr_init_class_code(class_name, fields) ⇒ Object

create attr_accessor + initialize code, for eval

Examples

class EvalHelperAttrInitTest
  include EvalHelper

  def hoge(hash)
    attr_init_class_code(hash[:class_name], hash[:fields])
  end
end

hash = {
  class_name: "Hoge",
  fields: [:hoge1, :hoge2, :hoge3],
}
EvalHelperAttrInitTest.new.hoge(hash)

result

require 'attributes_initializable'

class Hoge
  include AttributesInitializable
  attr_accessor_init :hoge1, :hoge2, :hoge3
end



31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/eval_helper/attr_init_class_code.rb', line 31

def attr_init_class_code(class_name, fields)
  tmp_fields = fields.map { |v|":#{v}" }.join(', ')
  <<-EOS
require 'attributes_initializable'

class #{class_name}
include AttributesInitializable
attr_accessor_init #{tmp_fields}
end
  EOS
end

#each_brace_code(target, proc) ⇒ Object

create each brace single line code, for eval

Examples

class EvalHelperEachBraceTest
  include EvalHelper

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

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



22
23
24
 
# File 'lib/eval_helper/each_brace_code.rb', line 22

def each_brace_code(target, proc)
  "#{target}.each { |v|#{proc} }"
end

#each_do_code(target, proc) ⇒ Object

create each do code, for eval

Examples

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"



22
23
24
25
 
# File 'lib/eval_helper/each_do_code.rb', line 22

def each_do_code(target, proc)
  indented = proc.split("\n").reduce([]) { |ret, v|ret << "  #{v}" ; ret }.join("\n")
  "#{target}.each do |v|\n#{indented}\nend"
end

#each_with_index_brace_code(target, proc) ⇒ Object

create each with index brace single line code, for eval

Examples

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 { |v, i|puts "#{i}:#{v}" }'



22
23
24
 
# File 'lib/eval_helper/each_with_index_brace_code.rb', line 22

def each_with_index_brace_code(target, proc)
  "#{target}.each_with_index { |v, i|#{proc} }"
end

#each_with_index_do_code(target, proc) ⇒ Object

create each with index do single line code, for eval

Examples

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"



22
23
24
25
 
# File 'lib/eval_helper/each_with_index_do_code.rb', line 22

def each_with_index_do_code(target, proc)
  indented = proc.split("\n").reduce([]) { |ret, v|ret << "  #{v}" ; ret }.join("\n")
  "#{target}.each_with_index do |v, i|\n#{indented}\nend"
end

#if_code(condition, if_proc, else_proc) ⇒ Object

create if strings, for eval

Examples

if case

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

else case

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



48
49
50
51
52
53
54
55
56
 
# File 'lib/eval_helper/if_code.rb', line 48

def if_code(condition, if_proc, else_proc)
  <<-EOS
if #{condition}
#{if_proc}
else
#{else_proc}
end
  EOS
end

#if_code_after(condition, if_proc) ⇒ Object

create if strings, for eval

Examples

if case

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'

else case

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'



50
51
52
 
# File 'lib/eval_helper/if_code_after.rb', line 50

def if_code_after(condition, if_proc)
  "#{if_proc} if #{condition}"
end

#require_code(*args) ⇒ Object

create require strings, for eval

Examples

single require case

class EvalHelperRequireTest
  include EvalHelper

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

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

muiti require case

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"



34
35
36
37
 
# File 'lib/eval_helper/require_code.rb', line 34

def require_code(*args)
  args = args.is_a?(Array) ? args.flatten : [args]
  args.reduce([]) { |ret, v|ret << "require '#{v}'\n" }.join
end

#require_relative_code(*args) ⇒ Object

create require_relative strings, for eval

Examples

single require_relative case

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"

muiti require_relative case

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"



34
35
36
37
 
# File 'lib/eval_helper/require_relative_code.rb', line 34

def require_relative_code(*args)
  args = args.is_a?(Array) ? args.flatten : [args]
  args.reduce([]) { |ret, v|ret << "require_relative '#{v}'\n" }.join
end

#set_variable_code(name, value) ⇒ Object

create set variable logic strings, for eval

Examples

set string variable case

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

return

hoge = "hoge"

set numeric variable case

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

return

hoge_num = 1



48
49
50
 
# File 'lib/eval_helper/set_variable_code.rb', line 48

def set_variable_code(name, value)
  "#{name} = #{value}"
end

#set_variables_code(variables) ⇒ Object

create set variables logic strings, for eval

Examples

set string variables case

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)

return

name1 = "value1"
name2 = "value2"



35
36
37
38
39
40
41
42
43
44
 
# File 'lib/eval_helper/set_variables_code.rb', line 35

def set_variables_code(variables)
  fail TypeError, "invalid type #{variables.class}. you have to use Array" unless variables.is_a? Array
  variables.reduce([]) do |ret, variable|
    fail TypeError, "invalid type #{variable.class}. you have to use Hash" unless variable.is_a? Hash
    fail TypeError, 'invalid hash. you have to set Hash[:name]' if variable[:name].nil?
    fail TypeError, 'invalid hash. you have to set Hash[:value]' if variable[:value].nil?
    ret << "#{variable[:name]} = #{variable[:value]}"
    ret
  end.join("\n")
end

#ternary_operator(condition, true_case, false_case, ret = nil) ⇒ Object

create unless strings, for eval

Examples

true case

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'

false case

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'



60
61
62
63
 
# File 'lib/eval_helper/ternary_operator.rb', line 60

def ternary_operator(condition, true_case, false_case, ret = nil)
  ret = ret.nil? ? '' : "#{ret} = "
  "#{ret}#{condition} ? #{true_case} : #{false_case}"
end

#times_code(number, proc) ⇒ Object

create times logic strings, for eval

Examples

single_line_proc case

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

return

2.times { |i| puts "#{i}times" }

multi_line_proc case

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

return

3.times do |i|
  puts "#{i}times"
  puts "#{i*2}times"
end



51
52
53
54
55
56
57
58
59
 
# File 'lib/eval_helper/times_code.rb', line 51

def times_code(number, proc)
  return "#{number}.times { |i| #{proc} }" if proc.count('\n') == 0
  indented = proc.split('\n').reduce([]) { |ret, v|ret << "  #{v}" ; ret }.join("\n")
  <<-EOS
#{number}.times do |i|
#{indented}
end
  EOS
end

#unless_code(condition, unless_proc, else_proc) ⇒ Object

create unless strings, for eval

Examples

unless case

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

else case

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



48
49
50
51
52
53
54
55
56
 
# File 'lib/eval_helper/unless_code.rb', line 48

def unless_code(condition, unless_proc, else_proc)
  <<-EOS
unless #{condition}
#{unless_proc}
else
#{else_proc}
end
  EOS
end

#unless_code_after(condition, unless_proc) ⇒ Object

create unless strings, for eval

Examples

unless case

class EvalHelperTest
  include EvalHelper

  def hoge(hash)
    msg = hash[:input]
    code = unless_code_after(hash[:unless_cond], hash[:unless_proc])
    ret = 'dafault'
    instance_eval code
    ret
  end
end

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

else case

class EvalHelperTest
  include EvalHelper

  def hoge(hash)
    msg = hash[:input]
    code = unless_code_after(hash[:unless_cond], hash[:unless_proc])
    ret = 'ret = "true"'
    instance_eval code
    ret
  end
end

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



50
51
52
 
# File 'lib/eval_helper/unless_code_after.rb', line 50

def unless_code_after(condition, unless_proc)
  "#{unless_proc} unless #{condition}"
end