reflexive 0.0.3 → 0.0.4

data/spec/rails_integration_spec.rb

@@ -0,0 +1,139 @@
+require "fileutils"
+require "open-uri"
+
+require "reflexive"
+
+require File.expand_path("../rails_integration_spec_helper", __FILE__)
+
+shared_examples_for "fresh Rails app with Reflexive installed" do
+  it "responds on localhost" do
+    get("/").should include("Welcome aboard")
+  end
+
+  it "responds for Reflexive paths" do
+    constant_reflexion = get("/reflexive/constants/ActiveRecord::Base")
+    constant_reflexion.should include("ActiveRecord")
+    constant_reflexion.should include("Object")
+    constant_reflexion.should include("Class")
+    constant_reflexion.should include("Module")
+  end
+end
+
+describe "Integration with" do
+  describe "Rails 2.x" do
+    before(:all) do
+      bootstrap_gem_environment("rails", "2.3.5")
+      build_and_install_test_gem
+    end
+
+    it "installs proper version of Rails" do
+      sh_in_tmp_gemset("rails -v", :out => :return).should include("Rails 2")
+    end
+    
+    it "installs test Reflexive gem" do
+      sh_in_tmp_gemset("gem list", :out => :return).should include("reflexive")
+    end
+
+    describe "creates Rails application" do
+      before(:all) do
+        create_rails_app("2")
+      end
+
+      it "which has config/environment.rb file" do
+        Dir.chdir($app_dir) do
+          File.exist?("config/environment.rb")
+        end
+      end
+
+      describe "and installs Reflexive gem into it" do
+        before(:all) do
+          patch_app_file("config/environment.rb",
+                         "Rails::Initializer.run do |config|",
+                         <<-RUBY)
+                          Rails::Initializer.run do |config|
+                            config.gem "reflexive"
+                            config.middleware.insert_after("Rack::Lock", "Reflexive::Application")
+          RUBY
+        end
+
+        it "properly" do
+          Dir.chdir($app_dir) do
+            IO.read("config/environment.rb").should include("Reflexive")
+          end
+        end
+
+        describe "and runs application" do
+          before(:all) do
+            Dir.chdir($app_dir) do
+              spawn_server_and_wait_for_response("ruby script/server")
+            end
+          end
+
+          it_should_behave_like "fresh Rails app with Reflexive installed"
+
+          after(:all) do
+            terminate_server_blocking
+          end
+        end
+      end
+    end
+  end
+
+  describe "Rails 3.x" do
+    before(:all) do
+      bootstrap_gem_environment("rails", "3.0.0.beta3")
+      build_and_install_test_gem
+    end
+
+    it "installs proper version of Rails" do
+      sh_in_tmp_gemset("rails -v", :out => :return).should include("Rails 3")
+    end
+
+    it "installs test Reflexive gem" do
+      sh_in_tmp_gemset("gem list", :out => :return).should include("reflexive")
+    end
+
+    describe "creates Rails application" do
+      before(:all) do
+        create_rails_app("3")
+      end
+
+      it "which has config/application.rb file" do
+        Dir.chdir($app_dir) do
+          File.exist?("config/application.rb")
+        end
+      end
+
+      describe "and installs Reflexive gem into it" do
+        before(:all) do
+          patch_app_file("config/application.rb",
+                         "class Application < Rails::Application",
+                         <<-RUBY)
+                          class Application < Rails::Application
+                            config.middleware.insert_after("Rack::Lock", "Reflexive::Application")
+          RUBY
+        end
+
+        it "properly" do
+          Dir.chdir($app_dir) do
+            IO.read("config/application.rb").should include("Reflexive")
+          end
+        end
+
+        describe "and runs application" do
+          before(:all) do
+            Dir.chdir($app_dir) do
+              spawn_server_and_wait_for_response("rails server")
+            end
+          end
+
+          it_should_behave_like "fresh Rails app with Reflexive installed"
+
+          after(:all) do
+            terminate_server_blocking
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rails_integration_spec_helper.rb

