adsl 0.0.3 → 0.1.0

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

@@ -0,0 +1,34 @@
+require 'test/unit'
+require 'adsl/util/test_helper'
+require 'adsl/extract/rails/active_record_metaclass_generator'
+require 'adsl/extract/rails/rails_test_helper'
+
+class ADSL::Extract::Rails::RailsInstrumentationTestCase < Test::Unit::TestCase
+  def setup
+    assert_false class_defined? :ADSLMetaAsd, :ADSLMetaKme, 'Mod::ADSLMetaBlah'
+    
+    initialize_test_context
+  end
+
+  def teardown
+    unload_class :Asd, :Kme, 'Mod::Blah'
+  end
+
+  def initialize_metaclasses
+    ADSL::Extract::Rails::ActiveRecordMetaclassGenerator.new(Asd).generate_class
+    ADSL::Extract::Rails::ActiveRecordMetaclassGenerator.new(Kme).generate_class
+    ADSL::Extract::Rails::ActiveRecordMetaclassGenerator.new(Mod::Blah).generate_class
+  end
+
+  def create_rails_extractor(invariant_string = '')
+    ADSL::Extract::Rails::RailsExtractor.new :ar_classes => ar_classes, :invariants => invariant_string
+  end
+  
+  def ar_class_names
+    ['Asd', 'Kme', 'Mod::Blah']
+  end
+
+  def ar_classes
+    ar_class_names.map(&:constantize)
+  end
+end

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

