adsl 0.0.3 → 0.1.0

data/test/unit/adsl/extract/instrumenter_test.rb

@@ -0,0 +1,103 @@
+require 'test/unit'
+require 'pp'
+require 'adsl/extract/instrumenter'
+require 'adsl/util/test_helper'
+
+class ADSL::Extract::InstrumenterTest < Test::Unit::TestCase
+  class Foo
+  end
+
+  def setup
+    Foo.class_exec do
+      def blah
+        [1, 2, 3]
+      end
+
+      def call_blah
+        blah
+      end
+
+      def repeat_blah(arg)
+        arg.times.map do
+          blah
+        end.to_a
+      end
+
+      def empty_method
+      end
+
+      def self.blah
+        [3, 2, 1]
+      end
+
+      def self.call_blah
+        self.blah
+      end
+    end
+
+    assert_equal [1, 2, 3], Foo.new.blah
+    assert_equal nil, Foo.new.empty_method
+    assert_equal [1, 2, 3], Foo.new.call_blah
+    assert_equal [[1, 2, 3], [1, 2, 3]], Foo.new.repeat_blah(2)
+  end
+
+  def teardown
+  end
+  
+  def test_execute_instrumented__blank
+    instrumenter = ADSL::Extract::Instrumenter.new
+    assert_equal [1, 2, 3], instrumenter.execute_instrumented(Foo.new, :blah)
+  end
+  
+  def test_execute_instrumented__plain_replace
+    instrumenter = ADSL::Extract::Instrumenter.new
+    
+    instrumenter.replace :lit do |sexp|
+      s(:lit, sexp[1]*2)
+    end
+
+    assert_equal [2, 4, 6], instrumenter.execute_instrumented(Foo.new, :blah)
+  end
+
+  def test_execute_instrumented__instrumentation_does_not_wreck_empty_methods
+    instrumenter = ADSL::Extract::Instrumenter.new
+    assert_equal nil, instrumenter.execute_instrumented(Foo.new, :empty_method)
+  end
+
+  def test_execute_instrumented__calls_work
+    instrumenter = ADSL::Extract::Instrumenter.new
+    assert_equal [1, 2, 3], instrumenter.execute_instrumented(Foo.new, :call_blah) 
+  end
+
+  def test_execute_instrumented__instrumentation_propagates_through_calls
+    instrumenter = ADSL::Extract::Instrumenter.new
+
+    instrumenter.replace :lit do |sexp|
+      s(:lit, sexp[1]*2)
+    end
+
+    assert_equal [2, 4, 6], instrumenter.execute_instrumented(Foo.new, :call_blah) 
+  end
+  
+  def test_execute_instrumented__instrumentation_happens_once
+    instrumenter = ADSL::Extract::Instrumenter.new
+    
+    instrumenter.replace :lit do |sexp|
+      s(:lit, sexp[1]*2)
+    end
+
+    assert_equal [[2, 4, 6]], instrumenter.execute_instrumented(Foo.new, :repeat_blah, 1)
+    assert_equal [[2, 4, 6], [2, 4, 6]], instrumenter.execute_instrumented(Foo.new, :repeat_blah, 2)
+    assert_equal [2, 4, 6], instrumenter.execute_instrumented(Foo.new, :blah)
+  end
+  
+  def test_execute_instrumented__instrumentation_propagates_through_class_level_calls
+    instrumenter = ADSL::Extract::Instrumenter.new
+
+    instrumenter.replace :lit do |sexp|
+      s(:lit, sexp[1]*2)
+    end
+
+    assert_equal [6, 4, 2], instrumenter.execute_instrumented(Foo, :call_blah) 
+  end
+end

data/test/unit/adsl/extract/meta_test.rb

