reflexive 0.0.6 → 0.1.0

data/lib/reflexive/methods.rb

@@ -1,4 +1,5 @@
 require "reflexive/core_ext/kernel/singleton_class"
+require "reflexive/core_ext/module/reflexive_instance_methods"
 
 module Reflexive
   class Methods
@@ -36,7 +37,7 @@ module Reflexive
     def each_immediate_class_and_instance_method(&block)
       VISIBILITIES.each do |visibility|
         [ @klass_or_module, @klass_or_module.singleton_class ].each do |klass|
-          methods = klass.send("#{ visibility }_instance_methods", false)
+          methods = klass.send("reflexive_#{ visibility }_instance_methods", false)
           methods.each { |m| block.call(klass.instance_method(m)) }
         end
       end
@@ -123,7 +124,7 @@ module Reflexive
     # when no methods are found - returns nil
     def collect_instance_methods(klass)
       methods_with_visibility = VISIBILITIES.map do |visibility|
-        methods = klass.send("#{ visibility }_instance_methods", false)
+        methods = klass.send("reflexive_#{ visibility }_instance_methods", false)
         [visibility, methods] unless methods.empty?
       end.compact
       Hash[methods_with_visibility] unless methods_with_visibility.empty?

data/lib/reflexive/parse_tree_top_down_walker.rb

@@ -91,7 +91,17 @@ module Reflexive
       return unless params_event
       params_event = params_event[1] if params_event[0] == :paren # ?
       found = false
-      for scanner_event in extract_scanner_events_from_tree(params_event)
+
+      if options_arguments = params_event[2]
+        options_arguments.each do |optional_argument|
+          if scanner_event?(event = optional_argument[0])
+            add_local_variable(event)
+            keep_walking(optional_argument[1..-1])
+          end
+        end
+      end
+
+      for scanner_event in extract_scanner_events_from_tree(params_event.values_at(1,3,4,5))
         if scanner_event[:ident]
           found = true
           add_local_variable(scanner_event)
@@ -167,10 +177,11 @@ module Reflexive
 
     def on_def(name, params, body)
       push_local_variables_context
+      # TODO this is hack :(
+      push_namespace_instance_scope unless @in_singleton_class_defition
       add_local_variables_from_params_event(params)
-      push_namespace_instance_scope
       keep_walking(body)
-      pop_namespace_scope
+      pop_namespace_scope unless @in_singleton_class_defition
       pop_local_variables_context
     end
 
@@ -182,7 +193,7 @@ module Reflexive
     end
 
     def on_class(name, ancestor, body)
-      keep_walking(name)
+      keep_walking(name, ancestor)
       push_local_variables_context
       push_namespace_scope(resolve_constant_ref(name))
       keep_walking(body)
@@ -192,7 +203,9 @@ module Reflexive
 
     def on_sclass(target, body)
       push_local_variables_context
+      @in_singleton_class_defition = true
       keep_walking(body)
+      @in_singleton_class_defition = false
       pop_local_variables_context
     end
 
@@ -231,13 +244,61 @@ module Reflexive
 
     def on_command(operation, command_args)
       method_call(operation, nil) if is_ident?(operation)
+      if operation[:ident] == "autoload" &&
+              (arguments = resolve_arguments(command_args))
+
+        if [:const, :tstring_content].include?(arguments[0].keys.first)
+          constant_access(arguments[0], arguments[0].values.first)
+        end
+      end
       keep_walking(command_args)
     end
 
+    def resolve_arguments(arguments)
+      arguments = arguments[1] if arguments[0] == :arg_paren
+      if arguments[0] == :args_add_block
+        if arguments[1].is_a?(Array)
+          arguments[1].map { |a| resolve_argument(a) }
+        end
+      end
+    end
+
+    def resolve_argument(argument)
+      if argument[0] == :symbol_literal
+        # [:symbol_literal, [:symbol, {:const=>"C"}]]
+        if argument[1].is_a?(Array)
+          if argument[1][0] == :symbol
+            argument[1][1] # {:const=>"C"}
+          end
+        end
+      elsif argument[0] == :string_literal
+        # [:string_literal, [:string_content, {:tstring_content=>"C"}]]
+        if argument[1].is_a?(Array)
+          if argument[1][0] == :string_content
+            argument[1][1] # {:tstring_content=>"C"}
+          end
+        end
+      end
+    end
+
     def on_fcall(operation)
       method_call(operation, nil) if is_ident?(operation)
     end
 