@@ -0,0 +1,120 @@
+require 'adsl/extract/rails/other_meta'
+
+module ADSL
+  module Extract
+    module Rails
+      module RailsSpecialGemInstrumentation
+
+        def instrument_gem_cancan(controller_class, action)
+          return unless klass = Object.lookup_const('CanCan::ControllerResource')
+
+          model_class_name = controller_class.controller_name.singularize.camelize
+          klass.class_eval <<-ruby, __FILE__, __LINE__
+            def name_from_controller
+              "#{ model_class_name.underscore.singularize }"
+            end
+
+            def namespace
+              [#{ model_class_name.split('::')[0..-2].map{ |a| "'#{a}'" }.join(', ') }]
+            end
+
+            def authorize_resource; end
+
+            def find_resource
+              #{ model_class_name }.find
+            end
+
+            def build_resource
+              #{ model_class_name }.new
+            end
+
+            def load_collection
+              #{ model_class_name }.where
+            end
+
+            def load_resource
+              unless skip?(:load)
+                var_name, objset = if load_instance?
+                  [instance_name.to_s, load_resource_instance]
+                else
+                  [instance_name.to_s.pluralize, load_collection]
+                end
+                ins_explore_all 'load_resource' do
+                  ins_stmt(ADSL::Parser::ASTAssignment.new(
+                    :var_name => ADSL::Parser::ASTIdent.new(:text => "at__\#{var_name}"),
+                    :objset => objset.adsl_ast
+                  ))
+                  nil
+                end
+                @controller.instance_variable_set(
+                  "@\#{ var_name }",
+                  #{ model_class_name }.new(:adsl_ast => ADSL::Parser::ASTVariable.new(
+                    :var_name => ADSL::Parser::ASTIdent.new(:text => "at__\#{var_name}")
+                  ))
+                )
+              end
+            end
+          ruby
+
+          controller_class.class_exec do
+            def authorize!(*args); end
+          end
+
+        end
+
+        def instrument_gem_ransack(controller_class, action)
+          if Object.lookup_const('RansackUI')
+            Object.lookup_const('RansackUI::ControllerHelpers').class_exec do
+              def load_ransack_search(*args); end
+            end
+          end
+
+          if Object.lookup_const('Ransack')
+            ActiveRecord::Base.class_exec do
+              def search(*args); where; end
+            end
+          end
+        end
+
+        def instrument_gem_authlogic(controller_class, action)
+          return unless Object.lookup_const('Authlogic')
+
+          # only instrument this if there is a class called User; assume that a user is the logged in entity
+          return unless Object.lookup_const('User')
+
+          Object.lookup_const('Authlogic::Session::Base').class_exec do
+            def self.find(*args)
+              ADSL::Extract::Rails::PartiallyUnknownHash.new(
+                :record => User.find
+              )
+            end
+          end
+        end
+
+        def instrument_gem_devise(controller_class, action)
+          return unless Object.lookup_const('Devise')
+          
+          Devise.mappings.values.each do |mapping|
+            role = mapping.singular
+            role_class = mapping.class_name
+            controller_class.class_eval <<-ruby
+              def authenticate_#{role}!(*args); end
+              def #{role}_signed_in?(*args); true; end
+              def current_#{role}(*args); #{role_class}.find(-1); end
+              def #{role}_session(*args); ::ADSL::Extract::MetaUnknown.new; end
+              def only_render_implemented_actions(*args); end
+            ruby
+          end
+        end
+
+        def instrument_gems(controller_class, action)
+          instrument_gem_cancan controller_class, action
+          instrument_gem_ransack controller_class, action
+          instrument_gem_authlogic controller_class, action
+          instrument_gem_devise controller_class, action
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+require 'adsl/util/general'
+require 'active_record'
+require 'action_controller'
+require 'action_view'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+ 
+ENV["RAILS_ENV"] ||= 'test'
+
+def initialize_test_context
+  Object.lookup_or_create_class('::Asd', ActiveRecord::Base).class_exec do
+    has_many :blahs, :class_name => 'Mod::Blah'
+    has_many :kmes, :through => :blahs, :source => :kme12, :dependent => :destroy
+  end
+  
+  Object.lookup_or_create_class('::Kme', Asd).class_exec do
+    belongs_to :blah, :class_name => 'Mod::Blah', :dependent => :delete
+  end
+  
+  Object.lookup_or_create_class('::Mod::Blah', ActiveRecord::Base).class_exec do
+    belongs_to :asd
+    has_one :kme12, :class_name => 'Kme', :dependent => :delete
+  end
+
+  Object.lookup_or_create_class('::ApplicationController', ActionController::Base).class_exec do
+    def respond_to
+      # allow for empty render statements, for testing purposes only
+      if block_given?
+        super
+      else
+        render :nothing => true
+      end
+    end
+
+    def render(options = {}, extra_options = nil, &block)
+      options ||= {}
+      options[:nothing] = true
+      super
+    end
+
+    # no templates exist and we do not care
+    rescue_from ActionView::MissingTemplate do; end
+  end
+
+  Object.lookup_or_create_class('::AsdsController', ApplicationController).class_exec do
+    def index;   respond_to; end
+    def show;    respond_to; end
+    def new;     respond_to; end
+
+    def create
+      a = Asd.new
+      a.save!
+      respond_to
+    end
+
+    def edit;    respond_to; end
+    def update;  respond_to; end
+    def destroy; respond_to; end
+    def nothing; respond_to; end
+
+    before_filter :before,  :only => :before_filter_action
+    before_filter :before2, :only => :before_filter_action
+    after_filter  :after,   :only => :after_filter_action
+
+    before_filter :before_nothing, :only => :nothing
+    after_filter  :after_nothing,  :only => :nothing
+
+    def before_filter_action; respond_to; end
+    def after_filter_action;  respond_to; end
+    
+    def before; end
+    def before2; end
+    def after; end
+
+    def before_nothing; end
+    def after_nothing; end
+  end
+end
+
+# Only the parts of rails we want to use
+# if you want everything, use "rails/all"
+require "action_controller/railtie"
+
+if ENV["RAILS_ENV"] == 'test'
+
+  # Define the application and configuration
+  class ADSLRailsTestApplication < ::Rails::Application
+    # configuration here if needed
+    config.assets.enabled = false
+    config.active_support.deprecation = :stderr
+    config.secret_token = 'RandomTextRequiredByARecentVersionOfRakeOrWhateverWhoCaresThisIsUsedForGemTestingOnly'
+    config.action_dispatch.show_exceptions = false
+  end
+
+  logger = Logger.new(STDOUT)
+  logger.level = Logger::ERROR
+  # silence is getting deprecated in Rails 4.0
+  # not sure why, the alternatives are not nearly as convenient
+  def logger.adsl_silence
+    old_level = self.level
+    self.level = 6
+    yield
+  ensure
+    self.level = old_level
+  end
+
+  Rails.logger = logger
+
+  ActiveRecord::Base.establish_connection(
+    :adapter => 'sqlite3',
+    :database => ':memory:',
+    :verbosity => 'quiet'
+  )
+ 
+  # Initialize the application
+  ADSLRailsTestApplication.initialize!
+  ADSLRailsTestApplication.routes.draw do
+    resources :asds do
+      collection do
+        get :nothing
+        get :before_filter_action
+        get :after_filter_action
+        get :around_filter_action
+      end
+    end
+  end
+
+  # Initialize the test activerecord schema
+  ActiveRecord::Migration.verbose = false
+  ActiveRecord::Schema.define do
+    create_table :asds do |t|
+      t.string :type
+    end
+    create_table :blahs do |t|
+      t.integer :asd_id
+    end
+  end
+end
+

data/lib/adsl/extract/sexp_utils.rb

