Class: Nydp::Evaluator

Inherits:
Object show all
Defined in:
lib/nydp/runner.rb

Direct Known Subclasses

Runner

Defined Under Namespace

Classes: CompiledExpression

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(ns, name) ⇒ Evaluator

Returns a new instance of Evaluator.



74
75
76
77
78
 
# File 'lib/nydp/runner.rb', line 74

def initialize ns, name
  @name = name
  @ns   = ns
  @rubydir = FileUtils.mkdir_p "rubycode"
end

Instance Attribute Details

#name ⇒ Object

Returns the value of attribute name.



72
73
74
 
# File 'lib/nydp/runner.rb', line 72

def name
  @name
end

#ns ⇒ Object

Returns the value of attribute ns.



72
73
74
 
# File 'lib/nydp/runner.rb', line 72

def ns
  @ns
end

Class Method Details

.mk_manifest(name, class_list) ⇒ Object 



88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
 
# File 'lib/nydp/runner.rb', line 88

def self.mk_manifest name, class_list
  class_expr = <<KLA
#{class_list.map {|k| "require '#{k}'" }.join("\n")}

class #{name}
  def self.build ns
#{class_list.map {|k| "#{k}.new(ns).call" }.join("\n    ")}
  end
end
KLA
  File.open("rubycode/#{name}.rb", "w") { |f|
    fullpath = File.expand_path("rubycode/#{name}.rb")
    Nydp.logger.info "writing #{fullpath}" if Nydp.logger
    f.write class_expr
  }
end

Instance Method Details

#compile_expr(expr) ⇒ Object 



80
81
82
83
84
85
86
 
# File 'lib/nydp/runner.rb', line 80

def compile_expr expr
  begin
    Compiler.compile(expr, nil, ns)
  rescue StandardError => e
    raise Nydp::Error, "failed to compile #{expr._nydp_inspect}"
  end
end

#eval_compiled(compiled_expr, precompiled, src, manifest) ⇒ Object 



162
163
164
165
166
167
168
169
170
171
172
173
174
175
 
# File 'lib/nydp/runner.rb', line 162

def eval_compiled compiled_expr, precompiled, src, manifest
  return nil unless precompiled

  digest  = Digest::SHA256.hexdigest(precompiled.inspect)
  cname   = "#{GENERATED_CLASS_PREFIX}_#{digest.upcase}"
  kla     = mk_ruby_class src, precompiled, compiled_expr, cname

  manifest << cname

  kla.new(ns).call

rescue Exception => e
  raise Nydp::Error, "failed to eval #{compiled_expr._nydp_inspect} from src #{src._nydp_inspect}"
end

#evaluate(expr, manifest = []) ⇒ Object 



177
178
179
180
181
 
# File 'lib/nydp/runner.rb', line 177

def evaluate expr, manifest=[]
  precompiled = ns.apply :"pre-compile-new-expression", expr
  compiled    = compile_expr precompiled # TODO : we don't need this step if the class already exists! Do it later only when we need it
  eval_compiled compiled, precompiled, expr, manifest
end

#mk_ruby_class(src, precompiled, compiled_expr, cname) ⇒ Object 



148
149
150
151
152
153
154
155
156
157
158
159
160
 
# File 'lib/nydp/runner.rb', line 148

def mk_ruby_class src, precompiled, compiled_expr, cname
  begin
    require cname
    self.class.const_get(cname)

  rescue LoadError => e
    # compiled_expr    = compile_expr precompiled # TODO : delete line in #evaluate and uncomment this one
    fname = "rubycode/#{cname}.rb"
    txt   = mk_ruby_source src, precompiled, compiled_expr, cname

    eval(txt, nil, fname) || raise("failed to generate class #{cname} from src #{src}")
  end
end

#mk_ruby_source(src, precompiled, compiled_expr, cname) ⇒ Object 



116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/nydp/runner.rb', line 116

def mk_ruby_source src, precompiled, compiled_expr, cname
  srcs       = []
  ruby_expr  = compiled_expr.compile_to_ruby "    ", srcs
  six        = 0
  srcs       = srcs.map { |s|
    s = "  @@src_#{six} = #{s.inspect}"
    six += 1
    s
  }
  class_expr = "class #{cname} < Nydp::Runner::CompiledExpression

#{srcs.join("\n")}

  def src
#{src.inspect.inspect}
  end

  def precompiled
#{precompiled.inspect.inspect}
  end

  def call
#{ruby_expr}
  end
end

#{cname}
"
  File.open("rubycode/#{cname}.rb", "w") { |f| f.write class_expr }
  class_expr
end