+    def on_method_add_arg(method, arguments)
+
+      if method[0] == :fcall &&
+              scanner_event?(method[1]) &&
+              method[1][:ident] == "autoload"
+        if arguments = resolve_arguments(arguments)
+          if [:const, :tstring_content].include?(arguments[0].keys.first)
+            constant_access(arguments[0], arguments[0].values.first)
+          end
+        end
+      end
+      keep_walking(method, arguments)
+    end
+
     # primary_value => anything
     # operation2	: tIDENTIFIER
     #		| tCONSTANT
@@ -277,9 +338,9 @@ module Reflexive
     def on_call(receiver, dot, method)
       if rcv = resolve_receiver(receiver)
         method_call(method, [rcv])
-      else
-        keep_walking(receiver)
       end
+       
+      keep_walking(receiver)
     end
 
     def on_var_ref(ref_event)
@@ -328,8 +389,8 @@ module Reflexive
 
     def method_call(scanner_event, receiver, *args)
       unless receiver
-        # implict self concept
-        receiver = @scope.dup
+        # implict self concept (will be fetched from constant_access_scope)
+        receiver = @scope.last == :instance ? :instance : :class
       end
       merge_tags(scanner_event,
                  {:method_call =>

data/lib/reflexive/reflexive_ripper.rb

@@ -19,8 +19,11 @@ module Reflexive
 
     def parse
       parse_tree = super
-      require 'pp'
-      # pp parse_tree
+      
+      if ENV["DEBUG"]
+        require 'pp'
+        pp parse_tree
+      end
 
       ParseTreeTopDownWalker.new(parse_tree).walk
       parse_tree

data/lib/reflexive/routing_helpers.rb

@@ -1,70 +1,91 @@
 require "cgi" unless defined?(CGI) && defined?(CGI::escape)
 
-module RoutingHelpers
-  # method_call_tag is the scanner event tag emitted by ReflexiveRipper
-  def method_call_path(method_call_tag)
-    # r method_call_tag.values_at(:name, :receiver)
-    name, receiver = method_call_tag.values_at(:name, :receiver)
-    if receiver.last == :instance
-      new_method_path(receiver[0..-2].join("::"), :instance, name)
-    else
-      new_method_path(receiver.join("::"), :class, name)
-    end rescue(r(method_call_tag)) 
-  end
+module Reflexive
+  module RoutingHelpers
+    # method_call_tag is the scanner event tag emitted by ReflexiveRipper
+    def method_call_path(method_call_tag)
+      # r method_call_tag.values_at(:name, :receiver)
+      name, receiver, scope = method_call_tag.values_at(:name, :receiver, :scope)
+      scope = scope.join("::")
 
-  # entry point for method links (may dispatch to
-  # class_method_definition_path or method_documentation_path based on whether
-  # the method definition was found by with our reflection capabilities)
-  def new_method_path(constant, level, method_name)
-    "/reflexive/constants/#{ constant }/#{ level }_methods/#{ CGI.escape(method_name.to_s) }"
-  end
+      if receiver == :class
+        scope = "Kernel" if scope.empty?
+        new_method_path(scope, :class, name)
+      elsif receiver == :instance
+        scope = "Kernel" if scope.empty?
+        new_method_path(scope, :instance, name)
+      else
+        receiver = receiver.join("::")
+        new_method_path(Reflexive.constant_lookup(receiver, scope), :class, name)
+      end
 
-  def class_method_definition_path(constant, method_name)
-    new_method_path(constant, :class, method_name) + "/definition"
-  end
+#    if receiver.last == :instance
+#      new_method_path(receiver[0..-2].join("::"), :instance, name)
+#    else
+#      new_method_path(receiver.join("::"), :class, name)
+#    end rescue(r(method_call_tag))
+    end
 
-  def instance_method_definition_path(constant, method_name)
-    new_method_path(constant, :instance, method_name) + "/definition"
-  end
+    # entry point for method links (may dispatch to
+    # class_method_definition_path or method_documentation_path based on whether
+    # the method definition was found by with our reflection capabilities)
+    def new_method_path(constant, level, method_name)
+      "/reflexive/constants/#{ constant }/#{ level }_methods/#{ CGI.escape(method_name.to_s) }"
+    end
 
-  def method_documentation_path(constant, method_name)
-    method_path(constant, method_name) + "/apidock"
-  end
+    def method_path(constant, method_name)
+      "/reflexive/constants/#{ constant }/methods/#{ CGI.escape(method_name.to_s) }"
+    end
 
-  def dashboard_path
-    "/reflexive/dashboard"
-  end
+    def new_method_definition_path(constant, level, method_name)
+      new_method_path(constant, level, method_name) + "/definition"
+    end
 
-  def up_path(path)
-    file_path(File.expand_path("../", path))
-  end
+    def class_method_definition_path(constant, method_name)
+      new_method_path(constant, :class, method_name) + "/definition"
+    end
 
-  def file_path(path)
-    File.join("/reflexive/files", path)
-  end
+    def instance_method_definition_path(constant, method_name)
+      new_method_path(constant, :instance, method_name) + "/definition"
+    end
 
-  def constant_lookup_path(name, scope)
-    "/reflexive/constant_lookup" <<
-      "?name=#{ CGI.escape(name) }&scope=#{ CGI.escape(scope.join("::"))}"
-  end
+    def method_documentation_path(constant, level, method_name)
+      new_method_path(constant, level, method_name) + "/apidock"
+    end
 
-  def load_path_lookup_path(path)
-    "/reflexive/load_path_lookup?path=#{ CGI.escape(path.to_s) }"
-  end
+    def dashboard_path
+      "/reflexive/dashboard"
+    end
 
-  def constant_path(constant)
-    "/reflexive/constants/#{ constant }"
-  end
+    def up_path(path)
+      file_path(File.expand_path("../", path))
+    end
 
-  def method_path(constant, method_name)
-    "/reflexive/constants/#{ constant }/methods/#{ CGI.escape(method_name.to_s) }"
-  end
+    def file_path(path)
+      File.join("/reflexive/files", path)
+    end
 
-  def apidock_path(constant, method_name)
-    "http://apidock.com/ruby/#{ constant }/#{ CGI.escape(method_name.to_s) }"
-  end
+    def constant_lookup_path(name, scope)
+      "/reflexive/constant_lookup" <<
+              "?name=#{ CGI.escape(name) }&scope=#{ CGI.escape(scope.join("::"))}"
+    end
+
+    def load_path_lookup_path(path)
+      "/reflexive/load_path_lookup?path=#{ CGI.escape(path.to_s) }"
+    end
+
+    def constant_path(constant)
+      "/reflexive/constants/#{ constant }"
+    end
+
+    def apidock_path(constant, level, method_name)
+      path = "http://apidock.com/ruby/#{ constant }/#{ CGI.escape(method_name.to_s) }"
+      path << "/class" if level == :class
+      path
+    end
 
-  def method_definition_path(constant, method_name)
-    method_path(constant, method_name) + "/definition"
+    def method_definition_path(constant, level, method_name)
+      method_path(constant, method_name) + "/definition"
+    end
   end
 end

data/public/stylesheets/reflexive/reflexive.css

@@ -102,6 +102,11 @@ pre .lva-highlight
 .dashboard .column
 {
   float: left;
+
+}
+
+.dashboard .column.first
+{
   width: 350px;
 }
 

data/reflexive.gemspec

@@ -13,13 +13,16 @@ Gem::Specification.new do |s|
   s.required_ruby_version = '>= 1.9.1'
 
   # keeping this in sync with Gemfile manually
-  s.add_dependency "rack"
-  s.add_dependency "sinatra"
-  s.add_dependency "sinatra_more"
-  s.add_dependency "coderay"
-  s.add_dependency "rdiscount"
+  s.add_dependency "rack", "1.1.0"
+  s.add_dependency "sinatra", "1.0"
+  s.add_dependency "sinatra_more", "0.3.40"
+  s.add_dependency "coderay", "0.9.3"
+  #  s.add_dependency "rdiscount"
 
   s.add_development_dependency "rails", "3.0.0.beta3"
   s.add_development_dependency "rspec", "2.0.0.beta.8"
-  s.add_development_dependency "sinatra-reloader"
+  s.add_development_dependency "sinatra-reloader", "0.4.1"
+  s.add_development_dependency "thin", "1.2.7"
+  s.add_development_dependency "rack-test", "0.5.3"
+  s.add_development_dependency "webrat", "0.7.1"
 end

data/spec/coderay_html_encoder_spec.rb

@@ -11,6 +11,12 @@ describe Reflexive::CodeRayHtmlEncoder do
                             {:constant_access=>{:name=>"Cons", :scope=>[]}}]]).should(include("<a href"))
   end
 