@@ -0,0 +1,54 @@
+require 'sexp_processor'
+
+class Sexp
+  def block_replace(*search_types, &block)
+    options = search_types.last.is_a?(Hash) ? search_types.pop : {}
+    
+    propagate_to_children = true
+    if options.include?(:unless_in)
+      options[:unless_in] = Array.wrap options[:unless_in]
+      propagate_to_children = false if options[:unless_in].include?(self.sexp_type)
+    end
+
+    new = self.map do |element|
+      if propagate_to_children && element.is_a?(Sexp)
+        result = element.block_replace *search_types, options, &block
+        result = [result] unless result.class == Array
+        result
+      else
+        [element]
+      end
+    end
+    result = Sexp.from_array new.flatten(1)
+    result = block[result] if search_types.include? result.sexp_type
+    return result
+  end
+
+  def find_shallowest(search_type)
+    return [self] if sexp_type == search_type
+    self.inject([]) do |collection, subsexp|
+      collection << subsexp.find_shallowest(search_type) if subsexp.is_a?(Sexp)
+      collection
+    end.flatten(1)
+  end
+
+  def may_return_or_raise?
+    return true if sexp_type == :return
+    return true if sexp_type == :call && self[2] == :raise
+    sexp_body.each do |subsexp|
+      return true if subsexp.is_a?(Sexp) && subsexp.may_return_or_raise?
+    end
+    false
+  end
+end
+
+class Module
+  def to_sexp
+    parts = self.name.split('::')
+    sexp = s(:colon3, parts.shift.to_sym)
+    parts.each do |part|
+      sexp = s(:colon2, sexp, part.to_sym)
+    end
+    sexp
+  end
+end

data/lib/adsl/fol/first_order_logic.rb

