Class: RedParse::MethodNode

Inherits:

ValueNode

• Object
• Array
• Node
• ValueNode
• RedParse::MethodNode

Includes:

HasRescue

Defined in:

lib/redparse/node.rb

Constant Summary

Constants included from FlattenedIvars

FlattenedIvars::EXCLUDED_IVARS

Instance Attribute Summary

• #empty_else ⇒ Object readonly

  Returns the value of attribute empty_else.

• #empty_ensure ⇒ Object readonly

  Returns the value of attribute empty_ensure.

Attributes inherited from Node

#endline, #errors, #offset, #parent, #startline

Attributes included from Stackable::Meta

#boolean_identity_params, #identity_params

Class Method Summary

• .namelist ⇒ Object

Instance Method Summary

• #else_=(x) ⇒ Object
• #ensure_=(x) ⇒ Object

  def receiver= x self=x end.

• #image ⇒ Object
• #initialize(defword, header, maybe_eq_, semi_, body, rescues, else_, ensure_, endword_) ⇒ MethodNode constructor

  A new instance of MethodNode.

• #parsetree(o) ⇒ Object
• #to_lisp ⇒ Object
• #unparse(o = default_unparse_options) ⇒ Object

Methods included from HasRescue

#parsetree_and_rescues, #unparse_and_rescues

Methods inherited from ValueNode

#lvalue

Methods inherited from Node

#+, #+@, #==, [], #[]=, #add_parent_links!, #begin_parsetree, create, #data, #deep_copy, #delete_extraneous_ivars!, #delete_linenums!, #depthwalk, #depthwalk_nodes, #error?, #evalable_inspect, #fixup_multiple_assignments!, #fixup_rescue_assignments!, #initialize_ivars, inline_symbols, #inspect, #lhs_unparse, #linerange, #lvalue, #lvars_defined_in, #merge_replacement_session, #negate, #original_brackets_assign, param_names, #parsetrees, #pretty_print, #prohibit_fixup, #replace_ivars_and_self, #replace_value, #rescue_parsetree, #to_parsetree, #to_parsetree_and_warnings, #unary, #walk, #xform_tree!

Methods included from Stackable::Meta

#build_exemplars, #enumerate_exemplars, #identity_param

Methods included from FlattenedIvars

#flattened_ivars, #flattened_ivars_equal?

Methods included from Stackable

#identity_name

Constructor Details

#initialize(defword, header, maybe_eq_, semi_, body, rescues, else_, ensure_, endword_) ⇒ MethodNode

Returns a new instance of MethodNode.

# File 'lib/redparse/node.rb', line 4494

def initialize(defword,header,maybe_eq_,semi_,
               body,rescues,else_,ensure_,endword_)
  @offset=defword.offset
  @empty_else=@empty_ensure=nil
#        if DotCallNode===header
#          header=header.data[1]
#        end
  if CallSiteNode===header
    receiver=header.receiver
    args=header.args
    header=header.name
  end
  if MethNameToken===header
    header=header.ident 
  end
  unless String===header
    fail "unrecognized method header: #{header}"
  end
  if else_
    else_=else_.val  or @empty_else=true
  end
  if ensure_
    ensure_=ensure_.val or @empty_ensure=true
  end
  args.extend ListInNode if args
  rescues.extend ListInNode if rescues
  replace [receiver,header,args,body,rescues,else_,ensure_]
end

Instance Attribute Details

#empty_else ⇒ Object (readonly)

Returns the value of attribute empty_else.

# File 'lib/redparse/node.rb', line 4523

def empty_else
  @empty_else
end

#empty_ensure ⇒ Object (readonly)

Returns the value of attribute empty_ensure.

# File 'lib/redparse/node.rb', line 4523

def empty_ensure
  @empty_ensure
end

Class Method Details

.namelist ⇒ Object

# File 'lib/redparse/node.rb', line 4525

def self.namelist
  %w[receiver name args body rescues elses ensures]
end

Instance Method Details

#else_=(x) ⇒ Object

# File 'lib/redparse/node.rb', line 4541

def else_= x
  self[6]=x      
end

#ensure_=(x) ⇒ Object

def receiver= x

  self[0]=x      
end

