delorean_lang 0.5.1 → 0.5.2

data/lib/delorean/delorean.treetop

@@ -10,17 +10,28 @@ grammar Delorean
     /
     sp4 i:identifier sp? '=' sp? e:expression <Formula>
     /
+    n:class_name ':' sp? mod:(m:class_name_import_nested) <SubNodeNested> # FIXME: requires to be above SubNode statement, otherwise doesn't work
+    /
     n:class_name ':' sp? mod:(m:class_name '::')? p:class_name <SubNode>
     /
     n:class_name ':' <BaseNode>
     /
-    'import' sp n:class_name <Import>
+    'import' sp n:class_name_import <Import>
   end
 
   rule class_name
     [A-Z] [a-zA-Z0-9_]*
   end
 
+  rule class_name_import
+    [A-Z] [a-zA-Z0-9_]* ('::' [A-Z] [a-zA-Z0-9_]*)*
+  end
+
+  # FIXME: Hacky way to skip Module::Node cases, so only Module::NestedModule::Node will pass
+  rule class_name_import_nested
+    [A-Z] [a-zA-Z0-9_]* (('::' [A-Z] [a-zA-Z0-9_]*) 2..)
+  end
+
   rule expression
     'ERR(' sp? args:fn_args? sp? ')' <ErrorOp>
     /
@@ -119,6 +130,7 @@ grammar Delorean
     list_expr                                           /
     set_expr                                            /
     hash_expr                                           /
+    c:class_name_import <NodeAsValueNested>             / # FIXME: requires to be above NodeAsValue statement, otherwise doesn't work
     mod:(m:class_name '::')? c:class_name <NodeAsValue> /
     '(' sp? e:expression sp? ')'          <Expr>
   end

data/lib/delorean/engine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'delorean/const'
 require 'delorean/base'
 require 'set'
@@ -6,9 +8,9 @@ require 'pp'
 module Delorean
   class Engine
     attr_reader :last_node, :module_name, :line_no,
-    :comp_set, :pm, :m, :imports, :sset
+                :comp_set, :pm, :m, :imports, :sset
 
-    def initialize(module_name, sset=nil)
+    def initialize(module_name, sset = nil)
       # name of current module
       @module_name = module_name
       @sset = sset
@@ -16,9 +18,12 @@ module Delorean
     end
 
     def reset
-      @m, @pm = nil, nil
-      @last_node, @node_attrs = nil, {}
-      @line_no, @multi_no = 0, nil
+      @m = nil
+      @pm = nil
+      @last_node = nil
+      @node_attrs = {}
+      @line_no = 0
+      @multi_no = nil
 
       # set of comprehension vars
       @comp_set = Set.new
@@ -41,24 +46,24 @@ module Delorean
     end
 
     def parse_import(name)
-      err(ParseError, "No script set") unless sset
+      err(ParseError, 'No script set') unless sset
 
       err(ParseError, "Module #{name} importing itself") if
         name == module_name
 
       begin
         @imports[name] = sset.get_engine(name)
-      rescue => exc
+      rescue StandardError => exc
         err(ImportError, exc.to_s)
       end
 
-      @pm.const_set("#{MOD}#{name}", @imports[name].pm)
+      @pm.const_set("#{MOD}#{name.gsub('::', '__')}", @imports[name].pm)
     end
 
     def gen_import(name)
       @imports.merge!(@imports[name].imports)
 
-      @m.const_set("#{MOD}#{name}", @imports[name].m)
+      @m.const_set("#{MOD}#{name.gsub('::', '__')}", @imports[name].m)
     end
 
     def get_import_engine(name)
@@ -66,7 +71,7 @@ module Delorean
       @imports[name]
     end
 
-    def is_node_defined(name)
+    def node_defined?(name)
       @pm.constants.member? name.to_sym
     end
 
@@ -74,7 +79,7 @@ module Delorean
     # method about our expectation.  flag=true means that we make sure
     # that name is defined.  flag=false is the opposite.
     def parse_check_defined_node(name, flag)
-      isdef = is_node_defined(name)
+      isdef = node_defined?(name)
 
       if isdef != flag
         isdef ? err(RedefinedError, "#{name} already defined") :
@@ -83,7 +88,7 @@ module Delorean
     end
 
     def super_name(pname, mname)