@@ -0,0 +1,261 @@
+require 'adsl/util/general'
+require 'active_support/all'
+
+class String
+  def resolve_spass
+    self
+  end
+
+  def split_by_zero_level_comma
+    parts = []
+    sequence_beginning_index = 0
+    index = 0
+    paren_level = 0
+    while index < length
+      if self[index, 1] == '('
+        paren_level += 1
+      elsif self[index, 1] == ')'
+        paren_level -= 1
+        raise ArgumentError, 'Unmatching parenthesis' if paren_level < 0
+      elsif self[index, 1] == ',' and paren_level == 0
+        parts << self[sequence_beginning_index, index - sequence_beginning_index].strip
+        sequence_beginning_index = index + 1
+      end
+      index += 1
+    end
+    parts << self[sequence_beginning_index, length - sequence_beginning_index].strip
+    parts
+  end
+end
+
+class Symbol
+  def resolve_spass
+    to_s
+  end
+end
+
+class TrueClass
+  def resolve_spass
+    "true"
+  end
+end
+
+class FalseClass
+  def resolve_spass
+    "false"
+  end
+end
+
+module ADSL
+  module FOL
+    class Not
+      def initialize(*formulae)
+        @formulae = formulae.flatten
+        raise ArgumentError, "At least one subformula required" if @formulae.empty?
+      end
+
+      def resolve_spass
+        children = @formulae.map{ |obj| obj.resolve_spass }
+        children.delete_if{ |a| a == 'false' }
+        return 'false' if children.include? 'true'
+        return And.new(children.map{ |child| child.match('\Anot\((.*)\)\z') ? $1 : "not(#{child})" }).resolve_spass
+      end
+    end
+    
+    class And
+      attr_reader :objs
+      
+      def initialize(*objs)
+        @objs = objs.flatten
+      end
+
+      def resolve_spass
+        children = @objs.map{ |child| child.resolve_spass }
+        children = children.map{ |child| child.match('\Aand\((.*)\)\z') ? $1.split_by_zero_level_comma : child }.flatten
+        children.delete_if{ |a| a == 'true' }
+        return 'false' if children.include? 'false'
+        return 'true' if children.empty?
+        return children.first if children.length == 1
+        return "and(#{children.join(', ')})"
+      end
+    end
+
+    class Or
+      attr_reader :objs
+
+      def initialize(*objs)
+        @objs = objs.flatten
+      end
+
+      def resolve_spass
+        children = @objs.map{ |child| child.resolve_spass }
+        children = children.map{ |child| child.match('\Aor\((.*)\)\z') ? $1.split_by_zero_level_comma : child }.flatten
+        children.delete_if{ |a| a == 'false' }
+        return 'true' if children.include? 'true'
+        return 'false' if children.empty?
+        return children.first if children.length == 1
+        return "or(#{children.join(', ')})"
+      end
+    end
+    
+    class ForAll
+      def initialize(*params)
+        params = params.flatten
+        raise ArgumentError, "At least a formula required" if params.length < 1
+        @args = params.first(params.length - 1)
+        @formula = params.last
+      end
+
+      def resolve_spass
+        args = @args.map{ |obj| obj.resolve_spass }
+        formula = @formula.resolve_spass
+        return formula if args.empty?
+        return 'true' if formula == 'true'
+        return 'false' if formula == 'false'
+        "forall( [#{args.join(', ')}], #{formula})" 
+      end
+    end
+
+    class Exists
+      def initialize(*params)
+        params = params.flatten
+        raise ArgumentError, "At least a formula required" if params.length < 1
+        @args = params.first(params.length - 1)
+        @formula = params.last
+      end
+
+      def resolve_spass
+        args = @args.map{ |obj| obj.resolve_spass }
+        formula = @formula.resolve_spass
+        return formula if args.empty?
+        return 'true' if formula == 'true'
+        return 'false' if formula == 'false'
+        "exists( [#{args.join(', ')}], #{formula})" 
+      end
+    end
+    
+    class Equal
+      def initialize(*subformulae)
+        @subformulae = subformulae.flatten
+        raise ArgumentError, "At least two subformulae required" if @subformulae.length < 2
+      end
+
+      def resolve_spass
+        return @subformulae.first.resolve_spass if @subformulae.length == 1
+        combinations = []
+        (@subformulae.length-1).times do |index|
+          combinations << "equal(#{@subformulae[index].resolve_spass}, #{@subformulae[index+1].resolve_spass})"
+        end
+        return And.new(combinations).resolve_spass
+      end
+    end
+
+    class Equiv
+      def initialize(*subformulae)
+        @subformulae = subformulae.flatten
+        raise ArgumentError, "At least two subformulae required" if @subformulae.length < 2
+      end
+
+      def resolve_spass
+        subformulae = @subformulae.map{ |sub| sub.resolve_spass }
+        return subformulae.first if subformulae.length == 1
+        return And.new(subformulae).resolve_spass if subformulae.include? 'true'
+        return Not.new(subformulae).resolve_spass if subformulae.include? 'false'
+        combinations = []
+        (subformulae.length-1).times do |index|
+          combinations << "equiv(#{subformulae[index]}, #{subformulae[index+1]})"
+        end
+        return And.new(combinations).resolve_spass
+      end
+    end
+    
+    class Implies
+      def initialize(from, to)
+        @from = from
+        @to = to
+      end
+
+      def resolve_spass
+        from = @from.resolve_spass
+        to = @to.resolve_spass
+        return to if from == 'true'
+        return 'true' if from == 'false'
+        return Not.new(from).resolve_spass if to == 'false'
+        return 'true' if to == 'true'
+        return "implies(#{from}, #{to})"
+      end
+    end
+
+    class OneOf
+      def initialize(*formulae)
+        @formulae = formulae.flatten
+      end
+
+      def resolve_spass
+        return 'false' if @formulae.empty?
+        return @formulae.first.resolve_spass if @formulae.length == 1
+        return Equiv.new(Not.new(@formulae.first), @formulae.last).resolve_spass if @formulae.length == 2
+
+        substatements = []
+        @formulae.length.times do |i|
+          formulae_without_i = @formulae.first(i) + @formulae.last(@formulae.length - 1 - i)
+          substatements << Implies.new(@formulae[i], Not.new(formulae_without_i))
+        end
+        And.new(Or.new(@formulae), substatements).resolve_spass
+      end
+    end
+
+    class IfThenElse
+      def initialize(iif, tthen, eelse)
+        @iif = iif
+        @tthen = tthen
+        @eelse = eelse
+      end
+
+      def resolve_spass
+        And.new(Implies.new(@iif, @tthen), Implies.new(Not.new(@iif), @eelse)).resolve_spass
+      end
+    end
+    
+    class IfThenElseEq
+      def initialize(iif, tthen, eelse)
+        @iif = iif
+        @tthen = tthen
+        @eelse = eelse
+      end
+
+      def resolve_spass
+        And.new(Equiv.new(@iif, @tthen), Equiv.new(Not.new(@iif), @eelse)).resolve_spass
+      end
+    end
+    
+    class PairwiseEqual
+      def initialize(*list)
+        list = list.flatten
+        @list1 = list.first((list.length/2.0).ceil)
+        @list2 = list.last((list.length/2.0).floor)
+        raise ArgumentError, "Lists not of equal length: [#{@list1.join(", ")}], [#{@list2.join(", ")}]" if @list1.length != @list2.length
+      end
+
+      def resolve_spass
+        equalities = []
+        @list1.length.times do |i|
+          equalities << Equal.new(@list1[i], @list2[i])
+        end
+        return And.new(equalities).resolve_spass
+      end
+    end
+
+    # define a method for each of the above classes, starting with underscore and underscored* afterwards
+    # *see: http://api.rubyonrails.org/v2.3.8/classes/ActiveSupport/CoreExtensions/String/Inflections.html
+    self.constants.each do |klass_name|
+      instance_eval do
+        klass = FOL.const_get klass_name
+        send :define_method, "_#{klass_name.to_s.underscore}".to_sym do |*args|
+          klass.new(*args).resolve_spass
+        end
+      end
+    end
+  end
+end
+