module EvalHelper

Public Instance Methods

attr_accessor_init_code(attribute) click to toggle source

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
# 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([]) { |a, e|a << ":#{e}" }.join(', ')
    init_variables = atrs.reduce([]) { |a, e|a << "#{e}" }.join(', ')
    set_variables = atrs.reduce([]) { |a, e|a << "  @#{e} = #{e}" }.join("\n")
    ret_code = <<-EOS
attr_accessor #{accessors}

def initialize(#{init_variables})
#{set_variables}
end
    EOS
  end
attr_init_class_code(class_name, fields) click to toggle source

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
# 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) click to toggle source

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 }'
# 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) click to toggle source

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"
# File lib/eval_helper/each_do_code.rb, line 22
def each_do_code(target, proc)
  indented = proc.split("\n").reduce([]) { |a, e|a << "  #{e}"; a }.join("\n")
  "#{target}.each do |v|\n#{indented}\nend"
end
each_with_index_brace_code(target, proc) click to toggle source

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}" }'
# 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) click to toggle source

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"
# 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([]) { |a, e|a << "  #{e}"; a }.join("\n")
  "#{target}.each_with_index do |v, i|\n#{indented}\nend"
end
if_code(condition, if_proc, else_proc) click to toggle source

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
# 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) click to toggle source

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'
# 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) click to toggle source

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"
# File lib/eval_helper/require_code.rb, line 34
def require_code(*args)
  args = args.is_a?(Array) ? args.flatten : [args]
  args.reduce([]) { |a, e|a << "require '#{e}'\n" }.join
end
require_relative_code(*args) click to toggle source

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"
# 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([]) { |a, e|a << "require_relative '#{e}'\n" }.join
end
setting_variable_code(name, value) click to toggle source

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
# File lib/eval_helper/set_variable_code.rb, line 48
def setting_variable_code(name, value)
  "#{name} = #{value}"
end
setting_variables_code(variables) click to toggle source

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"
# File lib/eval_helper/set_variables_code.rb, line 35
def setting_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) click to toggle source

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'
# 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) click to toggle source

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
# 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([]) { |a, e|a << "  #{e}"; a }.join("\n")
    <<-EOS
#{number}.times do |i|
#{indented}
end
    EOS
  end
unless_code(condition, unless_proc, else_proc) click to toggle source

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
# 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) click to toggle source

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'
# File lib/eval_helper/unless_code_after.rb, line 50
def unless_code_after(condition, unless_proc)
  "#{unless_proc} unless #{condition}"
end