-      mname ? "#{MOD}#{mname}::#{pname}" : pname
+      mname ? "#{MOD}#{mname.gsub('::', '__')}::#{pname}" : pname
     end
 
     def parse_check_defined_mod_node(pname, mname)
@@ -91,13 +96,15 @@ module Delorean
       engine.parse_check_defined_node(pname, true)
     end
 
-    def parse_define_node(name, pname, mname=nil)
+    def parse_define_node(name, pname, mname = nil)
       parse_check_defined_node(name, false)
       parse_check_defined_mod_node(pname, mname) if pname
 
       sname = pname ? super_name(pname, mname) : 'Object'
 
-      @pm.module_eval("class #{name} < #{sname}; end")
+      @pm.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        class #{name} < #{sname}; end
+      RUBY
 
       # latest defined node
       @last_node = name
@@ -125,20 +132,21 @@ module Delorean
 
     # Parse-time check to see if attr is available on current node.
     def parse_call_last_node_attr(attr_name)
-      err(ParseError, "Not inside a node") unless @last_node
+      err(ParseError, 'Not inside a node') unless @last_node
       parse_call_attr(@last_node, attr_name)
     end
 
     def parse_define_var(var_name)
-      err(RedefinedError,
-          "List comprehension can't redefine variable '#{var_name}'") if
-        comp_set.member? var_name
+      if comp_set.member? var_name
+        err(RedefinedError,
+            "List comprehension can't redefine variable '#{var_name}'")
+      end
 
       comp_set.add var_name
     end
 
     def parse_undef_var(var_name)
-      err(ParseError, "internal error") unless comp_set.member? var_name
+      err(ParseError, 'internal error') unless comp_set.member? var_name
       comp_set.delete var_name
     end
 
@@ -152,10 +160,10 @@ module Delorean
 
       @node_attrs[@last_node] << name
 
-      checks = spec.map { |a|
+      checks = spec.map do |a|
         n = a.index('.') ? a : "#{@last_node}.#{a}"
         "_x.member?('#{n}') ? raise('#{n}') : #{a}#{POST}(_x + ['#{n}'])"
-      }.join(';')
+      end.join(';')
 
       code =
         "class #{@last_node}; def self.#{name}#{POST}(_x); #{checks}; end; end"
@@ -195,7 +203,7 @@ module Delorean
       raise exc.new(msg, @module_name, curr_line)
     end
 
-    def parse_check_call_fn(fn, argcount, class_name=nil)
+    def parse_check_call_fn(fn, argcount, class_name = nil)
       klass = case class_name
               when nil
                 @m::BaseClass
@@ -234,7 +242,7 @@ module Delorean
         # generate ruby code
         gen = t.rewrite(self)
       rescue RuntimeError => exc
-        err(ParseError, "codegen error: " + exc.message)
+        err(ParseError, 'codegen error: ' + exc.message)
       end
 
       # puts gen
@@ -242,9 +250,9 @@ module Delorean
       begin
         # evaluate generated code in @m
         @m.module_eval(gen, "#{MOD}#{module_name}", curr_line)
-      rescue => exc
+      rescue StandardError => exc
         # bad ruby code generated, shoudn't happen
-        err(ParseError, "codegen error: " + exc.message)
+        err(ParseError, 'codegen error: ' + exc.message)
       end
     end
 
@@ -253,20 +261,22 @@ module Delorean
 
       # @m module is used at runtime for code evaluation.  @pm module
       # is only used during parsing to check for errors.
-      @m, @pm = BaseModule.clone, Module.new
+      @m = BaseModule.clone
+      @pm = Module.new
 
-      multi_line, @multi_no = nil, nil
+      multi_line = nil
+      @multi_no = nil
 
       source.each_line do |line|
         @line_no += 1
 
         # skip comments