@@ -0,0 +1,115 @@
+require "fileutils"
+require "reflexive"
+require "open-uri"
+
+def sh(*args)
+  require File.expand_path("../shell_out", __FILE__)
+  shell_out_args = args.dup
+  options = shell_out_args.pop if shell_out_args[-1].is_a?(Hash)
+  shell_out_args << { :raise_exceptions => true,
+                      :verbose => true }.merge(options || {})
+  ShellOut(*shell_out_args)
+end
+
+def tmp_gemset_env
+  { "GEM_HOME" => $tmp_gemdir,
+    "GEM_PATH" => $tmp_gemdir }  
+end
+
+def sh_in_tmp_gemset(cmd, options = {})
+  sh(tmp_gemset_env, cmd, options)
+end
+
+$purge_at_exit = []
+
+at_exit do
+  for dir in $purge_at_exit
+    FileUtils::Verbose.rm_rf(dir)
+  end
+end
+
+def mktmpdir(prefix)
+  tmp_dir = Dir.mktmpdir
+  $purge_at_exit << tmp_dir.dup
+  tmp_dir
+end
+
+def gem_repository_option
+  gem_repository_path = File.expand_path("../../tmp/gem_repository", __FILE__)
+  
+  if File.directory?(gem_repository_path)
+    "--source file://#{ gem_repository_path }"
+  else
+    ""
+  end
+end
+
+def bootstrap_gem_environment(*args)
+  $tmp_gemdir = mktmpdir("reflexive_test_gemset") 
+  while name = args.shift
+    version = args.shift
+    sh_in_tmp_gemset "gem install #{ name } --version='#{ version }' " <<
+                     "--no-update-sources --quiet #{ gem_repository_option }"
+  end
+end
+
+def make_tmp_gemset_name
+  t = Time.now.strftime("%Y%m%d")
+  "reflexive_test_gemset_#{t}_#{$$}_#{rand(0x100000000).to_s(36)}"
+end
+
+def build_and_install_test_gem
+  Dir.chdir(File.expand_path("../../", __FILE__)) do
+    sh({ "GEM_VERSION" => "9.9.9" }, "gem build reflexive.gemspec")
+    begin
+      sh_in_tmp_gemset("gem install reflexive-9.9.9.gem --quiet")
+    ensure
+      File.delete("reflexive-9.9.9.gem")
+    end
+  end
+end
+
+def spawn_server_and_wait_for_response(cmd)
+  $server_pid = spawn(tmp_gemset_env, cmd)
+  puts "Spawned server with #{ $server_pid } PID"
+  tries = 0
+  print "Waiting for server to start..."
+  started = false
+  while (tries += 1) < 10 && !started
+  started = get("/").include?("Welcome aboard") rescue false
+  print "."
+  sleep 1
+  end
+  print "\n"
+  abort "Failed to start server" unless started
+end
+
+def terminate_server_blocking
+  puts "Terminating server with #{ $server_pid } PID..."
+  `kill -9 #{ $server_pid }`
+  Process::waitpid2($server_pid)
+end
+
+def get(path)
+  open("http://localhost:3000#{ path }").read
+end
+
+def create_rails_app(version)
+  unless $tmp_dir # one dir is enough
+    $tmp_dir = mktmpdir("reflexive_test_rails_apps")
+  end
+  
+  $app_dir = File.join($tmp_dir, "reflexive_test_rails#{ version }_app")
+  
+  Dir.chdir($tmp_dir) do
+    sh_in_tmp_gemset("rails reflexive_test_rails#{ version }_app")
+  end
+end
+
+def patch_app_file(path, pattern, replacement)
+  Dir.chdir($app_dir) do
+    contents = IO.read(path)
+    contents.sub!(pattern, replacement)
+    File.open(path, "w") { |f| f.write(contents) }
+  end
+end

data/spec/reflexive_ripper_spec.rb

