adsl 0.0.3 → 0.1.0

data/lib/adsl/extract/instrumenter.rb

@@ -0,0 +1,206 @@
+require 'backports'
+require 'sexp_processor'
+require 'ruby_parser'
+require 'method_source'
+require 'ruby2ruby'
+require 'adsl/extract/sexp_utils'
+require 'adsl/extract/meta'
+
+module Kernel
+  def ins_call(object, method_name, *args, &block)
+    ::ADSL::Extract::Instrumenter.get_instance.execute_instrumented object, method_name, *args, &block
+  end
+end
+
+module ADSL
+  module Extract
+    class Instrumenter
+      
+      attr_reader :stack_depth, :method_locals_stack
+      attr_accessor :instrumentation_filters
+      
+      @instance = nil
+      @method_locals_stack = []
+
+      def self.get_instance()
+        @instance
+      end
+
+      def ruby_parser
+        RUBY_VERSION >= '2' ? Ruby19Parser.new : RubyParser.for_current_ruby
+      end
+
+      def self.instrumented()
+        # a dummy method injected into the AST
+      end
+
+      def method_locals
+        @method_locals_stack.last
+      end
+
+      def previous_locals
+        @method_locals_stack[-2]
+      end
+
+      def root_locals
+        @method_locals_stack.first
+      end
+
+      def exec_within
+        Instrumenter.instance_variable_set(:@instance, self) if @stack_depth == 0
+        @stack_depth += 1
+        @method_locals_stack << create_locals if respond_to? :create_locals
+
+        return yield(self)
+      ensure
+        @stack_depth -= 1
+        @method_locals_stack.pop
+        Instrumenter.instance_variable_set(:@instance, nil) if @stack_depth == 0
+      end
+
+      def mark_sexp_instrumented(sexp)
+        raise 'Already instrumented' if sexp_instrumented? sexp
+        
+        first_stmt = sexp[3]
+
+        if first_stmt[0] != :call or
+            first_stmt[1] != Instrumenter.to_sexp or
+            first_stmt[2] != :instrumented
+          new_stmt = s(:call, Instrumenter.to_sexp, :instrumented)
+          sexp.insert 3, new_stmt
+        end
+        sexp
+      end
+
+      def sexp_instrumented?(sexp)
+        first_stmt = sexp[3]
+        return (first_stmt[0] == :call and
+            first_stmt[1] == Instrumenter.to_sexp and
+            first_stmt[2] == :instrumented)
+      rescue MethodSource::SourceNotFoundError
+        return
+      end
+
+      def initialize(instrument_domain = Dir.pwd)
+        @instrument_domain = instrument_domain
+        @replacers = []
+        @stack_depth = 0
+        @method_locals_stack = []
+
+        # mark the instrumentation
+        replace :defn, :defs do |sexp|
+          mark_sexp_instrumented sexp
+        end
+
+        # make sure the instrumentation propagates through calls
+        replace :call do |sexp|
+          # expected format: s(:call, object, method_name, *args)
+          # replaced with Extract::Instrumenter.e(instrumenter_id, object, method_name, *args)
+          original_object = sexp.sexp_body[0] || s(:self)
+          original_method_name = sexp.sexp_body[1]
+          original_args = sexp.sexp_body[2..-1]
+
+          next sexp if [s(:self), nil].include? original_object and Kernel.respond_to? original_method_name
+
+          s(:call, nil, :ins_call, original_object, s(:lit, original_method_name), *original_args)
+        end
+      end
+
+      def should_instrument?(object, method_name)
+        return false if object.is_a?(Fixnum) or object.is_a?(Symbol)
+       
+        method = object.singleton_class.instance_method method_name
+
+        return false if method.source_location.nil?
+        return false if method.owner == Kernel
+        return false if @instrument_domain && !(method.source_location.first =~ /^#{@instrument_domain}.*$/)
+
+        (instrumentation_filters || []).each do |filter|
+          return false unless filter.allow_instrumentation? object, method_name
+        end
+        
+        source = method.source
+        sexp = ruby_parser.process source
+        !sexp_instrumented? sexp
+      rescue MethodSource::SourceNotFoundError
+        # sometimes this happens because the method_source gem bugs out with evals etc
+        return false
+      rescue NameError => e
+        # ghost method with no available source
+        return false
+      end
+
+      def replace(*types, &block)
+        options = types.last.is_a?(Hash) ? types.pop : {}
+        @replacers << [types, block, options]
+      end
+
+      def with_replace(*types, replacer)
+        replace *types, replacer
+        yield
+      ensure
+        @replacers.pop
+      end
+
+      def execute_instrumented(object, method_name, *args, &block)
+        self.exec_within do
+          instrument object, method_name
+          return object.send method_name, *args, &block
+        end
+      end
+
+      def convert_root_defs_into_defn(sexp)
+        sexp.sexp_type == :defs ? s(:defn, *sexp[2..-1]) : sexp
+      end
+
+      def instrument_string(source)
+        sexp = ruby_parser.process source
+        unless sexp.nil?
+          instrumented_sexp = instrument_sexp sexp
+          new_code = Ruby2Ruby.new.process instrumented_sexp
+        else
+          source
+        end
+      end
+
+      def instrument(object, method_name)
+        if should_instrument? object, method_name
+          begin
+            # this is complex because I want to avoid using .method on non-class objects
+            # because they might implement method themselves
+            method = object.singleton_class.instance_method method_name
+            
+            source = method.source
+            
+            # Ruby 2.0.0 support is in development as of writing this
+            sexp = ruby_parser.process source
+
+            unless sexp.nil?
+              sexp = convert_root_defs_into_defn sexp
+
+              instrumented_sexp = instrument_sexp sexp
+              
+              new_code = Ruby2Ruby.new.process instrumented_sexp
+
+              object.replace_method method_name, new_code
+              
+              new_code
+            else
+              source
+            end
+          rescue MethodSource::SourceNotFoundError
+          end
+        end
+      end
+
+      def instrument_sexp(sexp)
+        return nil if sexp.nil?
+        @replacers.reverse_each do |types, block, options|
+          sexp = sexp.block_replace *types, options, &block
+        end
+        sexp
+      end
+
+    end
+  end
+end

data/lib/adsl/extract/meta.rb

@@ -0,0 +1,33 @@
+require 'rubygems'
+require 'backports'
+
+class Object
+  def replace_method(method_name, source = nil, &block)
+    raise "Object #{self} of class #{self.class} does not respond to #{method_name}" unless self.respond_to? method_name, true
+    
+    im = self.singleton_class.instance_method(method_name)
+    
+    aliases = []
+    self.singleton_class.instance_methods.each do |other_name|
+      next if other_name == method_name
+      other = self.singleton_class.instance_method other_name
+      aliases << [other_name, other] if other == im
+    end
+
+    owner = im.owner
+
+    unless source.nil?
+      owner.class_eval source
+    else
+      owner.send :define_method, method_name, &block
+    end
+
+    aliases.each do |other_name, other|
+      other.owner.class_exec do
+        alias_method other_name, method_name
+      end
+    end
+
+    true
+  end
+end

data/lib/adsl/extract/rails/action_block_builder.rb

@@ -0,0 +1,233 @@
+require 'adsl/extract/rails/other_meta'
+require 'adsl/parser/ast_nodes'
+
+module ADSL
+  module Extract
+    module Rails
+
+      class ActionBlockBuilder
+
+        attr_accessor :root_paths, :stmt_frames, :branch_choices
+
+        def initialize
+          @root_paths = []
+          @stmt_frames = [[]]
+          @branch_choices = []
+          @return_values = []
+          @has_returned_or_raised = false
+        end
+
+        def push_frame; @stmt_frames << []; end
+        def pop_frame;  @stmt_frames.pop; end
+
+        def in_stmt_frame(*args)
+          push_frame
+          yield *args
+        ensure
+          return pop_frame
+        end
+
+        def included_already?(where, what)
+          return where.map{ |e| e.equal? what }.include?(true) ||
+            (
+              where.last.is_a?(ADSL::Parser::ASTObjsetStmt) &&
+              what.is_a?(ADSL::Parser::ASTObjsetStmt) &&
+              where.last.objset == what.objset
+            )
+        end
+
+        def append_stmt(stmt, options = {})
+          return stmt if @has_returned_or_raised && !options[:ignore_has_returned]
+          return stmt if included_already? @stmt_frames.last, stmt
+          @stmt_frames.last << stmt
+          stmt
+        end
+        alias_method :<<, :append_stmt
+
+        def branch_choice(if_id)
+          @branch_choices.each do |iter_if_id, choice|
+            return choice if iter_if_id == if_id
+          end
+          @branch_choices << [if_id, true]
+          true
+        end
+
+        def has_more_executions?
+          @branch_choices.each do |if_id, choice|
+            return true if choice == true
+          end
+          false
+        end
+
+        def increment_branch_choice
+          @branch_choices.pop while !@branch_choices.empty? && @branch_choices.last[1] == false
+          @branch_choices.last[1] = false unless @branch_choices.empty?
+        end
+
+        def reset
+          unless has_more_executions?
+            @root_paths = []
+            @branch_choices = []
+            @return_values = []
+          end
+          @has_returned_or_raised = false
+          @stmt_frames = [[]]
+        end
+
+        def explore_all_choices
+          while true
+            begin
+              reset
+              increment_branch_choice
+
+              return_value = yield
+           
+              do_return return_value unless @has_returned_or_raised
+            rescue Exception => e
+              #puts "Exception: #{e}"
+              #puts e.backtrace.first 20
+              #do_raise unless @has_returned_or_raised
+            ensure
+              return common_return_value unless has_more_executions?
+            end
+          end
+        end
+
+        def common_supertype_of_objsets(values)
+          return false if values.empty?
+          values.each do |value|
+            return false if value.is_a?(MetaUnknown) || !value.respond_to?(:adsl_ast)
+          end
+          adsl_asts = values.reject{ |v| v.nil? }.map(&:adsl_ast)
+          adsl_asts = adsl_asts.map{ |v| v.is_a?(ADSL::Parser::ASTObjsetStmt) ? v.objset : v }
+          adsl_asts.each do |adsl_ast|
+            return false unless adsl_ast.class.is_objset?
+            # side effects should trigger only if the selection is chosen;
+            # but the translation does not do this
+            return false if adsl_ast.objset_has_side_effects?
+          end
+
+          common_supertype = nil
+          values.each do |value|
+            next if value.nil?
+            if common_supertype.nil?
+              common_supertype = value.class
+            elsif value.class <= common_supertype
+              # all is fine
+            elsif common_supertype <= value.class
+              common_supertype = value.class
+            else
+              return false
+            end
+          end
+
+          common_supertype
+        end
+
+        def common_supertype_of_objset_arrays(values)
+          return false if values.empty?
+
+          values.each do |value|
+            return false unless value.is_a? Array
+          end
+          
+          return_value = []
+          highest_length = values.map(&:length).max
+          highest_length.times do |index|
+            ct = compatible_types(values.map{ |v| v[index] })
+            return false unless ct
+            return_value << ct
+          end
+          return_value
+        end
+
+        def common_return_value
+          uniq = @return_values.dup
+          # avoid include? because it uses :== and metaobjects override the == operator
+          if uniq.map(&:nil?).include? true
+            uniq.delete_if{ |e| e.nil? }
+            uniq << nil
+          end
+
+          if uniq.length == 1
+            uniq.first
+          elsif ct = common_supertype_of_objsets(uniq)
+            objsets = uniq.map(&:adsl_ast).map{ |r| r.is_a?(ADSL::Parser::ASTObjsetStmt) ? r.objset : r }
+            ct.new(:adsl_ast => ADSL::Parser::ASTOneOfObjset.new(:objsets => objsets))
+          elsif ct = common_supertype_of_objset_arrays(uniq)
+            highest_length = uniq.map(&:length).max
+            combined_objsets = []
+            highest_length.times do |index|
+              objsets = uniq.map{|u| u[index]}.map(&:adsl_ast).map{ |r| r.is_a?(ADSL::Parser::ASTObjsetStmt) ? r.objset : r }
+              combined_objsets << ct[index].new(:objset => ADSL::Parser::ASTOneOfObjset.new(:objsets => objsets))
+            end
+            combined_objsets
+          else
+            # append all return values to root paths
+            # cause they won't be returned and handled by the caller
+            # if an array is returned, assume the 'return 1, 2, 3' syntax
+
+            @return_values.length.times do |index|
+              Array.wrap(@return_values[index]).flatten.each do |ret_value|
+                stmt = ADSL::Extract::Rails::ActionInstrumenter.extract_stmt_from_expr ret_value
+                @root_paths[index] << stmt unless (
+                  stmt.nil? ||
+                  !stmt.class.is_statement? ||
+                  included_already?(@root_paths[index], stmt)
+                )
+              end
+            end
+            
+            ADSL::Extract::Rails::MetaUnknown.new
+          end
+        end
+
+        def all_stmts_so_far
+          stmts = []
+          @stmt_frames.each do |frame|
+            stmts += frame
+          end
+          stmts
+        end
+
+        def do_return(return_value = nil)
+          unless @has_returned_or_raised
+            @root_paths << all_stmts_so_far
+            @return_values << return_value
+            @has_returned_or_raised = true
+          end
+          return_value
+        end
+
+        def do_raise(*args)
+          unless @has_returned_or_raised
+            # appending nothing to root paths
+            @root_paths << [::ADSL::Parser::ASTDummyStmt.new(:type => :raise)]
+            @return_values << nil
+            @has_returned_or_raised = true
+          end
+          return *args
+        end
+
+        def adsl_ast
+          blocks = @root_paths.map do |root_path|
+            ::ADSL::Parser::ASTBlock.new :statements => root_path
+          end
+
+          if blocks.empty?
+            ::ADSL::Parser::ASTBlock.new :statements => []
+          elsif blocks.length == 1
+            blocks.first
+          else
+            ::ADSL::Parser::ASTBlock.new :statements => [::ADSL::Parser::ASTEither.new(:blocks => blocks)]
+          end
+        end
+
+        def root_lvl_adsl_ast
+          ::ADSL::Parser::ASTBlock.new :statements => @stmt_frames.first
+        end
+      end
+
+    end
+  end
+end