Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.jruby.ext.tracepoint;
  
  import java.util.Arrays;
  import java.util.EnumSet;
  import org.jruby.Ruby;
 
 public class TracePoint extends RubyObject {
     public static void createTracePointClass(Ruby runtime) {
         RubyClass tracePoint = runtime.defineClass("TracePoint"runtime.getObject(), new ObjectAllocator() {
             @Override
             public IRubyObject allocate(Ruby runtimeRubyClass klazz) {
                 return new TracePoint(runtimeklazz);
             }
         });
         
         tracePoint.defineAnnotatedMethods(TracePoint.class);
     }
     
     public TracePoint(Ruby runtimeRubyClass klass) {
         super(runtimeklass);
         
         this. = "";
         this. = "";
         this. = -1;
         this. = "";
         this. = runtime.getNil();
         this. = runtime.getNil();
         this. = runtime.getNil();
     }
     
     @JRubyMethod(rest = true)
     public IRubyObject initialize(ThreadContext contextIRubyObject[] _eventsfinal Block block) {
         final Ruby runtime = context.runtime;
         
         if (!block.isGiven()) throw runtime.newThreadError("must be called with a block");
         
         RubyEvent[] events = new RubyEvent[_events.length];
         for (int i = 0; i < _events.lengthi++) {
             IRubyObject _event = _events[i];
             if (_event instanceof RubySymbol || _event instanceof RubyString) {
                 String eventName = _event.asJavaString();
                 RubyEvent event = RubyEvent.valueOf(eventName);
                 
                 if (event == nullthrow runtime.newArgumentError("unknown event: " + eventName);
                 
                 events[i] = event;
             }
         }
         
         EnumSet<RubyEvent_eventSet;
         if (events.length > 0) {
             _eventSet = EnumSet.copyOf(Arrays.asList(events));
         } else {
             _eventSet = EnumSet.allOf(RubyEvent.class);
         }
         
         final EnumSet<RubyEventeventSet = _eventSet;
          = new EventHook() {
             @Override
             public synchronized void eventHandler(ThreadContext contextString eventNameString fileint lineString nameIRubyObject type) {
                 if (! || context.isWithinTrace()) return;
                 
                  = true;
                 try {
                     if (file == nullfile = "(ruby)";
                     if (type == nulltype = context.runtime.getFalse();
 
                     RubyBinding binding = RubyBinding.newBinding(context.runtimecontext.currentBinding());
 
                     context.preTrace();
                     
                     // FIXME: get return value
                     update(eventNamefilelinenametypecontext.getErrorInfo(), context.nilbinding);
                 
                     block.yieldSpecific(contextTracePoint.this);
                 } finally {
                     update(nullnulllinenullcontext.nilcontext.nilcontext.nilcontext.nil);
                     context.postTrace();
                      = false;
                 }
             }
 
             @Override
             public boolean isInterestedInEvent(RubyEvent event) {
                 return eventSet.contains(event);
             }
        };
                
        return context.nil;
    }
    
    public IRubyObject binding(ThreadContext context) {
        checkInside(context);
        
        return context.nil;
    }
    
    public IRubyObject defined_class(ThreadContext context) {
        checkInside(context);
        
        return ;
    }
    
    public IRubyObject disable(ThreadContext contextBlock block) {
        return doToggle(contextblockfalse);
    }
    
    public IRubyObject enable(ThreadContext contextBlock block) {
        return doToggle(contextblocktrue);
    }
    
    @JRubyMethod(name = "enabled?")
    public IRubyObject enabled_p(ThreadContext context) {
        return context.runtime.newBoolean();
    }
    
    public IRubyObject event(ThreadContext context) {
        checkInside(context);
        
        return  == null ? context.nil : context.runtime.newSymbol();
    }
    
    public IRubyObject inspect(ThreadContext context) {
        if () {
            // TODO: event-specific inspect output
            return context.runtime.newString("#<TracePoint:" +  + ">");
        }
        
        return context.runtime.newString("#<TracePoint:" + ( ? "enabled" : "disabled") + ">");
    }
    
    public IRubyObject lineno(ThreadContext context) {
        checkInside(context);
        
        return context.runtime.newFixnum();
    }
    
    public IRubyObject method_id(ThreadContext context) {
        checkInside(context);
        
        return  == null ? context.nil : context.runtime.newString();
    }
    
    public IRubyObject path(ThreadContext context) {
        checkInside(context);
        
        return  == null ? context.nil : context.runtime.newString();
    }
    
    public IRubyObject raised_exception(ThreadContext context) {
        checkInside(context);
        
        return ;
    }
    
    public IRubyObject return_value(ThreadContext context) {
        checkInside(context);
        
        // FIXME: get return value
        return ;
    }
    
    public IRubyObject self(ThreadContext context) {
        return .isNil() ? context.nil : ((RubyBinding)).getBinding().getSelf();
    }
    
    private void update(String eventNameString fileint lineString nameIRubyObject typeIRubyObject exceptionIRubyObject returnValueIRubyObject binding) {
        // TODO: missing exception, self, return value
        this. = eventName;
        this. = file;
        this. = line;
        this. = name;
        this. = type;
        this. = exception;
        this. = returnValue;
        this. = binding;
    }
    private synchronized IRubyObject doToggle(ThreadContext contextBlock blockboolean toggle) {
        if (block.isGiven()) {
            boolean old = ;
            try {
                updateEnabled(contexttoggle);
                
                return block.yieldSpecific(context);
            } finally {
                updateEnabled(contextold);
            }
        }
        
        IRubyObject old = context.runtime.newBoolean();
        updateEnabled(contexttoggle);
        
        return old;
    }
    public void updateEnabled(ThreadContext contextboolean toggle) {
        if (toggle == return// don't re-add or re-remove hook
        
         = toggle;
        
        if (toggle) {
            context.runtime.addEventHook();
        } else {
            context.runtime.removeEventHook();
        }
    }
    private void checkInside(ThreadContext contextthrows RaiseException {
        if (!throw context.runtime.newRuntimeError("access from outside");
    }
    
    private EventHook hook;
    private volatile boolean enabled = false;
    private String eventName;
    private String file;
    private int line;
    private String name;
    private IRubyObject type;
    private IRubyObject exception;
    private IRubyObject returnValue;
    private IRubyObject binding;
    private volatile boolean inside = false;
New to GrepCode? Check out our FAQ X