-        next if line.match(/^\s*\#/)
+        next if line =~ /^\s*\#/
 
         # remove trailing blanks
         line.rstrip!
 
-        next if line.length == 0
+        next if line.empty?
 
         if multi_line
           # if line starts with >4 spaces, assume it's a multline
@@ -276,17 +286,18 @@ module Delorean
             next
           else
             t = parser.parse(multi_line)
-            err(ParseError, "syntax error") unless t
+            err(ParseError, 'syntax error') unless t
 
             generate(t)
-            multi_line, @multi_no = nil, nil
+            multi_line = nil
+            @multi_no = nil
           end
         end
 
         t = parser.parse(line)
 
         if !t
-          err(ParseError, "syntax error") unless line =~ /^\s+/
+          err(ParseError, 'syntax error') unless line =~ /^\s+/
 
           multi_line = line
           @multi_no = @line_no
@@ -297,7 +308,7 @@ module Delorean
 
       if multi_line
         t = parser.parse(multi_line)
-        err(ParseError, "syntax error") unless t
+        err(ParseError, 'syntax error') unless t
         generate(t)
       end
     end
@@ -313,14 +324,14 @@ module Delorean
 
     # enumerate qualified list of all attrs
     def enumerate_attrs
-      @node_attrs.keys.each_with_object({}) { |node, h|
+      @node_attrs.keys.each_with_object({}) do |node, h|
         h[node] = enumerate_attrs_by_node(node)
-      }
+      end
     end
 
     # enumerate qualified list of attrs by node
     def enumerate_attrs_by_node(node)
-      raise "bad node" unless node
+      raise 'bad node' unless node
 
       begin
         klass = node.is_a?(String) ? @m.module_eval(node) : node
@@ -331,11 +342,11 @@ module Delorean
 
       raise "bad node class #{klass}" unless klass.is_a?(Class)
 
-      klass.methods.map(&:to_s).select { |x|
+      klass.methods.map(&:to_s).select do |x|
         x.end_with?(POST)
-      }.map { |x|
+      end.map do |x|
         x.sub(/#{POST}$/, '')
-      }
+      end
     end
 
     # enumerate all params
@@ -346,15 +357,15 @@ module Delorean
     # enumerate params by a single node
     def enumerate_params_by_node(node)
       attrs = enumerate_attrs_by_node(node)
-      Set.new( attrs.select {|a| @param_set.include?(a)} )
+      Set.new(attrs.select { |a| @param_set.include?(a) })
     end
 
     ######################################################################
     # Runtime
     ######################################################################
 
-    def evaluate(node, attrs, params={})
-      raise "bad params" unless params.is_a?(Hash)
+    def evaluate(node, attrs, params = {})
+      raise 'bad params' unless params.is_a?(Hash)
 
       if node.is_a?(Class)
         klass = node
@@ -373,29 +384,29 @@ module Delorean
       type_arr = attrs.is_a?(Array)
       attrs = [attrs] unless type_arr
 
-      res = attrs.map { |attr|
+      res = attrs.map do |attr|
         raise "bad attribute '#{attr}'" unless attr =~ /^[a-z][A-Za-z0-9_]*$/
+
         klass.send("#{attr}#{POST}".to_sym, params)
-      }
+      end
       type_arr ? res : res[0]
     end
 
-    def eval_to_hash(node, attrs, params={})
+    def eval_to_hash(node, attrs, params = {})
       res = evaluate(node, attrs, params)
       Hash[* attrs.zip(res).flatten(1)]
     end
 
     def self.grok_runtime_exception(exc)
       # parse out the delorean-related backtrace records
-      bt = exc.backtrace.map{ |x|
-        x.match(/^#{MOD}(.+?):(\d+)(|:in `(.+)')$/);
+      bt = exc.backtrace.map do |x|
+        x =~ /^#{MOD}(.+?):(\d+)(|:in `(.+)')$/
         $1 && [$1, $2.to_i, $4.sub(/#{POST}$/, '')]
-      }.reject(&:!)
+      end.reject(&:!)
 
-      {"error" => exc.message, "backtrace" => bt}
+      { 'error' => exc.message, 'backtrace' => bt }
     end
 
     ######################################################################
-
   end
 end

data/lib/delorean/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Delorean
   ######################################################################
   # Parse Errors
@@ -48,5 +50,4 @@ module Delorean
 
   class InvalidIndex < StandardError
   end
-
 end

data/lib/delorean/model.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'delorean/const'
 
 module Delorean
@@ -7,23 +9,24 @@ module Delorean
     end
 
     module ClassMethods
-      def delorean_fn(name, options = {}, &block)
+      def delorean_fn(name, options = {})
         define_singleton_method(name) do |*args|
-          block.call(*args)
+          yield(*args)
         end
 
         sig = options[:sig]
 
-        raise "no signature" unless sig
+        raise 'no signature' unless sig
 
         if sig
           sig = [sig, sig] if sig.is_a? Integer
-          raise "Bad signature" unless (sig.is_a? Array and sig.length==2)
-          self.const_set(name.to_s.upcase+Delorean::SIG, sig)
+          raise 'Bad signature' unless sig.is_a?(Array) && (sig.length == 2)
+
+          const_set(name.to_s.upcase + Delorean::SIG, sig)
         end
       end
 
-      # FIXME IDEA: we just make :cache an argument to delorean_fn.
+      # FIXME: IDEA: we just make :cache an argument to delorean_fn.
       # That way, we don't need the cached_ flavors.  It'll make all
       # this code a lot simpler.  We should also just add the :private
       # mechanism here.
@@ -33,11 +36,11 @@ module Delorean
       # values are ActiveRecord objects.  Query results can be very
       # large lists which we count as one item in the cache.  Caching
       # mechanism will result in large processes.
-      def cached_delorean_fn(name, options = {}, &block)
+      def cached_delorean_fn(name, options = {})
         delorean_fn(name, options) do |*args|
           delorean_cache_adapter = ::Delorean::Cache.adapter
           # Check if caching should be performed
-          next block.call(*args) unless delorean_cache_adapter.cache_item?(
+          next yield(*args) unless delorean_cache_adapter.cache_item?(
             klass: self, method_name: name, args: args
           )
 
@@ -50,7 +53,7 @@ module Delorean
 
           next cached_item if cached_item != :NF
 
-          res = block.call(*args)
+          res = yield(*args)
 
           delorean_cache_adapter.cache_item(
             klass: self, cache_key: cache_key, item: res

data/lib/delorean/nodes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Delorean
   class SNode < Treetop::Runtime::SyntaxNode
   end
@@ -6,6 +8,7 @@ module Delorean
     def check(context, *a)
       f.check(context, *a)
     end
+
     def rewrite(context)
       f.rewrite(context)
     end
@@ -24,11 +27,12 @@ module Delorean
       # in _e.  If not, to compute it we check for the value in _e
       # (i.e. check for aname).  Otherwise, we use the default value
       # if any.
-      aname, cname = i.text_value, context.last_node
+      aname = i.text_value
+      cname = context.last_node
       not_found = defined?(e) ? e.rewrite(context) :
         "raise UndefinedParamError, 'undefined parameter #{aname}'"
 
-<<eos
+      <<eos
       class #{cname}
         def self.#{aname}#{POST}(_e)
             _e[self.name+'.#{aname}'] ||= _e.fetch('#{aname}') { #{not_found} }
@@ -58,7 +62,7 @@ eos
 
     def rewrite(context)
       context.gen_import(n.text_value)
-      ""
+      ''
     end
   end
 
@@ -71,13 +75,13 @@ eos
     def def_class(context, base_name)
       # Nodes are simply translated to classes.  Define our own
       # self.name() since it's extremely slow in MRI 2.0.
-      "class #{n.text_value} < #{base_name}; " +
-        "def self.module_name; '#{context.module_name}'; end;" +
+      "class #{n.text_value} < #{base_name}; " \
+        "def self.module_name; '#{context.module_name}'; end;" \
         "def self.name; '#{n.text_value}'; end; end"
     end
 
     def rewrite(context)
-      def_class(context, "BaseClass")
+      def_class(context, 'BaseClass')
     end
   end
 
@@ -96,6 +100,27 @@ eos
     end
   end
 
+  class SubNodeNested < BaseNode
+    def check(context, *)
+      module_names = mod.m.text_value.split('::')
+      node_name = module_names.pop
+      mname = module_names.join('::') if module_names.any?
+
+      context.parse_define_node(n.text_value, node_name, mname)
+    end
+
+    def rewrite(context)
+      module_names = mod.m.text_value.split('::')
+      node_name = module_names.pop
+      mname = module_names.join('::') if module_names.any?
+
+      sname = context.super_name(node_name, mname)
+
+      # A sub-node (derived node) is just a subclass.
+      def_class(context, sname)
+    end
+  end
+
   class Formula < SNode
     def check(context, *)
       context.parse_define_attr(i.text_value, e.check(context))
@@ -106,12 +131,12 @@ eos
       debug = Debug.debug_set.member?(dname)
 
       # an attr is defined as a class function on the node class.
-      "class #{context.last_node}; " +
+      "class #{context.last_node}; " \
         "def self.#{i.text_value}#{POST}(_e); " +
-        (debug ? "_debug =" : '') +
+        (debug ? '_debug =' : '') +
         "_e[self.name+'.#{i.text_value}'] ||= #{e.rewrite(context)};" +
         (debug ? 'Delorean::Debug.log(_debug); _debug;' : '') +
-        "end; end;"
+        'end; end;'
     end
   end
 
@@ -133,7 +158,7 @@ eos
     end
 
     def +(other)
-      self.to_s + other
+      to_s + other
     end
 
     def to_s
@@ -168,6 +193,37 @@ eos
     end
   end
 
+  class NodeAsValueNested < SNode
+    def check(context, *)
+      module_names = c.text_value.split('::')
+      node_name = module_names.pop
+      mname = module_names.join('::') if module_names.any?
+
+      begin
+        context.parse_check_defined_mod_node(node_name, mname)
+      rescue UndefinedError, ParseError
+        # Node is a non-Delorean ruby class
+        context.parse_class(text_value)
+      end
+      []
+    end
+
+    def rewrite(context)
+      module_names = c.text_value.split('::')
+      node_name = module_names.pop
+      mname = module_names.join('::') if module_names.any?
+
+      begin
+        context.parse_check_defined_mod_node(node_name, mname)
+        context.super_name(node_name, mname)
+      rescue UndefinedError, ParseError
+        # FIXME: wrap the class name so Call will be able to tell it
+        # apart from a regular value.
+        ClassText.new(text_value)
+      end
+    end
+  end
+
   # unary operator
   class UnOp < SNode
     def check(context, *)
@@ -181,7 +237,8 @@ eos
 
   class BinOp < SNode
     def check(context, *)
-      vc, ec = v.check(context), e.check(context)
+      vc = v.check(context)
+      ec = e.check(context)
       # returns list of attrs used in RHS and LHS
       ec + vc
     end
@@ -198,11 +255,13 @@ eos
   # hacky, for backwards compatibility
   class ErrorOp < SNode
     def check(context, *)
-      args.text_value=='' ? [] : args.check(context)
+      args.text_value == '' ? [] : args.check(context)
     end
 
     def rewrite(context, *)
-      args.text_value!='' ? "_err(#{args.rewrite(context)})" : "binding.pry; 0"
+      args.text_value != '' ?
+        "_err(#{args.rewrite(context)})" :
+        'binding.pry; 0'
     end
   end
 
@@ -217,41 +276,41 @@ eos
   end
 
   class Literal < SNode
-    def check(context, *)
+    def check(_context, *)
       []
     end
 
     # Delorean literals have same syntax as Ruby
-    def rewrite(context)
+    def rewrite(_context)
       text_value
     end
   end
 
   # _ is self -- a naive implementation of "self" for now.
   class Self < SNode
-    def check(context, *)
+    def check(_context, *)
       []
     end
 
-    def rewrite(context)
-      "_sanitize_hash(_e)"
+    def rewrite(_context)
+      '_sanitize_hash(_e)'
     end
   end
 
   class Sup < SNode
-    def check(context, *)
+    def check(_context, *)
       []
     end
 
-    def rewrite(context)
-      "superclass"
+    def rewrite(_context)
+      'superclass'
     end
   end
 
   class IString < Literal
-    def rewrite(context)
+    def rewrite(_context)
       # FIXME: hacky to just fail
-      raise "String interpolation not supported" if text_value =~ /\#\{.*\}/
+      raise 'String interpolation not supported' if text_value =~ /\#\{.*\}/
 
       # FIXME: syntax check?
       text_value
@@ -259,7 +318,7 @@ eos
   end
 
   class DString < Literal
-    def rewrite(context)
+    def rewrite(_context)
       # remove the quotes and requote.  We don't want the likes of #{}
       # evals to just pass through.
       text_value[1..-2].inspect
@@ -277,7 +336,7 @@ eos
       # class method calls.  POST is used in mangling the attr names.
       # _e is the environment.  Comprehension vars (in comp_set) are
       # not passed the env arg.
-      arg = context.comp_set.member?(text_value) ? "" : '(_e)'
+      arg = context.comp_set.member?(text_value) ? '' : '(_e)'
       text_value + POST + arg
     end
   end
@@ -315,11 +374,11 @@ eos
   end
 
   class GetAttr < SNode
-    def check(context, *)
+    def check(_context, *)
       []
     end
 
-    def rewrite(context, vcode)
+    def rewrite(_context, vcode)
       attr = i.text_value
       attr = "'#{attr}'" unless attr =~ /\A[0-9]+\z/
       "_get_attr(#{vcode}, #{attr}, _e)"
@@ -333,9 +392,11 @@ eos
 
     def rewrite(context, vcode)
       if al.text_value.empty?
-        args_str, arg_count = "", 0
+        args_str = ''
+        arg_count = 0
       else
-        args_str, arg_count = al.rewrite(context), al.arg_count
+        args_str = al.rewrite(context)
+        arg_count = al.arg_count
       end
 
       if vcode.is_a?(ClassText)
@@ -356,7 +417,7 @@ eos
 
     def rewrite(context, node_name)
       var = "_h#{context.hcount}"
-      res = al.text_value.empty? ? "" : al.rewrite(context, var)
+      res = al.text_value.empty? ? '' : al.rewrite(context, var)
       "(#{var}={}; #{res}; _node_call(#{node_name}, _e, #{var}))"
     end
   end
@@ -375,7 +436,7 @@ eos
       # element since it'll be "".
       attrs.shift
 
-      attrs.inject(v.rewrite(context)) {|x, y| "_get_attr(#{x}, '#{y}', _e)"}
+      attrs.inject(v.rewrite(context)) { |x, y| "_get_attr(#{x}, '#{y}', _e)" }
     end
   end
 
@@ -389,7 +450,7 @@ eos
     end
 
     def rewrite(context)
-      rest = ", " + args_rest.args.rewrite(context) if
+      rest = ', ' + args_rest.args.rewrite(context) if
         defined?(args_rest.args) && !args_rest.args.text_value.empty?
 
       [arg0.rewrite(context), rest].compact.sum
@@ -403,8 +464,9 @@ eos
 
   class IfElse < SNode
     def check(context, *)
-      vc, e1c, e2c =
-        v.check(context), e1.check(context), e2.check(context)
+      vc = v.check(context)
+      e1c = e1.check(context)
+      e2c = e2.check(context)
       vc + e1c + e2c
     end
 
@@ -420,7 +482,7 @@ eos
     end
 
     def rewrite(context)
-      "[" + (defined?(args) ? args.rewrite(context) : "") + "]"
+      '[' + (defined?(args) ? args.rewrite(context) : '') + ']'
     end
   end
 
@@ -434,7 +496,7 @@ eos
     def rewrite(context)
       arg0.rewrite(context) +
         (defined?(args_rest.args) && !args_rest.args.text_value.empty? ?
-         ", " + args_rest.args.rewrite(context) : "")
+         ', ' + args_rest.args.rewrite(context) : '')
     end
   end
 
@@ -442,19 +504,18 @@ eos
     def check(context, *)
       unpack_vars = args.check(context)
       e1c = e1.check(context)
-      unpack_vars.each {|vname| context.parse_define_var(vname)}
+      unpack_vars.each { |vname| context.parse_define_var(vname) }
 
       # need to check e2/e3 in a context where the comprehension var
       # is defined.
       e2c = e2.check(context)
       e3c = defined?(ifexp.e3) ? ifexp.e3.check(context) : []
 
-      unpack_vars.each {
-        |vname|
+      unpack_vars.each do |vname|
         context.parse_undef_var(vname)
         e2c.delete(vname)
         e3c.delete(vname)
-      }
+      end
 
       e1c + e2c + e3c
     end
@@ -462,13 +523,13 @@ eos
     def rewrite(context)
       res = ["(#{e1.rewrite(context)})"]
       unpack_vars = args.check(context)
-      unpack_vars.each {|vname| context.parse_define_var(vname)}
+      unpack_vars.each { |vname| context.parse_define_var(vname) }
       args_str = args.rewrite(context)
 
       res << ".select{|#{args_str}|(#{ifexp.e3.rewrite(context)})}" if
         defined?(ifexp.e3)
       res << ".map{|#{args_str}| (#{e2.rewrite(context)}) }"
-      unpack_vars.each {|vname| context.parse_undef_var(vname)}
+      unpack_vars.each { |vname| context.parse_undef_var(vname) }
       res.sum
     end
   end
@@ -492,7 +553,7 @@ eos
     def check(context, *)
       unpack_vars = args.check(context)
       e1c = e1.check(context)
-      unpack_vars.each {|vname| context.parse_define_var(vname)}
+      unpack_vars.each { |vname| context.parse_define_var(vname) }
 
       # need to check el/er/ei in a context where the comprehension var
       # is defined.
@@ -500,20 +561,19 @@ eos
       erc = er.check(context)
       eic = defined?(ifexp.ei) ? ifexp.ei.check(context) : []
 
-      unpack_vars.each {
-        |vname|
+      unpack_vars.each do |vname|
         context.parse_undef_var(vname)
         elc.delete(vname)
         erc.delete(vname)
         eic.delete(vname)
-      }
+      end
       e1c + elc + erc + eic
     end
 
     def rewrite(context)
       res = ["(#{e1.rewrite(context)})"]
       unpack_vars = args.check(context)
-      unpack_vars.each {|vname| context.parse_define_var(vname)}
+      unpack_vars.each { |vname| context.parse_define_var(vname) }
       args_str = args.rewrite(context)
 
       hid = @@comp_count += 1
@@ -523,10 +583,10 @@ eos
 
       unpack_str = unpack_vars.count > 1 ? "(#{args_str})" : args_str
 
-      res << ".each_with_object({}){|#{unpack_str}, _h#{hid}| " +
-        "_h#{hid}[#{el.rewrite(context)}]=(#{er.rewrite(context)})}"
+      res << ".each_with_object({}){|#{unpack_str}, _h#{hid}| " \
+             "_h#{hid}[#{el.rewrite(context)}]=(#{er.rewrite(context)})}"
 
-      unpack_vars.each {|vname| context.parse_undef_var(vname)}
+      unpack_vars.each { |vname| context.parse_undef_var(vname) }
       res.sum
     end
   end
@@ -537,7 +597,8 @@ eos
     end
 
     def rewrite(context)
-      return "{}" unless defined?(args)
+      return '{}' unless defined?(args)
+
       var = "_h#{context.hcount}"
       "(#{var}={}; " + args.rewrite(context, var) + "; #{var})"
     end
@@ -545,14 +606,15 @@ eos
 
   class KwArgs < SNode
     def check(context, *)
-      [arg0.check(context),
-       (ifexp.e3.check(context) if defined?(ifexp.e3)),
-       (args_rest.al.check(context) if
-         defined?(args_rest.al) && !args_rest.al.empty?)
+      [
+        arg0.check(context),
+        (ifexp.e3.check(context) if defined?(ifexp.e3)),
+        (args_rest.al.check(context) if
+          defined?(args_rest.al) && !args_rest.al.empty?)
       ].compact.sum
     end
 
-    def rewrite(context, var, i=0)
+    def rewrite(context, var, i = 0)
       arg0_rw = arg0.rewrite(context)
 
       if defined?(splat)
@@ -564,7 +626,7 @@ eos
       end
 
       res += " if (#{ifexp.e3.rewrite(context)})" if defined?(ifexp.e3)
-      res += ";"
+      res += ';'
       res += args_rest.al.rewrite(context, var, i) if
         defined?(args_rest.al) && !args_rest.al.text_value.empty?
       res
@@ -573,22 +635,23 @@ eos
 
   class HashArgs < SNode
     def check(context, *)
-      [e0.check(context),
-       (e1.check(context) unless defined?(splat)),
-       (ifexp.e3.check(context) if defined?(ifexp.e3)),
-       (args_rest.al.check(context) if
-         defined?(args_rest.al) && !args_rest.al.empty?),
+      [
+        e0.check(context),
+        (e1.check(context) unless defined?(splat)),
+        (ifexp.e3.check(context) if defined?(ifexp.e3)),
+        (args_rest.al.check(context) if
+          defined?(args_rest.al) && !args_rest.al.empty?),
       ].compact.sum
     end
 
     def rewrite(context, var)
       res = if defined?(splat)
-        "#{var}.merge!(#{e0.rewrite(context)})"
-      else
-        "#{var}[#{e0.rewrite(context)}]=(#{e1.rewrite(context)})"
-      end
+              "#{var}.merge!(#{e0.rewrite(context)})"
+            else
+              "#{var}[#{e0.rewrite(context)}]=(#{e1.rewrite(context)})"
+            end
       res += " if (#{ifexp.e3.rewrite(context)})" if defined?(ifexp.e3)
-      res += ";"
+      res += ';'
       res += args_rest.al.rewrite(context, var) if
         defined?(args_rest.al) && !args_rest.al.text_value.empty?
       res