@@ -0,0 +1,142 @@
+require 'test/unit'
+require 'adsl/extract/meta'
+require 'pp'
+require 'adsl/util/test_helper'
+
+class ADSL::Util::MetaTest < Test::Unit::TestCase
+  def setup
+    assert !class_defined?(:Foo, :Bar)
+  end
+
+  def teardown
+    unload_class :Foo, :Bar
+  end
+
+  def test_object__replace_method__crashes_when_no_method_exists
+    eval <<-ruby
+      class Foo; end
+    ruby
+    assert_raise do
+      Foo.new.replace_method :a, "def a; end"
+    end
+  end
+  
+  def test_object__replace_method__simple
+    eval <<-ruby
+      class Foo
+        def a; :old; end
+      end
+    ruby
+    assert_equal :old, Foo.new.a
+
+    Foo.new.replace_method :a, "def a; :new; end"
+
+    assert_equal :new, Foo.new.a
+  end
+
+  def test_object__replace_method__eigenclass
+    eval <<-ruby
+      class Foo
+        def a; :old; end
+      end
+    ruby
+
+    foo = Foo.new
+    def foo.a; :overridden; end
+
+    assert_equal :old, Foo.new.a
+    assert_equal :overridden, foo.a
+
+    foo.replace_method :a, "def a; :new; end"
+
+    assert_equal :old, Foo.new.a
+    assert_equal :new, foo.a
+  end
+
+  def test_object__replace_method__works_on_aliases
+    eval <<-ruby
+      class Foo
+        def a; :blah; end
+        alias_method :a_copy, :a
+      end
+    ruby
+
+    foo = Foo.new
+
+    assert_equal :blah, foo.a
+    assert_equal :blah, foo.a_copy
+
+    foo.replace_method :a, "def a; :kme; end"
+
+    assert_equal :kme, foo.a
+    assert_equal :kme, foo.a_copy
+  end
+
+  def test_object__replace_method__leaves_super_class_alone_if_overridden
+    eval <<-ruby
+      class Foo
+        def a; :old; end
+      end
+      class Bar < Foo
+        def a; :old; end
+      end
+    ruby
+    assert_equal :old, Foo.new.a
+    assert_equal :old, Bar.new.a
+
+    Bar.new.replace_method :a, "def a; :new; end"
+
+    assert_equal :old, Foo.new.a
+    assert_equal :new, Bar.new.a
+  end
+  
+  def test_object__replace_method__targets_superclass
+    eval <<-ruby
+      class Foo
+        def a; :old; end
+      end
+      class Bar < Foo
+      end
+    ruby
+    assert_equal :old, Foo.new.a
+    assert_equal :old, Bar.new.a
+
+    Bar.new.replace_method :a, "def a; :new; end"
+
+    assert_equal :new, Foo.new.a
+    assert_equal :new, Bar.new.a
+  end
+  
+  def test_object__replace_method__targets_module
+    eval <<-ruby
+      module Foo
+        def a; :old; end
+      end
+      class Bar
+        include Foo
+      end
+    ruby
+    assert_equal :old, Bar.new.a
+
+    Bar.new.replace_method :a, "def a; :new; end"
+
+    assert_equal :new, Bar.new.a
+  end
+
+  def test_objset__replace_method__block
+    eval <<-ruby
+      class Foo
+        def a; :old; end
+      end
+    ruby
+
+    assert_equal :old, Foo.new.a
+
+    Foo.new.replace_method :a do
+      :new
+    end
+
+    assert_equal :new, Foo.new.a
+  end
+
+end

data/test/unit/adsl/extract/rails/action_block_builder_test.rb

@@ -0,0 +1,178 @@
+require 'adsl/extract/rails/action_block_builder'
+require 'adsl/extract/rails/other_meta'
+require 'adsl/parser/ast_nodes'
+
+module ADSL::Extract::Rails
+  class ActionBlockBuilderTest < Test::Unit::TestCase
+    include ADSL::Parser
+
+    def test__in_stmt_frame
+      abb = ActionBlockBuilder.new
+      
+      assert_equal([:a, :b, :d], abb.in_stmt_frame do
+        abb << :a
+        abb << :b
+        assert_equal([:c], abb.in_stmt_frame do
+          abb << :c
+        end)
+        abb << :d
+      end)
+      
+      assert_equal([:a, :b, :d], abb.in_stmt_frame do
+        abb << :a
+        abb << :b
+        assert_equal([:c], abb.in_stmt_frame do
+          abb << :c
+        end)
+        abb << :d
+      end)
+    end
+
+    def test__all_stmts_so_far
+      abb = ActionBlockBuilder.new
+      
+      abb.in_stmt_frame do
+        abb << :a
+        abb << :b
+        abb.in_stmt_frame do
+          abb << :c
+          assert_equal [:a, :b, :c], abb.all_stmts_so_far
+        end
+        abb << :d
+        assert_equal [:a, :b, :d], abb.all_stmts_so_far
+      end
+      assert abb.all_stmts_so_far.empty?
+      
+      abb.in_stmt_frame do
+        abb << :a
+        abb << :b
+        abb.in_stmt_frame do
+          abb << :c
+          assert_equal [:a, :b, :c], abb.all_stmts_so_far
+        end
+        abb << :d
+        assert_equal [:a, :b, :d], abb.all_stmts_so_far
+      end
+      assert abb.all_stmts_so_far.empty?
+    end
+
+    def test__branch_choice__no_branches
+      abb = ActionBlockBuilder.new
+      abb.explore_all_choices do
+        abb << :a
+      end
+      assert_equal [[:a]], abb.root_paths
+    end
+
+    def test__branch_choice
+      abb = ActionBlockBuilder.new
+
+      abb.explore_all_choices do
+        abb << :a
+        abb << :b
+        if abb.branch_choice 1
+          abb << :c
+          if abb.branch_choice 2
+            abb << :d
+            abb.do_return :nil
+            abb << :e
+          else
+            abb << :f
+          end
+        else
+          abb << :g
+          abb.do_return :nil
+          abb << :h
+        end
+        abb << :i
+        if abb.branch_choice 3
+          abb << :j
+        else
+          abb << :k
+        end
+        abb << :l
+      end
+
+      expected_choices = [
+        [:a, :b, :c, :d],
+        [:a, :b, :c, :f, :i, :j, :l],
+        [:a, :b, :c, :f, :i, :k, :l],
+        [:a, :b, :g]
+      ]
+
+      assert_set_equal expected_choices, abb.root_paths
+    end
+
+    def test__common_return_value
+      abb = ActionBlockBuilder.new
+      
+      assert_equal(:a, abb.explore_all_choices do
+        abb.do_return :a
+      end)
+      
+      ret_value = abb.explore_all_choices do
+        if abb.branch_choice 1
+          abb.do_return :a
+        else
+          abb.do_return :b
+        end
+      end
+
+      assert_equal ::ADSL::Extract::Rails::MetaUnknown, ret_value.class
+    end
+
+    def test__common_return_value__ignores_duplicate_nils
+      abb = ActionBlockBuilder.new
+      
+      assert_equal(nil, abb.explore_all_choices do
+        if abb.branch_choice 1
+          abb.do_return nil
+        else
+          abb.do_return nil
+        end
+      end)
+    end
+
+    def test__common_return_value__implicit
+      abb = ActionBlockBuilder.new
+      
+      assert_equal(:c, abb.explore_all_choices do
+        abb << :b
+        abb << :c
+      end)
+
+      ret_value = abb.explore_all_choices do
+        abb << :c
+        if abb.branch_choice 1
+          abb << :a
+        else
+          abb << :c
+        end
+      end
+
+      assert_equal ::ADSL::Extract::Rails::MetaUnknown, ret_value.class
+    end
+
+    def test__common_return_value__looks_at_do_return_at_not_the_actual_return_value
+      abb = ActionBlockBuilder.new
+      
+      assert_equal(:a, abb.explore_all_choices do
+        abb.do_return :a
+        abb << :b
+      end)
+    end
+    
+    def test__adsl_ast__simple
+      abb = ActionBlockBuilder.new
+      abb.explore_all_choices do
+        abb << :a
+        abb << :b
+        abb << :c
+      end
+      adsl_ast = abb.adsl_ast
+      assert_equal ASTBlock, adsl_ast.class
+      assert_equal [:a, :b, :c], adsl_ast.statements
+    end
+
+  end
+end