+  it "emits constant links for :content tokens" do
+    encoder = Reflexive::CodeRayHtmlEncoder.new(:wrap => :div, :css => :style)
+    encoder.encode_tokens([["Cons", :content,
+                            {:constant_access=>{:name=>"Cons", :scope=>[]}}]]).should(include("<a href"))
+  end
+
   it "emits links with proper nesting info" do
     tokens = [["Cons", :constant,
                {:constant_access=>{:name=>"Cons", :scope=>["A", "B"]}}]]
@@ -26,7 +32,7 @@ describe Reflexive::CodeRayHtmlEncoder do
   it "emits class method links" do
     tokens = [ [
                   "m!", :ident,
-                  {:method_call=>{:name=>"m!", :receiver=>["A"]} }
+                  {:method_call=>{:name=>"m!", :receiver=>:class, :scope=>["A"]} }
              ] ]
     encoder.encode_tokens(tokens).should include("/constants/A/class_methods/m%21")
   end
@@ -34,7 +40,7 @@ describe Reflexive::CodeRayHtmlEncoder do
   it "emits instance method links" do
     tokens = [ [
                   "m!", :ident,
-                  {:method_call=>{:name=>"m!", :receiver=>["A", :instance]} }
+                  {:method_call=>{:name=>"m!", :receiver=>:instance, :scope => ["A"]} }
              ] ]
     encoder.encode_tokens(tokens).should include("/constants/A/instance_methods/m%21")
   end

