maglev-webtools 0.2.1 → 1.0

data/README.rdoc

@@ -1,40 +1,51 @@
-= WebTools Example
+= WebTools Example, a demo for what a unified Ruby mirror API can offer you
 
-The WebTools Sinatra application running in MagLev allows you to explore a
-MagLev Ruby application's Classes, Modules, Methods, Constants, and Ancestors
-in a web browser.
+The WebTools Sinatra application allows you to explore a Ruby
+application's Classes, Modules, Methods, Constants, and Ancestors in a
+web browser, as well as run and debug code, or explore VM statistics
+and other info.
 
-It will also allow you to explore GemStone/S Smalltalk code, and to examine
-detailed statistics about all processes connected to GemStone/S.
+If running on MagLev, it will also allow you to explore GemStone/S
+Smalltalk code, and to examine detailed statistics about all processes
+connected to GemStone/S.
 
 === Setup
 
-1. Download and install MagLev using instructions at
-   https://github.com/MagLev/maglev/blob/master/README.rdoc
+    $ rvm use [maglev-head|rbx|jruby|ruby-head]
+    $ bundle install
 
-2. Start the MagLev server
-    $ cd $MAGLEV_HOME
-    $ maglev start
-
-3. Install necessary gems:
-    $ cd <to this directory>
-    $ $MAGLEV_HOME/bin/bundle install
-
-    ### Temporary workaround for https://magtrac.gemstone.com/ticket/879 ###
+    ### Temporary workaround on MagLev for https://github.com/MagLev/maglev/issues/58 ###
     $ maglev-gem pristine rack
 
 == Viewing Ruby code
 
 Run the WebTools Sinatra application
 
-    $ rake
+    $ bundle exec rake
 
 This will start WEBrick in your current window. Hit Ctl-C to stop.
 