def body= x
  self[3]=x      
end

# File 'lib/redparse/node.rb', line 4537

def ensure_= x
  self[5]=x      
end

#image ⇒ Object

# File 'lib/redparse/node.rb', line 4545

def image
  "(def #{receiver.image.+('.') if receiver}#{name})"
end

#parsetree(o) ⇒ Object

# File 'lib/redparse/node.rb', line 4573

def parsetree(o)
  name=name()
  name=name.chop if /^[!~]@$/===name
  name=name.to_sym

  result=[name, target=[:scope, [:block, ]] ]
  if receiver
    result.unshift :defs, receiver.rescue_parsetree(o)
  else
    result.unshift :defn
  end

  goodies= (body or !rescues.empty? or elses or ensures or @empty_ensure) # or args())

  if unamp=args() and unamp=unamp.last and UnOpNode===unamp and unamp.op=="&@"
    receiver and goodies=true
  else 
    unamp=false
  end

  if receiver and !goodies
    target.delete_at 1 #omit :block
  else
    target=target[1]
  end

  target.push args=[:args,]
  target.push unamp.parsetree(o) if unamp

  if args()
    initvals=[]
    args().each{|arg| 
        case arg
            when VarNode
              args.push arg.ident.to_sym
            when UnaryStarNode
              args.push "*#{arg.val.ident}".to_sym
            when UnOpNode
              nil
            when AssignNode
              initvals << arg.parsetree(o)
              initvals[-1][-1]=arg.right.rescue_parsetree(o) #ugly
              args.push arg[0].ident.to_sym
            else 
              fail "unsupported node type in method param list: #{arg}"
        end
    }
    unless initvals.empty?
      initvals.unshift(:block) 
      args << initvals
      #args[-2][0]==:block_arg and target.push args.delete_at(-2)
    end
  end
  target.push [:nil] if !goodies && !receiver

  #it would be better to use parsetree_and_rescues for the rest of this method,
  #just to be DRYer

  target.push ensuretarget=target=[:ensure, ] if ensures or @empty_ensure
  #simple dup won't work... won't copy extend'd modules
  body=Marshal.load(Marshal.dump(body())) if body()
  elses=elses()
  if rescues.empty?
    case body
    when SequenceNode; body << elses;elses=nil
    when nil; body=elses;elses=nil
    else nil
    end if elses
  else
    target.push target=[:rescue, ] 
    elses=elses()
  end
  if body
    if BeginNode===body||RescueOpNode===body and 
      body.rescues.empty? and !body.ensure and !body.empty_ensure and body.body and body.body.size>1
        wantblock=true
    end
    body=body.parsetree(o)
    if body.first==:block and rescues.empty? and not ensures||@empty_ensure
      if wantblock
        target.push body
      else
        body.shift 
        target.concat body
      end
    else
      #body=[:block, *body] if wantblock
      target.push body
    end
  end
  target.push linked_list(rescues.map{|rescue_| rescue_.parsetree(o) }) unless rescues.empty?
  target.push elses.parsetree(o) if elses
  ensuretarget.push ensures.parsetree(o) if ensures
  ensuretarget.push [:nil] if @empty_ensure

  return result
end

#to_lisp ⇒ Object

# File 'lib/redparse/node.rb', line 4568

def to_lisp
  "(imethod #{name} is\n#{body.to_lisp}\n)\n"
  #no receiver, args, rescues, else_ or ensure_...
end

#unparse(o = default_unparse_options) ⇒ Object

# File 'lib/redparse/node.rb', line 4549

def unparse o=default_unparse_options
  result=[
   "def ",receiver&&receiver.unparse(o)+'.',name,
     args && '('+args.map{|arg| arg.unparse o}.join(',')+')', unparse_nl(body||self,o)
  ]
  result<<unparse_and_rescues(o)
=begin
  body&&result+=body.unparse(o)

  result+=rescues.map{|resc| resc.unparse o}.to_s 
  result+="else #{else_.unparse o}\n"  if else_
  result+="else\n" if @empty_else
  result+="ensure #{ensure_.unparse o}\n"  if ensure_
  result+="ensure\n" if @empty_ensure
=end

  result<<unparse_nl(endline,o)+"end"
  result.join
end