data/spec/integration_spec.rb

@@ -0,0 +1,227 @@
+require "reflexive/application"
+require "rack/test"
+require "nokogiri"
+require "webrat/core/matchers"
+
+FIXTURE_FILE_PATH = File.expand_path("../integration_spec_fixture.rb", __FILE__)
+require FIXTURE_FILE_PATH
+
+describe Reflexive::Application do
+  include Rack::Test::Methods
+  include Webrat::Matchers
+
+  include Reflexive::RoutingHelpers
+
+  def app
+    Reflexive::Application
+  end
+
+  it "shows dashboard" do
+    get(dashboard_path)
+    last_response.should be_ok
+    last_response.body.should include("Reflexive", "$LOAD_PATH", "Favorites")
+    last_response.body.should have_selector('a', :content => "Date")
+    last_response.body.should have_selector('a', :content => "Gem")
+    last_response.body.should have_selector('a', :content => "FileUtils")
+  end
+
+  describe "class/module browser" do
+    def constant_browser_for(constant)
+      get(constant_path(constant))
+      last_response.should be_ok
+      last_response.body
+    end
+    
+    it "shows class name" do
+      get(constant_path("OpenStruct"))
+      last_response.should be_ok
+      last_response.body.should include("OpenStruct")
+    end
+
+    it "shows files in which class is defined" do
+      constant_browser_for("OpenStruct").
+              should include("ostruct.rb")
+      constant_browser_for("IntegrationSpecFixture::TestClass").
+              should include("integration_spec_fixture.rb")
+    end
+
+    it "shows superclass" do
+      constant_browser_for("IntegrationSpecFixture::TestClass").
+              should include("TestBaseClass")
+      constant_browser_for("OpenStruct").
+              should include("BasicObject")
+    end
+
+    it "shows instance methods" do
+      constant_browser_for("IntegrationSpecFixture::TestClass").
+              should include("public_meth", "protected_meth", "private_meth")
+    end
+
+    it "shows class methods" do
+      constant_browser_for("IntegrationSpecFixture::TestClass").
+              should include("class_meth")
+    end
+
+    it "shows inherited instance methods" do
+      constant_browser_for("IntegrationSpecFixture::TestClass").
+              should include("inherited_meth")
+    end
+
+    it "shows inherited class methods" do
+      constant_browser_for("IntegrationSpecFixture::TestClass").
+              should include("inherited_class_meth")
+    end
+
+    it "shows instance methods for module" do
+      constant_browser_for("IntegrationSpecFixture::TestModule").
+              should include("module_meth")
+    end
+
+    it "shows class methods for module" do
+      constant_browser_for("IntegrationSpecFixture::TestModule").
+              should include("module_class_meth")
+    end
+
+    it "shows classes module is included in" do
+      constant_browser_for("IntegrationSpecFixture::TestModule").
+              should include("TestClass")
+    end
+
+    it "shows classes class is derived from" do
+      constant_browser_for("IntegrationSpecFixture::TestBaseClass").
+              should include("TestClass")
+    end
+
+    it "shows classes nested inside the class" do
+      constant_browser_for("IntegrationSpecFixture::TestClass").
+              should have_selector("a", :content => "NestedClass")
+    end
+  end
+
+  describe "source browser" do
+    def source_browser
+      get(file_path(FIXTURE_FILE_PATH))
+      last_response.should be_ok
+      last_response.body
+    end
+
+    it "shows arbitrary files from file system" do
+      get(file_path(FIXTURE_FILE_PATH))
+      last_response.should be_ok
+      last_response.body.should include("integration_spec_fixture.rb")
+    end
+
+    it "browses directories" do
+      dir = File.dirname(FIXTURE_FILE_PATH)
+      get(file_path(dir))
+      last_response.should be_ok
+
+      Dir["#{ dir }/*"].each do |path|
+        last_response.body.should include(File.basename(path))
+      end
+    end
+
+    it "highlights the code" do
+      source_browser.should have_selector("span.no")
+      source_browser.should have_selector("span.s")
+      source_browser.should have_selector("span.r")
+      source_browser.should have_selector("span.co")
+    end
+
+    it "links class names" do
+      source_browser.should have_selector('a[href$="constant_lookup?name=TestBaseClass&scope=IntegrationSpecFixture"]')
+    end
+
+    it "links module names" do
+      source_browser.should have_selector('a[href$="constant_lookup?name=IntegrationSpecFixture&scope="]')
+    end
+
+    it "links arguments to require/load" do
+      source_browser.should have_selector('a[href$="load_path_lookup?path=ostruct"]')
+    end
+
+    it "links method calls from top level" do
+      source_browser.should have_selector('a[href$="constants/Kernel/class_methods/require"]')
+    end
+
+    it "links method calls from class instance level" do
+      source_browser.should have_selector('a[href$="constants/IntegrationSpecFixture::TestClass/class_methods/inherited_class_meth"]')
+    end
+
+    it "links method calls from class definition level" do
+      source_browser.should have_selector('a[href$="constants/IntegrationSpecFixture::TestClass/class_methods/another_inherited_class_meth"]')
+    end
+
+    it "links local variable assignments and access" do
+      source_browser.should have_selector('span[id^="lv:"][id$=":local_var"]', :content => "local_var") do |local_var_assignment|
+        source_browser.should have_selector('a[href="#' + local_var_assignment.first["id"] + '"]')
+      end
+      source_browser.should have_selector('span[id^="lv:"][id$=":another_local_var"]', :content => "another_local_var")
+      # source_browser.should have_selector('a.lva', :content => "another_local_var")
+    end
+
+    it "links method calls" do
+      source_browser.should have_selector('a[href$="constants/IntegrationSpecFixture::TestClass/instance_methods/not_defined_meth"]', :content => "not_defined_meth")
+    end
+  end
+
+  describe "constant lookup" do
+    it "redirects to found constant" do
+      get(constant_lookup_path("TestModule", ["IntegrationSpecFixture::TestClass"]))
+      
+      last_response.should be_redirect
+      last_response.body.should be_empty
+
+      follow_redirect!
+      
+      last_response.body.should match(/module\s+IntegrationSpecFixture::TestModule/) 
+      last_response.body.should include("integration_spec_fixture.rb")
+    end
+  end
+
+  describe "method lookup" do
+    it "redirects to found method" do
+      get(new_method_path("IntegrationSpecFixture::TestClass", :instance, "inherited_meth"))
+
+      last_response.should be_redirect
+      last_response.body.should be_empty
+
+      follow_redirect!
+      
+      last_request.path.should include("constants/IntegrationSpecFixture::TestClass/instance_methods/inherited_meth/definition")
+    end
+
+    it "shows error message when method is not found" do
+      get(new_method_path("IntegrationSpecFixture::TestClass", :instance, "not_defined_meth"))
+
+      last_response.should be_ok
+      last_response.body.should include("Reflexive Error")
+    end
+
+    it "redirect to documentation for core methods" do
+      get(new_method_path("IntegrationSpecFixture::TestClass", :class, "class_eval"))
+
+      last_response.should be_redirect
+
+      follow_redirect!
+      
+      last_request.path.should include("constants/Module/instance_methods/class_eval/apidock")
+    end
+
+    it "uses heuristics providing user a way to choose method for module instance methods" do
+      get(new_method_path("IntegrationSpecFixture::HeuristicLookupBaseModule", :instance, "meth"))
+
+      last_response.should be_ok
+      last_response.body.should include("HeuristicLookupIncludingClass1")
+      last_response.body.should include("HeuristicLookupIncludingClass2")
+    end
+
+    it "uses heuristics providing user a way to choose method for class instance methods" do
+      get(new_method_path("IntegrationSpecFixture::HeuristicLookupBaseClass", :instance, "meth"))
+
+      last_response.should be_ok
+      last_response.body.should include("HeuristicLookupInheritingClass1")
+      last_response.body.should include("HeuristicLookupInheritingClass2")
+    end
+  end
+end