-Browse to http://localhost:9292/, click on a class or module, then
-click on a constant or method. Results appear in the bottom pane, file
-locations with line numbers in the bottom status line, and time spent
-on the server/network/client in the top status line.
+Browse to http://localhost:9292/webtools, open a browser, click on a
+namespace, then click on a constant in that namespace. You will see
+instance methods. Select boxes show ancestors and implementors of the
+selected method in the hierarchy. To see class methods, switch to the
+"Class" tab.
+
+Method source appears in the bottom pane, and time spent on the
+server/network/client in the status line. Depending on your Ruby,
+saving methods will work or not.
+
+If you choose to open a workspace, you can run Ruby code. If the code
+has an error, a debugger will start. Depending on the capabilities of
+your Ruby, you can also inspect stack frames, trim the stack, step
+through methods and inspect arguments and locals. As a rule of thumb,
+almost nothing of this will work with MRI, because the MRI reflection
+is ad-hoc, infantile, and generally a prime example for an utter lack
+of -- or disgregard for -- engineering prinicples. Have a look at the
+Ruby mirrors project (https://github.com/timfel/rubymirrors) for more
+information.
+
+== MagLev specific demos
 
 === Add classes and modules from ActiveModel
 
@@ -46,8 +57,9 @@ to load an empty database.</b>
 
     $ rake meta
 
-Click on "Refresh View" in WebTools. Note that AValidPerson now appears in the
-class list, as do a number of classes/modules from ActiveModel and ActiveSupport.
+Open a new browser in WebTools. Note that AValidPerson now appears in
+the class list, as do a number of classes/modules from ActiveModel and
+ActiveSupport.
 
 Click on the class AValidPerson and compare it with the source
 (meta_demo.rb). Some things to note:
@@ -92,7 +104,7 @@ $MAGLEV_HOME/gemstone/examples/www. The Smalltalk example code can be
 invoked from ruby (a demonstration of how to invoke Smalltalk from Ruby),
 via:
 
-    $ rake smalltalk:run
+    $ rake smalltalk
 
 Then browse to http://localhost:8080/ and explore
 
@@ -100,10 +112,7 @@ Hit Ctl-C in the terminal window to stop.
 
 == Known problems
 
-Network timeouts are not caught. EAGAIN is not handled. If you're running WebTools on
-a slow network, this may cause data to not appear in the bottom pane.
-
-The line number displayed for evals is always 2. This will be fixed at a later date.
+Oh, so many problems...
 
 == Contributing
 

data/bin/webtools

@@ -1,14 +1,35 @@
-#!/usr/bin/env maglev-ruby
+#!/usr/bin/env ruby
 $LOAD_PATH.unshift(File.expand_path("../../lib", __FILE__))
+require 'rubygems'
 require 'rack'
 require 'web_tools'
 
+# HACK
+ARGV.each do |arg|
+  ARGV.shift
+  mirror_api = ARGV.first if arg == "-t"
+end
+mirror_api ||= RUBY_ENGINE
+begin
+  require "#{mirror_api.downcase}/reflection"
+  MirrorAPI = Object.const_get(mirror_api.capitalize)
+rescue LoadError
+  require "ruby/reflection"
+  MirrorAPI = Ruby
+end
+# HACK END ;)
+
 app = Rack::Builder.new do
   WebTools::UI.set :root, File.expand_path("../..", __FILE__)
   ui = WebTools::UI.new
+  WebTools.constants.each { |c| WebTools.const_get(c) }
+
   redirect = proc { |env| [301,
                     {'Content-Type' => 'text/html', 'Location' => '/webtools/'},
                     '<a href="/webtools">Moved permanently</a>'] }
+  WebTools::Tool.subclasses.each do |cls|
+    map('/webtools/' + cls.display_name) { run cls.new }
+  end
   map('/webtools/') { run ui }
   map('/') { run redirect }
 end

data/lib/web_tools/code_browser.rb

@@ -0,0 +1,156 @@
+require 'sinatra/base'
+require 'web_tools'
+require 'web_tools/support/code_browser'
+require 'web_tools/support/service_helper'
+
+module WebTools
+  class CodeBrowser < Tool
+
+    def self.description
+      'Browse Namespaces, Classes, and Methods'
+    end
+
+    get '/' do # Tool>>json in ST
+      json("response" => response_for_class,
+           "dictList" => dict_list,
+           "packageList" => [],
+           "classCatList" => class_cat_list,
+           "classList" => class_list,
+           "classDef" => "",
+           "superList" => super_list,
+           "methodFilterList" => [],
+           "methodList" => method_list,
+           "implList" => implementor_list,
+           "method" => method)
+    end
+
+    post '/removeClass' do
+      parent = reflect(Object).constant(params["dict"] || "Object").value
+      parent.constant(params["klass"]).delete
+      json({})
+    end
+
+    post '/removeMethod' do
+      parent = reflect(Object).constant(params["dict"] || "Object").value
+      klass = parent.constant(params["klass"]).value
+      klass = klass.singleton_class if params["isMeta"]
+      klass.method(params["name"]).delete
+      json({})
+    end
+
+    def response_for_class
+      # return nil if params["selector"]
+      # return nil unless params["request"]
+      # begin
+      #   result = eval(params["request"])
+      #   if result.is_a? Module
+      #     return nil unless result.namespace
+      #     response = { "dict" => result.namespace.my_class.inspect,
+      #       "classCat" => nil,
+      #       "klass" => result.inspect,
+      #       "isMeta" => false,
+      #       "superClass" => result.inspect,
+      #       "methodCat" => nil,
+      #       "selector" => nil,
+      #       "implementor" => nil,
+      #       "action" => "klass" }
+      #     response.each {|k,v| params[k] = v }
+      #     response
+      #   else
+      #     nil
+      #   end
+      # rescue Exception => e
+      #   { "action" => "klass",
+      #     "error" => [e.class.inspect, e.message] }
+      # end
+    end
+
+    def dict_list
+      return [] unless params['isDictsTab']
+      pkgs = ["Object"]
+      reflect(Object).nested_classes.each do |k|
+        pkgs << k.name if k.nested_classes.any?
+        @dict = k if @dict.nil? && params['dict'] == k.name
+      end
+      pkgs.compact.uniq.sort
+    end
+
+    def class_cat_list
+      filter = (@dict || @package || reflect(Object))
+      names = []
+      class_cat_list_for(filter, names)
+      @class_category ||= filter
+      names.sort
+    end
+
+    def class_cat_list_for(klassmirror, ary)
+      klassmirror.nested_classes.each do |klass|
+        path = klass.name.gsub("::", "-")
+        unless ary.include? path
+          ary << path
+          if @class_category.nil? && params['classCat'] == path
+            @class_category = klass
+          end
+          class_cat_list_for(klass, ary)
+        end
+      end
+    end
+
+    # Returns a sorted list of class and module names in the Ruby Namespace
+    #
+    # @return [Array] sorted list of class and module names found in the Ruby
+    #         namespace hierarchy.
+    def class_list
+      @klass = reflect(Object).constant(params["klass"]).value if params["klass"]
+      @klass = @klass.singleton_class if @klass && params["isMeta"]
+      (@class_category.nested_classes + [@class_category]).collect(&:name).uniq.sort
+    end
+
+    def super_list
+      return [] if @klass.nil?
+      if params["superClass"]
+        super_class = non_meta_name(params["superClass"])
+        @super_class = reflect(Object).constant(super_class).value
+        if super_class != params["superClass"]
+          @super_class = @super_class.singleton_class
+        end
+      else
+        @super_class = @klass
+      end
+      @super_list = @klass.ancestors.reverse
+      @super_list.collect(&:name)
+    end
+
+    def implementor_list
+      selected = params["implementor"]
+      return [] if @super_list.nil? || @super_list.empty?
+      list = @super_list.select do |c|
+        c.methods.include?(@selector)
+      end
+      @implementor = list.detect {|e| e.name == selected } || @klass
+      list.collect(&:name)
+    end
+
+    def method
+      return nil unless @implementor && @selector
+      nil.pause if Module === @implementor
+      @method = @implementor.method(@selector)
+      { "dictionaryName" => "",
+        "className" => @klass.name,
+        "isMeta" => params["isMeta"],
+        "category" => "",
+        "selector" => @selector,
+        "source" => @method.source,
+        "stepPoints" => @method.step_offsets,
+        "sends" => @method.send_offsets }
+    end
+
+    def method_list
+      selected = params["selector"]
+      return [] if @super_list.nil? || @super_list.empty?
+      list = @super_class.methods
+      @selector = selected if list.include? selected
+      list.sort
+    end
+  end
+end

data/lib/web_tools/debugger.rb

@@ -1,219 +1,116 @@
-require 'sinatra'
 require 'web_tools'
-require 'web_tools/support/service_helper'
-require 'rack/contrib/jsonp'
-require 'maglev/debugger'
-require 'maglev/method_source'
 
-module WebTools
-  class Debugger < Sinatra::Base
-    include WebTools::Support::ServiceHelper
-    use Rack::JSONP
+class WebTools::Debugger < WebTools::Tool
+  dont_show!
 
-    def respond_json(obj)
-      content_type :json
-      result = case obj
-               when Maglev::Debugger::Wrapper
-                 obj.to_hash
-               else
-                 if obj.is_a? Array and
-                     obj.all? {|e| e.is_a? Maglev::Debugger::Wrapper}
-                   obj.collect(&:to_hash)
-                 else
-                   case obj
-                   when Array, Hash
-                     obj
-                   else
-                     details_for(obj)
-                   end
-                 end
-               end
-      body(result.to_json)
-    end
-
-    def process
-      Maglev::Debugger::Process.new(ObjectSpace._id2ref(params[:oop].to_i))
-    end
-
-    def frames
-      params.has_key?("all") ? process.frames : process.ruby_frames
-    end
-
-    def frame
-      f = frames[params[:idx].to_i]
-      f.debug_info!
-      f
-    end
-
-    def objects
-      instance_variables_for(object)
-    end
-
-    def object
-      ctxt = frame.debug_info[:context]
-      obj = nil
-      variable_list = params[:splat].first.split("/objects/")
-      variable_list.each do |name|
-        name = name[0...(-"/objects".size)] if name.end_with? "/objects"
-        obj = ctxt[name.to_sym]
-        ctxt = instance_variables_for(obj)
-      end
-      obj
-    end
-
-    def instance_variables_for(object)
-      object.instance_variables.inject({}) do |hash, var|
-        hash[var.to_sym] = object.instance_variable_get(var)
-        hash
-      end
-    end
+  before do
+    @entry = system.object_by_id(params["oop"].to_i).reflectee
+    @process = reflect(@entry.thread) if @entry
+  end
 
-    def details_for(object)
-      { "instance_variables" => instance_variables_for(object),
-        "self" => object,
-        "inspect" => object.inspect,
-        "class" => object.class,
-        "do-it" => nil,
-        "do-it-result" => nil }
-    end
+  get '/' do
+    return {} unless @entry
+    json("label" => @entry.exception.message,
+         "stack" => str_report_for(@process))
+  end
 
-    before do
-      Maglev.abort_transaction
-    end
+  get '/frame' do
+    return {} unless @process
+    frame = @process.stack[params["frame"].to_i - 1]
+    return {} if frame.nil?
+    json("method" => method_data_from_frame(frame),
+         "variables" => variables_data_from_frame(frame))
+  end
 
-    # => list of errors
-    get "/process" do
-      errors = ObjectLog.errors.collect {|e| Maglev::Debugger::Process.new(e) }
-      processes = Thread.list.select(&:stop?).collect do |e|
-        Maglev::Debugger::Process.new(e)
+  post '/step' do
+    return {} unless @process
+    steplevel = params["level"].to_i
+    stacksize = @process.stack.size
+
+    if params["level"]
+      @process.step(steplevel)
+    else
+      @process.run
+      sleep 0.2 until @process.reflectee.stop?
+      unless @process.alive? # No exception, return result
+        # TODO
+        nil.pause
       end
-      respond_json (errors + processes)
     end
 
-    get "/process/:oop" do
-      respond_json process
-    end
+    new_stack = @process.stack
+    frame = new_stack.first
 
-    get "/process/:oop/frames" do
-      respond_json frames
+    data = { "label" => @process.name,
+      "method" => method_data_from_frame(frame),
+      "variables" => variables_data_from_frame(frame) }
+    if new_stack.size != stacksize # Stack changed, reload
+      data["stack"] = str_report_for @process
     end
 
-    get "/process/:oop/frames/:idx" do
-      respond_json frame
-    end
-
-    get "/process/:oop/frames/:idx/objects" do
-      respond_json frame.debug_info[:context]
-    end
-
-    get "/process/:oop/frames/:idx/objects/*" do
-      if params[:splat].first.end_with? "objects"
-        respond_json objects
-      else
-        respond_json details_for(object)
-      end
-    end
-
-    delete "/process/:oop" do
-      respond_json process.delete
-    end
-
-    delete "/process/:oop/frames/:idx" do
-      respond_json frame.delete
-    end
+    json(data)
+  end
 
-    post "/process/:oop" do
-      p = process
-      return 404 if p.is_a? Maglev::Debugger::ObjectLogError
-      if params["running"] == "true" and p.thread.alive? and p.thread.stop?
-        p.thread.run
-        Thread.pass
-        Thread.pass
-        p.thread.join
-        if (result = p.thread[:result]).is_a? Maglev::Debugger::Process
-          if params["debugging"] == "true"
-            status 500
-            body result.exception.inspect
-          else
-            p.thread.kill
-            Thread.pass
-            raise result.exception
-          end
-        else
-          result
-        end
-      else
-        404
-      end
-    end
+  post '/restart' do
+    return {} unless @process
+    frame = @process.stack[params["frame"].to_i - 1]
+    return {} if frame.nil?
+    frame.restart
+    new_frame = @process.stack.first
+
+    json("label" => @process.name,
+         "stack" => str_report_for(@process),
+         "method" => method_data_from_frame(new_frame),
+         "variables" => variables_data_from_frame(new_frame))
+  end
 
-    put "/process/:oop/frames/:idx" do
-      # TODO: Really check the posted document
-      if doIt = params["do-it"]
-        begin
-          result = frame.context_eval(doIt)
-        rescue Exception => e
-          result = e
-        end
-        current_frame = frame.to_hash
-        current_frame[:"do-it"] = doIt
-        current_frame[:"do-it-result"] = details_for(result)
-        respond_json current_frame
-      elsif params["index"] == "1" and params[:idx] == "0"
-        current_frame = frame.to_hash
-        until frame.method_name != current_frame[:method_name]
-          frame.step(:into) # Step into until we find the next ruby frame
-        end
-        respond_json frame
-      elsif di = params["debug_info"]
-        current_frame = frame.to_hash
-        if di["stepOffset"] && di["stepOffset"] != current_frame[:debug_info][:stepOffset]
-          return 404 unless params[:idx] == "0"
-          while di["stepOffset"].to_i > frame[:debug_info][:stepOffset].to_i
-            frame.step(:over)
-          end
-          respond_json frame
-        elsif di["source"] && di["source"] != current_frame[:debug_info][:source]
-          current_frame = frame
-          return 404 if frame.block_nesting > 0 # cannot change nested frames
-          klass = current_frame.defining_class
-          klass.set_method_source(current_frame.method_name, di["source"])
-          current_frame.delete
-          params[:idx] = "0"
-          respond_json frame # Retreive the frame again, to show the updated source
-        end
-      else
-        status 404
-        respond_json frame
-      end
-    end
+  def method_data_from_frame(frame)
+    dict = frame.method.defining_class.nesting[1]
+    dict = dict ? dict.name : ""
+    { "source" => frame.method.source,
+      "stepPoints" => frame.method.step_offsets,
+      "sends" => frame.method.send_offsets,
+      "nowAt" => frame.step_offset,
+      "dictionaryName" => dict || "",
+      "className" => frame.method.defining_class.name,
+      "isMeta" => frame.method.defining_class.singleton_class? }
+  rescue Exception
+    return { "source" => "", "stepPoints" => "", "sends" => "", "nowAt" => 0,
+      "dictionaryName" => "", "className" => "", "isMeta" => "" }
+  end
 
-    put "/process/:oop/frames/:idx/objects/*" do
-      return 404 if params[:splat].first.end_with? "objects"
+  def variables_data_from_frame(frame)
+    list = [{ "name" => "self",
+              "string" => frame.self.name,
+              "oop" => frame.self.reflectee.object_id }]
+    if frame.self != frame.receiver
+      list << { "name" => "receiver",
+        "string" => frame.receiver.name,
+        "oop" => frame.receiver.reflectee.object_id }
+    end
+    frame.arguments.each do |k, v|
+      list << { "name" => k.to_s,
+        "string" => v.name,
+        "oop" => v.reflectee.object_id }
+    end
+    frame.locals.each do |k, v|
+      list << { "name" => k.to_s,
+        "string" => v.name,
+        "oop" => v.reflectee.object_id }
+    end
+    list
+  rescue Exception
+    return []
+  end
 
-      if doIt = params["do-it"]
-        begin
-          result = object.instance_eval(doIt)
-        rescue Exception => e
-          result = e
-        end
-        return_value = details_for(object)
-        return_value["do-it"] = doIt
-        return_value["do-it-result"] = details_for(result)
-        respond_json return_value
-      else
-        404
+  def str_report_for(process_mirror)
+    process_mirror.stack.collect do |f|
+      str = ""
+      if f.method
+        separator = f.method.defining_class.singleton_class? ? '.' : '#'
+        str = "#{f.method.defining_class.name}#{separator}"
       end
-    end
-
-    # XXX: Remove me, please
-    options '*' do
-      [200,
-       { 'Access-Control-Allow-Origin' => '*',
-         'Access-Control-Allow-Methods' => 'PUT, POST, GET, DELETE, OPTIONS',
-         'Access-Control-Max-Age' => '1000',
-         'Access-Control-Allow-Headers' => '*' },
-       [""]]
+      str += (f.name || "block in #{f.selector}")
     end
   end
 end