@@ -0,0 +1,351 @@
+require "reflexive/reflexive_ripper"
+
+Rspec::Matchers.define :have_scopes do |*expected_scopes|
+  match do |actual_scanner_events|
+    @actual_scopes = actual_scanner_events.
+                       map { |e| e[:meta_scope] }.compact
+    @actual_scopes == expected_scopes
+  end
+
+  failure_message_for_should do |actual_scanner_events|
+    "expected that scanner events: #{ actual_scanner_events } \n" <<
+            "(with scopes:                #{ @actual_scopes }) \n" <<
+            "would have following scopes: #{ expected_scopes[0] }"
+  end
+end
+
+Rspec::Matchers.define :have_tags do |*expected_tags|
+  match do |actual_scanner_events|
+    @actual_tags = actual_scanner_events.map { |e| e[:tags] }.compact
+    (expected_tags - @actual_tags).empty?
+  end
+
+  failure_message_for_should do |actual_scanner_events|
+    "expected that scanner events: #{ actual_scanner_events } \n" <<
+            "(with tags:                #{ @actual_tags }) \n" <<
+            "would have following tags: #{ expected_tags }"
+  end
+end
+
+Rspec::Matchers.define :have_exact_tags do |*expected_tags|
+  match do |actual_scanner_events|
+    @actual_tags = actual_scanner_events.map { |e| e[:tags] }.compact
+    expected_tags == @actual_tags  
+  end
+
+  failure_message_for_should do |actual_scanner_events|
+    "expected that scanner events: #{ actual_scanner_events } \n" <<
+            "(with tags:                #{ @actual_tags }) \n" <<
+            "would have exact tags: #{ expected_tags[0] }"
+  end
+end
+
+describe Reflexive::ReflexiveRipper do
+  def scanner_events_for(source)
+    parser = Reflexive::ReflexiveRipper.new(source)
+    parser.parse
+    parser.scanner_events
+  end
+
+  it "collects scanner events as hashes" do
+    scanner_events_for("a = 42").should == [
+            {:ident=>"a", :tags=>{:local_variable_assignment=>"1:a"}},
+            {:sp=>" "}, {:op=>"="}, {:sp=>" "}, {:int=>"42"}
+    ]
+  end
+
+  describe "injects method call scanner event tags" do
+    specify "m!" do
+      scanner_events_for("m!").should(have_tags(
+              {:method_call=>{:name=>"m!", :receiver=>[], :scope => []}}
+      ))
+    end
+
+    specify "A.b!()" do
+      scanner_events_for("A.b!").should(have_tags(
+              {:method_call=>{:name=>"b!", :receiver=>["A"], :scope => []}}
+      ))
+    end
+
+    specify "A::B.c!()" do
+      scanner_events_for("A::B.c!()").should(have_tags(
+              {:method_call=>{:name=>"c!", :receiver=>["A::B"], :scope => []}}
+      ))
+    end
+
+    specify "module A; B.c!(); end" do
+      scanner_events_for("module A; B.c!(); end").should(have_tags(
+              {:method_call=>{:name=>"c!", :receiver=>["B"], :scope => ["A"]}}
+      ))
+    end
+  end
+
+  describe "injects local variable assignment event tags" do
+    specify "v = 1" do
+      scanner_events_for("a = 42").should(have_tags(
+              :local_variable_assignment=>"1:a"))
+    end
+
+    specify "def m(arg) end" do
+      scanner_events_for("def m(arg); end").should(have_tags(
+              :local_variable_assignment=>"2:arg"))
+    end
+
+    specify "a, b = 1, 2" do
+      scanner_events_for("a, b = 1, 2").should(have_tags(
+              {:local_variable_assignment=>"1:a"},
+              {:local_variable_assignment=>"1:b"}))
+    end
+
+    specify "a, b, *c, d = 1, 2" do
+      scanner_events_for("a, b, *c, d = 1, 2").should(have_tags(
+              {:local_variable_assignment=>"1:a"},
+              {:local_variable_assignment=>"1:b"},
+              {:local_variable_assignment=>"1:c"},
+              {:local_variable_assignment=>"1:d"}
+      ))
+    end
+
+    specify "1.tap { (dv = 1).tap { puts dv } }" do
+      scanner_events_for("1.tap { (dv = 1).tap { puts dv } }").should(have_exact_tags(
+              {:local_variable_assignment=>"2:dv"},
+              {:method_call=>{:name=>"puts", :receiver=>[], :scope => []}},
+              {:local_variable_access=>"2:dv"}
+      ))
+    end
+
+    specify "1.tap { x = 1; 1.tap { puts x } }" do
+      scanner_events_for("1.tap { x = 1; 1.tap { puts x } }").should(have_tags(
+              {:local_variable_assignment=>"2:x"},
+              {:local_variable_assignment=>"2:x"}))
+    end
+
+    specify "tv = 1; def m; puts tv; end" do
+      scanner_events_for("tv = 1; def m; puts tv; end").should(have_tags(
+              {:local_variable_assignment=>"1:tv"},
+              {:method_call=>{:name=>"puts", :receiver=>[:instance], :scope => []}},
+              {:method_call=>{:name=>"tv", :receiver=>[:instance], :scope => []}}))
+    end
+
+  end
+
+  describe "scope handling" do
+    describe "for method calls" do
+      specify "from top level" do
+        scanner_events_for("m()").should(have_tags(
+              {:method_call=>{:name=>"m", :receiver=>[], :scope => []}}))
+      end
+
+      specify "class definition level" do
+        scanner_events_for("class C; cm(); end").should(have_tags(
+              {:method_call=>{:name=>"cm", :receiver=>["C"], :scope => ["C"]}}))
+        scanner_events_for("module M; cm(); end").should(have_tags(
+              {:method_call=>{:name=>"cm", :receiver=>["M"], :scope => ["M"]}}))
+      end
+
+      specify "class instance level" do
+        scanner_events_for("class C; def im1; im2; end end").should(have_tags(
+              {:method_call=>{:name=>"im2", :receiver=>["C", :instance], :scope => ["C"]}}))
+        scanner_events_for("module M; def im1; im2; end end").should(have_tags(
+              {:method_call=>{:name=>"im2", :receiver=>["M", :instance], :scope => ["M"]}}))
+      end
+
+      specify "class singleton level" do
+        scanner_events_for("class C; def self.cm1() cm2; end end").should(have_tags(
+              {:method_call=>{:name=>"cm2", :receiver=>["C"], :scope => ["C"]}}))
+        scanner_events_for("module M; def self.cm1() cm2; end end").should(have_tags(
+              {:method_call=>{:name=>"cm2", :receiver=>["M"], :scope => ["M"]}}))
+      end
+
+      pending "nested method calls with constant references" do
+        src = <<-RUBY
+          module M
+            class C
+              def self.m
+              end
+            end
+          end
+          class M::C
+            def m
+              c = C.m
+            end
+          end
+        RUBY
+      end
+    end
+
+    describe "for constant references" do
+      specify "top level" do
+        scanner_events_for("C").should(have_tags(
+              :constant_access=>{:name=>"C", :scope=>[]}
+        ))
+      end
+
+      specify "path" do
+        scanner_events_for("A::B").should(have_tags(
+              {:constant_access=>{:name=>"A", :scope=>[]}},
+              {:constant_access=>{:name=>"A::B", :scope=>[]}}
+        ))
+        scanner_events_for("A::B::C").should(have_tags(
+              {:constant_access=>{:name=>"A", :scope=>[]}},
+              {:constant_access=>{:name=>"A::B", :scope=>[]}},
+              {:constant_access=>{:name=>"A::B::C", :scope=>[]}}
+        ))
+      end
+
+      specify "top path" do
+        scanner_events_for("::A::B").should(have_tags(
+              {:constant_access=>{:name=>"::A::B", :scope=>[]}}
+        ))
+      end
+
+      specify "nested" do
+        scanner_events_for("module A; module B; C; end end").should(have_tags(
+              {:constant_access=>{:name=>"A", :scope=>[]}},
+              {:constant_access=>{:name=>"B", :scope=>["A"]}},
+              {:constant_access=>{:name=>"C", :scope=>["A", "B"]}}
+        ))
+        scanner_events_for("module A; class B; C; end end").should(have_tags(
+              {:constant_access=>{:name=>"A", :scope=>[]}},
+              {:constant_access=>{:name=>"B", :scope=>["A"]}},
+              {:constant_access=>{:name=>"C", :scope=>["A", "B"]}}
+        ))
+      end
+
+      specify "combined (nested with path)" do
+        scanner_events_for("module M; C::D; end").should(have_tags(
+                {:constant_access=>{:name=>"M", :scope=>[]}},
+                {:constant_access=>{:name=>"C", :scope=>["M"]}},
+                {:constant_access=>{:name=>"C::D", :scope=>["M"]}}
+        ))
+      end
+
+      specify "combined (nested with top level)" do
+        scanner_events_for("module M; ::C::D; end").should(have_tags(
+              {:constant_access=>{:name=>"M", :scope=>[]}},
+              {:constant_access=>{:name=>"::C::D", :scope=>["M"]}}
+        ))
+      end
+
+      specify "from instance methods" do
+        scanner_events_for("def m; C; end").should(have_tags(
+              {:constant_access=>{:name=>"C", :scope=>[]}}
+        ))
+
+      end
+    end
+  end
+
+  describe "injects scope meta events" do
+    example "simple class def" do
+      scanner_events_for("class C; end").should(
+        have_scopes(["C"], []))
+    end
+
+    example "nested class def" do
+      scanner_events_for("class C; class D; end end").should(
+        have_scopes(["C"], ["C", "D"], ["C"], []))
+    end
+
+    example "class inside module def" do
+      scanner_events_for("module M; class C; end end").should(
+              have_scopes(["M"], ["M", "C"], ["M"], []))
+    end
+
+    it "handles const_path_ref" do
+      scanner_events_for("class Const::PathRef < ::TopConstRef; end").should(
+              have_scopes(["Const::PathRef"], []))
+    end
+
+    it "handles top_const_ref" do
+      scanner_events_for("class ::TopConstRef; end").should(
+              have_scopes(["::TopConstRef"], []))
+    end
+  end
+
+  #  describe "injects require/load argument tag" do
+  #    specify "require" do
+  #      scanner_events_for("require 'f'").should(have_tags(
+  #          {:local_variable_assignment=>"1:tv"}
+  #      ))
+  #    end
+  #  end
+
+  it "shouldn't get confused with non-scope changing const refs" do
+    scanner_events_for("v = :class; SomeConst = 123").should(
+              have_scopes())
+  end
+
+  it "should handle complex arbitrary nesting" do
+    src = <<-RUBY
+      class TC
+        def m
+        end
+      end
+
+      module M1
+        def m
+        end
+
+        module M2
+          def m
+          end
+          class C1
+
+          end
+          class C1
+            def m
+            end
+          end
+        end
+
+        class C3
+          def m
+          end
+        end
+
+      end
+
+      module M1::M2
+        class C4
+          module M4
+            def m
+            end
+          end
+
+          class C5
+            module M3
+            end
+            class C6
+            end
+          end
+        end
+      end
+    RUBY
+    scanner_events_for(src).should(
+              have_scopes(["TC"],
+                           [], 
+                           ["M1"],
+                           ["M1", "M2"],
+                           ["M1", "M2", "C1"],
+                           ["M1", "M2"],
+                           ["M1", "M2", "C1"],
+                           ["M1", "M2"],
+                           ["M1"],
+                           ["M1", "C3"],
+                           ["M1"],
+                           [],
+                           ["M1::M2"],
+                           ["M1::M2", "C4"],
+                           ["M1::M2", "C4", "M4"],
+                           ["M1::M2", "C4"],
+                           ["M1::M2", "C4", "C5"],
+                           ["M1::M2", "C4", "C5", "M3"],
+                           ["M1::M2", "C4", "C5"],
+                           ["M1::M2", "C4", "C5", "C6"],
+                           ["M1::M2", "C4", "C5"],
+                           ["M1::M2", "C4"],
+                           ["M1::M2"],
+                           []))
+  end
+end

