adsl 0.0.3 → 0.1.0

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

@@ -0,0 +1,135 @@
+require 'adsl/parser/ast_nodes'
+
+module ADSL
+  module Extract
+    module Rails
+      module CallbackChainSimulator
+
+        include ADSL::Parser
+       
+        # returns true or false if the node will render or raise, or will not render or raise
+        # returns nil if the node may or may not render or raise
+        def halting_status_of(ast_node, is_action_body = false)
+          if ast_node.is_a?(ASTBlock)
+            sub_statuses = ast_node.statements.map do |stmt|
+              sub_rs = halting_status_of stmt, is_action_body
+              return true if sub_rs
+              sub_rs
+            end
+            return nil if sub_statuses.include? nil
+            return false
+          elsif ast_node.is_a?(ASTEither)
+            sub_statuses = ast_node.blocks.map{ |block| halting_status_of block, is_action_body }
+            return false if sub_statuses.uniq == [false]
+            return true if sub_statuses.uniq == [true]
+            return nil
+          elsif ast_node.is_a?(ASTDummyStmt) and [:render, :raise].include?(ast_node.type)
+            return false if ast_node.type == :render and is_action_body
+            return true
+          else
+            return false
+          end
+        end
+
+        # returns a hash of {:will_halt => block, :will_not_halt => block}
+        def split_into_paths_that_will_or_will_not_halt(block, is_action_body = false)
+          case halting_status_of block, is_action_body
+          when true;  return { :will_halt => block, :will_not_halt => nil }
+          when false; return { :will_halt => nil,   :will_not_halt => block }
+          end
+         
+          paths = { :will_halt => [], :will_not_halt => [] }
+          block.statements.each do |stmt|
+            if stmt.is_a?(ASTBlock) && halting_status_of(stmt, is_action_body).nil?
+              possibilities = split_into_paths_that_will_or_will_not_halt stmt, is_action_body
+
+              paths[:will_halt]     << possibilities[:will_halt]
+              paths[:will_not_halt] << possibilities[:will_not_halt]
+            elsif stmt.is_a?(ASTEither) && halting_status_of(stmt, is_action_body).nil?
+              rendering_paths     = []
+              not_rendering_paths = []
+              
+              stmt.blocks.each do |subblock|
+                possibilities = split_into_paths_that_will_or_will_not_halt subblock, is_action_body
+                rendering_paths     << possibilities[:will_halt]     unless possibilities[:will_halt].nil?
+                not_rendering_paths << possibilities[:will_not_halt] unless possibilities[:will_not_halt].nil?
+              end
+
+              if rendering_paths.length == 1
+                paths[:will_halt] << rendering_paths.first
+              else
+                paths[:will_halt] << ASTEither.new(:blocks => rendering_paths)
+              end
+
+              if not_rendering_paths.length == 1
+                paths[:will_not_halt] << not_rendering_paths.first
+              else
+                paths[:will_not_halt] << ASTEither.new(:blocks => not_rendering_paths)
+              end
+            else
+              paths[:will_halt]     << stmt
+              paths[:will_not_halt] << stmt
+            end
+          end
+
+          paths[:will_halt]     = ASTBlock.new(:statements => paths[:will_halt])
+          paths[:will_not_halt] = ASTBlock.new(:statements => paths[:will_not_halt])
+
+          paths
+        end
+
+        def split_into_callbacks(root_block)
+          pairs = []
+          root_block.statements.reverse_each do |stmt|
+            if stmt.is_a? ADSL::Parser::ASTDummyStmt
+              pairs << [stmt.type, []]
+            else
+              pairs.last[1] << stmt
+            end
+          end
+          pairs.reverse!
+          pairs.length.times do |index|
+            stmts = pairs[index][1]
+            pairs[index][1] = (stmts.length == 1 ? stmts.first : ASTBlock.new(:statements => stmts.reverse))
+          end
+          
+          pairs
+        end
+
+        def interrupt_callback_chain_on_render(root_block, action_name)
+          callbacks = split_into_callbacks root_block
+
+          index = action_index = callbacks.index{ |callback_name, block| callback_name == action_name } 
+          return if index.nil?
+           
+          # skip the action and proceed to the most prior before block
+          until index < 0
+            block = callbacks[index][1]
+            render_halts = index != action_index
+
+            case halting_status_of block, !render_halts
+            when true
+              # will halt execution after this callback is done
+              callbacks = callbacks.first(index + 1)
+            when nil
+              # may render
+              paths = split_into_paths_that_will_or_will_not_halt block, !render_halts
+              what_happens_unless_renders = ASTBlock.new(:statements => callbacks[index+1..-1].map{ |c| c[1] })
+              callbacks = callbacks.first(index + 1)
+              callbacks.last[1] = ASTEither.new(:blocks => [
+                paths[:will_halt],
+                ASTBlock.new(:statements => [paths[:will_not_halt], *what_happens_unless_renders])
+              ])
+            else
+              # doesn't render, all good!
+            end
+            index -= 1
+          end
+
+          root_block.statements = callbacks.map{ |name, block| block }
+        end
+        
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require 'adsl/verification/invariant'
+require 'adsl/verification/formula_generators'
+require 'adsl/extract/rails/invariant_instrumenter'
+require 'adsl/verification/instrumentation_filter'
+
+module ADSL
+  module Extract
+    module Rails
+      class InvariantExtractor
+
+        include ADSL::Verification
+        include ADSL::Verification::FormulaGenerators
+        include ADSL::Verification::InstrumentationFilterGenerators
+
+        attr_reader :invariants
+
+        def initialize(ar_class_names)
+          @ar_class_names = ar_class_names
+          @invariants = []
+          @builder = nil
+          @stack_level = 0
+        end
+
+        def invariant(name = nil, builder)
+          @invariants << Invariant.new(:description => name, :formula => builder.adsl_ast)
+        end
+
+        def load_in_context(path)
+          file = File.open path, 'r'
+          ADSL::Extract::Rails::InvariantInstrumenter.new(@ar_class_names).instrument_and_execute_source self, file.read
+        ensure
+          file.close
+        end
+
+        def extract(param)
+          if param.is_a? Array
+            param.each do |path|
+              load_in_context path
+            end
+          else
+            ADSL::Extract::Rails::InvariantInstrumenter.new(@ar_class_names).instrument_and_execute_source self, param
+          end
+          @invariants
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+require 'adsl/extract/instrumenter'
+require 'adsl/verification/formula_generators'
+require 'adsl/extract/rails/active_record_metaclass_generator'
+
+module ADSL
+  module Extract
+    module Rails
+      class InvariantInstrumenter < ADSL::Extract::Instrumenter
+        
+        def instrument_and_execute_source object, source
+          instrumented_source = instrument_string source
+          exec_within do
+            object.instance_eval instrumented_source
+          end
+        end
+
+        def initialize(ar_class_names, *params)
+          super *params
+
+          # if a block is passed to the invariant call, add that block to the last of the parameters instead
+          replace :iter do |sexp|
+            next sexp unless (
+              sexp[1].sexp_type == :call and
+              sexp[1][1].nil? and
+              sexp[1][2] == :invariant and
+              sexp[1].last.sexp_type == :call
+            )
+
+            params_for_invariant = sexp[1][3..-1]
+            s(:call, nil, :invariant,
+              *params_for_invariant[0..-2],
+              s(:iter, params_for_invariant.last, *sexp[2..-1])
+            )
+          end
+
+          # replace and with self.and etc
+          [:and, :or].each do |operand|
+            replace operand do |sexp|
+              s(:if,
+                s(:call, nil, :respond_to?, s(:lit, operand)),
+                s(:call, s(:self), operand, *sexp.sexp_body),
+                s(operand,                  *sexp.sexp_body)
+              )
+            end
+          end
+
+          # replace not with self.not
+          replace :call do |sexp|
+            next sexp unless sexp[2] == :!
+            s(:if,
+              s(:call, nil, :respond_to?, s(:lit, :not)),
+              s(:call, s(:self), :not, sexp[1].dup),
+              sexp
+            )
+          end
+        end
+
+        def should_instrument?(object, method_name)
+          return false unless super
+
+          klass = object.class != Class ? object.class : object
+          method = object.method method_name
+          
+          klass.name.match(/^ADSL::.*$/).nil? && !(method.source_location[0] =~ /.*lib\/adsl\/.*/)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'active_support'
+require 'adsl/parser/ast_nodes'
+
+class NilClass
+  def adsl_ast
+    ::ADSL::Parser::ASTEmptyObjset.new
+  end
+end
+
+module ADSL
+  module Extract
+    module Rails
+
+      class MetaUnknown
+        def method_missing(method, *args, &block)
+          self
+        end
+
+        def respond_to?(method_name, *args, &block)
+          return true unless method_name == :adsl_ast
+        end
+
+        def to_s
+          self.class.name
+        end
+
+        def adsl_ast
+          nil
+        end
+      end
+
+      class PartiallyUnknownHash < MetaUnknown
+        def initialize(options = {})
+          @options = options
+        end
+
+        def [](arg)
+          @options[arg] || MetaUnknown.new
+        end
+
+        def []=(key, val)
+          @options[key] = val
+        end
+
+        def method_missing(method, *args, &block)
+          return @options[method] if @options.include? method
+          if method.to_s =~ /^.*=$/
+            short_method = method.to_s[0..-2].to_sym
+            return @options[short_method] if @options.include? short_method
+          end
+          super
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,211 @@
+require 'adsl/extract/rails/action_instrumenter'
+require 'adsl/extract/rails/invariant_extractor'
+require 'adsl/extract/rails/callback_chain_simulator'
+require 'adsl/extract/rails/rails_special_gem_instrumentation'
+require 'adsl/extract/rails/other_meta'
+require 'adsl/parser/ast_nodes'
+require 'adsl/util/general'
+require 'pathname'
+
+module ADSL
+  module Extract
+    module Rails
+      class RailsExtractor
+        
+        include ADSL::Extract::Rails::CallbackChainSimulator
+        include ADSL::Extract::Rails::RailsSpecialGemInstrumentation
+        
+        attr_accessor :ar_classes, :actions, :invariants, :instrumentation_filters
+
+        def initialize(options = {})
+          options = Hash[
+            :ar_classes => default_activerecord_models,
+            :invariants => Dir['invariants/**/*_invs.rb'],
+            :instrumentation_filters => []
+          ].merge options
+         
+          @ar_classes = options[:ar_classes].map do |ar_class|
+            generator = ActiveRecordMetaclassGenerator.new ar_class
+            generator.generate_class
+          end
+          
+          ar_class_names = @ar_classes.map(&:adsl_ast_class_name)
+          
+          @invariant_extractor = ADSL::Extract::Rails::InvariantExtractor.new ar_class_names
+          @invariants = @invariant_extractor.extract(options[:invariants]).map{ |inv| inv.adsl_ast }
+          @instrumentation_filters = @invariant_extractor.instrumentation_filters
+          @instrumentation_filters += options[:instrumentation_filters]
+
+          @action_instrumenter = ADSL::Extract::Rails::ActionInstrumenter.new ar_class_names
+          @action_instrumenter.instrumentation_filters = @instrumentation_filters
+          @actions = []
+          all_routes.each do |route|
+            translation = action_to_adsl_ast(route)
+            @actions << translation unless translation.nil?
+          end
+        end
+
+        def all_routes
+          ::Rails.application.routes.routes.map{ |route|
+            {
+              :request_method => request_method_for(route),
+              :url => url_for(route),
+              :controller => controller_of(route),
+              :action => action_of(route)
+            }
+          }.select{ |route|
+            !route[:action].nil? &&
+            !route[:controller].nil? &&
+            !route[:url].nil? &&
+            !route[:request_method].nil? &&
+            route[:controller].action_methods.include?(route[:action].to_s)
+          }.uniq{ |a|
+            [a[:controller], a[:action]]
+          }.sort{ |a, b| [a[:controller].to_s, a[:action]] <=> [b[:controller].to_s, b[:action]] }
+        end
+
+        def route_for(controller, action)
+          all_routes.select{ |a| a[:controller] == controller && a[:action] == action.to_sym}.first
+        end
+
+        def action_name_for(route)
+          "#{route[:controller]}__#{route[:action]}"
+        end
+
+        def callbacks(controller)
+          controller.respond_to?(:_process_action_callbacks) ? controller._process_action_callbacks : []
+        end
+
+        def prepare_instrumentation(controller_class, action)
+          controller_class.class_eval <<-ruby, __FILE__, __LINE__ + 1
+            def default_render(*args); end
+            def verify_authenticity_token; end
+            def params
+              ADSL::Extract::Rails::PartiallyUnknownHash.new(
+                :controller => '#{ controller_class.controller_name }',
+                :action => '#{ action }'
+              )
+            end
+          ruby
+
+          instrument_gems controller_class, action
+          
+          controller = controller_class.new
+          @action_instrumenter.instrument controller, action
+          callbacks(controller_class).each do |callback|
+            next if callback.filter.is_a?(String)
+            @action_instrumenter.instrument controller, callback.filter 
+          end
+        end
+
+        def action_to_adsl_ast(route)
+          instrumentation_allows = @instrumentation_filters.map do |f|
+            f.allow_instrumentation? route[:controller].new, route[:action]
+          end
+          return nil if instrumentation_allows.include? false
+
+          action_name = action_name_for route
+          potential_adsl_asts = @actions.select{ |action| action.name.text == action_name }
+          raise "Multiple actions with identical names" if potential_adsl_asts.length > 1
+          return potential_adsl_asts.first if potential_adsl_asts.length == 1
+
+          prepare_instrumentation route[:controller], route[:action]
+
+          session = ActionDispatch::Integration::Session.new(::Rails.application)
+          ::Rails.application.config.action_dispatch.show_exceptions = false
+
+          block = @action_instrumenter.exec_within do
+            @action_instrumenter.exec_within do
+              request_method = route[:request_method].to_s.downcase.split('|').first
+              session.send request_method, route[:url]
+            end
+            @action_instrumenter.abb.root_lvl_adsl_ast 
+          end
+
+          interrupt_callback_chain_on_render block, route[:action]
+
+          action = ADSL::Parser::ASTAction.new({
+            :name => ADSL::Parser::ASTIdent.new(:text => action_name),
+            :arg_cardinalities => [],
+            :arg_names => [],
+            :arg_types => [],
+            :block => block
+          })
+
+          action = action.optimize
+          action.prepend_global_variables_by_signatures /^at__.*/, /^atat__.*/
+
+          action
+        end
+
+        def default_activerecord_models
+          models_dir = Rails.respond_to?(:root) ? Rails.root.join('app', 'models') : Pathname.new('app/models')
+          classes = Dir[models_dir.join '**', '*.rb'].map{ |path|
+            relative_path = /^#{Regexp.escape models_dir.to_s}\/(.*)\.rb$/.match(path)[1]
+            klass = nil
+            while klass.nil? && !relative_path.empty?
+              begin
+                klass = relative_path.camelize.constantize
+              rescue NameError, LoadError
+              end
+              if klass.nil?
+                relative_path = /^[^\/]+\/(.*)$/.match(relative_path)[1]
+              end
+            end
+            raise "Could not find class corresponding to path #{path}" if klass.nil?
+            klass
+          }.select{ |klass| klass < ActiveRecord::Base }
+          until_no_change(classes) do |classes|
+            all = classes.dup
+            classes.each do |c|
+              all << c.superclass unless classes.include?(c.superclass) || c.superclass == ActiveRecord::Base
+            end
+            all
+          end
+        end
+
+        def controller_of(route)
+          return nil unless route.defaults.include? :controller
+          possible_names = [
+            "#{route.defaults[:controller].pluralize}_controller".camelize,
+            "#{route.defaults[:controller]}_controller".camelize, 
+          ]
+          possible_names.each do |name|
+            begin
+              return name.constantize
+            rescue NameError
+            end
+          end
+          raise "No controller class found for #{route.defaults}; attempted class names are #{possible_names}"
+        end
+
+        def action_of(route)
+          return nil unless route.defaults.include? :action
+          route.defaults[:action].to_sym
+        end
+
+        def request_method_for(route)
+          method_s = route.verb.source.match(/^\^?(.*?)\$?$/)[1]
+          return nil if method_s.empty?
+          method_s.to_sym
+        end
+
+        def url_for(route)
+          params = {}
+          route.required_parts.each do |part|
+            params[part] = 0
+          end
+          route.format(params)
+        end
+
+        def adsl_ast
+          ADSL::Parser::ASTSpec.new(
+            :classes => @ar_classes.map(&:adsl_ast),
+            :actions => @actions,
+            :invariants => @invariants
+          )
+        end
+      end
+    end
+  end
+end