data/test/unit/adsl/extract/rails/action_instrumenter_test.rb

@@ -0,0 +1,68 @@
+require 'test/unit'
+require 'active_record'
+require 'ruby_parser'
+require 'ruby2ruby'
+require 'adsl/util/test_helper'
+require 'adsl/extract/rails/action_instrumenter'
+require 'adsl/extract/rails/rails_test_helper'
+require 'adsl/extract/rails/rails_instrumentation_test_case'
+
+class ADSL::Extract::ActionInstrumenterTest < ADSL::Extract::Rails::RailsInstrumentationTestCase
+
+  def test__local_instance_class_variables_differ
+    instrumenter = ADSL::Extract::Rails::ActionInstrumenter.new ar_class_names, File.join(Dir.pwd, '/test/unit').to_s
+    input_code = <<-rails
+      def blah
+        a = 1
+        @a = 2
+        @@a = 3
+        return a, @a, @@a
+      end
+    rails
+
+    Asd.class_eval input_code
+    Kme.class_eval input_code
+
+    asd, kme = Asd.new, Kme.new
+    asd_values = asd.blah
+    kme_values = instrumenter.execute_instrumented kme, :blah
+
+    assert_equal [1, 2, 3], asd_values
+    assert_equal [1, 2, 3], kme_values
+
+    assert_equal 2, asd.instance_variable_get(:@a)
+    assert_equal 3, Asd.class_variable_get(:@@a)
+
+    assert_equal 2, kme.instance_variable_get(:@a)
+    assert_equal 3, Kme.class_variable_get(:@@a)
+  end
+
+  def test__multiassign_simple
+    instrumenter = ADSL::Extract::Rails::ActionInstrumenter.new ar_class_names, File.join(Dir.pwd, '/test/unit').to_s
+    input_codes = {
+      "def blah; @a, @b, @c = 1, 2, 3; end" => [1, 2, 3],
+      "def blah; @a, @b, @c = 4, 5; end" => [4, 5, nil],
+      "def blah; @a, @b = 6, 7, 8; end" => [6, 7, nil],
+      "def call3; [8, 9, 10]; end; def blah; @a, @b, @c = call3; end" => [8, 9, 10],
+      "def call2; [11, 12]; end; def blah; @a, @b, @c = call2; end" => [11, 12, nil],
+      "def blah; @a, @b = [13, 14]; end" => [13, 14, nil],
+      "def blah; @a, @b = [[15, 16], 17]; end" => [[15, 16], 17, nil]
+    }
+    input_codes.each do |code, expected_results|
+      Asd.class_eval code
+      Kme.class_eval code
+
+      asd, kme = Asd.new, Kme.new
+      asd.blah
+      instrumenter.execute_instrumented kme, :blah
+
+      assert_equal expected_results[0], asd.instance_variable_get(:@a), code
+      assert_equal expected_results[1], asd.instance_variable_get(:@b), code
+      assert_equal expected_results[2], asd.instance_variable_get(:@c), code
+
+      assert_equal expected_results[0], kme.instance_variable_get(:@a), code
+      assert_equal expected_results[1], kme.instance_variable_get(:@b), code
+      assert_equal expected_results[2], kme.instance_variable_get(:@c), code
+    end
+  end
+end