data/spec/reflexive_spec.rb

@@ -0,0 +1,98 @@
+require "reflexive/helpers"
+require "reflexive/constantize"
+require "reflexive/descendants"
+
+describe "Reflexive.loaded_features_lookup" do
+  before(:all) do
+    @native_feature = $LOADED_FEATURES.detect { |f| f =~ /\.so\z/ }
+    @ruby_feature = $LOADED_FEATURES.detect { |f| f =~ /\.rb\z/ }
+    raise "Can't setup test: need at least one native and ruby feature loaded" unless @native_feature && @ruby_feature 
+  end
+  
+  it "doesn't looks up native features" do
+    Reflexive.loaded_features_lookup(@native_feature).should == nil
+  end
+
+  it "looks up ruby features when passed feature basename" do
+    ruby_feature_basename = File.basename(@ruby_feature)
+    Reflexive.loaded_features_lookup(ruby_feature_basename).should == @ruby_feature
+  end
+  
+  it "looks up ruby features when passed feature basename and path part" do
+    feature_dirname = File.dirname(@ruby_feature)
+    feature_basename = File.basename(@ruby_feature)
+    feature_name = File.join(feature_dirname.split("/").last(2).join("/"),
+                             feature_basename) 
+    Reflexive.loaded_features_lookup(feature_name).should == @ruby_feature
+  end
+
+  it "looks up ruby features when passed feature basename without extension" do
+    ruby_feature_basename = File.basename(@ruby_feature).sub(/\.\w+\z/, "")
+    Reflexive.loaded_features_lookup(ruby_feature_basename).should == @ruby_feature
+  end
+end
+
+describe "Reflexive.constant_lookup" do
+  module M1
+    class C1
+    end
+    module M2
+      module M3
+        class C2
+        end
+      end
+    end
+  end
+
+  it "looks up top-level constants" do
+    Reflexive.constant_lookup("::String", "Some::Ignored::Scope").should == ::String
+  end
+
+  it "returns nil for non existing top-level constant" do
+    Reflexive.constant_lookup("::StringAsd", "Some::Ignored::Scope").should == nil
+  end
+
+  it "looks up top-level constants without scope" do
+    Reflexive.constant_lookup("String", "").should == ::String
+  end
+
+  it "looks up non top-level constants with scope" do
+    Reflexive.constant_lookup("C1", "M1").should == ::M1::C1
+    Reflexive.constant_lookup("C2", "M1::M2::M3").should == ::M1::M2::M3::C2
+  end
+
+  it "returns nil for non existing non top-level constants with scope" do
+    Reflexive.constant_lookup("CNotExist", "M1").should == nil
+  end
+end
+
+describe "Reflexive.load_path_lookup" do
+  it "looks up features present in $LOAD_PATH" do
+    feature = nil
+    $LOAD_PATH.each { |p| break if (feature = Dir["#{ p }/*.rb"].first) }
+    feature_basename = File.basename(feature).sub(/\.\w+\z/, "")
+    Reflexive.load_path_lookup(feature_basename).should == feature
+  end
+end
+
+describe "Reflexive.descendants" do
+  class X2 ; end
+  class A2 < X2; end
+  class B2 < X2; end
+
+  module M2
+  end
+
+  class C2
+  end
+
+  C2.extend(M2)
+  
+  it "finds class descendant" do
+    Reflexive.descendants(X2).should =~ [B2, A2]
+  end
+
+  it "finds singleton class descendant" do
+    Reflexive.descendants(M2).should =~ [C2]
+  end
+end