rdl 1.0.0.rc1

data/lib/rdl_types.rb

@@ -0,0 +1,2 @@
+require_rel "../types/ruby-#{RUBY_VERSION}/_aliases.rb" # load type aliases first
+require_rel "../types/ruby-#{RUBY_VERSION}/*.rb"

data/types/other/chronic.rb

@@ -0,0 +1,5 @@
+module Chronic
+  class << self
+    type(:parse, "(String) -> ActiveSupport::TimeWithZone")
+  end
+end

data/types/other/paperclip_attachment.rb

@@ -0,0 +1,7 @@
+module Paperclip
+end
+
+class Paperclip::Attachment
+  type(:path, "() -> String")
+  type(:path, "(Symbol) -> String")
+end

data/types/other/securerandom.rb

@@ -0,0 +1,4 @@
+module SecureRandom
+  type('self.base64', '(?Fixnum) -> String')
+  type('self.hex', '(?Fixnum) -> String')
+end

data/types/rails-4.2.1/fixnum.rb

@@ -0,0 +1,3 @@
+class Fixnum
+  type :*, '(ActiveSupport::Duration) -> ActiveSupport::Duration'
+end

data/types/rails-4.2.1/string.rb

@@ -0,0 +1,3 @@
+class String
+  type :html_safe, '() -> String'
+end

data/types/rails-tmp/action_dispatch.rb

@@ -0,0 +1,406 @@
+module RailsHelper
+  class << self
+    attr_accessor :namespace
+    attr_accessor :resources_stack
+    attr_accessor :inside_member
+  end
+
+  def self.get_path_helper(name)
+    stack = RailsHelper.resources_stack.map {|e| e.to_s.singularize}
+    resources_str = stack.join("_")
+    method_prefix = resources_str == "" ? "#{name}" : "#{name}_#{resources_str}" 
+    :"#{method_prefix}_path"
+  end
+
+  def self.get_resource_info(controller, action)
+    controller_s = controller.singularize
+    controller_c = controller_s.camelize
+
+    case action
+    when :new
+      v = [/^GET$/]
+      p = "/#{controller_s}/new"
+      prefix = "#{controller_s}"
+      pht = "() -> String"
+    when :create
+      v = [/^POST$/]
+      p = "/#{controller_s}"
+      prefix = "#{controller_s}"
+      pht = "() -> String"
+    when :show
+      v = [/^GET$/]
+      p = "/#{controller_s}"
+      prefix = "#{controller_s}"
+      pht = "() -> String"
+    when :edit
+      v = [/^GET$/]
+      p = "/#{controller_s}/edit"
+      prefix = "edit_#{controller_s}"
+      pht = "() -> String"
+    when :update
+      v = [/^PUT$/, /^PATCH$/]
+      p = "/#{controller_s}"
+      prefix = "#{controller_s}"
+      pht = "() -> String"
+    when :destroy
+      v = [/^DELETE$/]
+      p = "/#{controller_s}"
+      prefix = "#{controller_s}"
+      pht = "() -> String"
+    else
+      raise Exception, "invalid action #{action.inspect}"
+    end
+
+    ph = "#{prefix}_path".to_sym
+    uh = "#{prefix}_url".to_sym
+    uht = pht
+    {:verb => v, :path => p, :path_helper => [ph, pht], :url_helper => [uh, uht]}
+  end
+
+  def self.get_resources_info(controller, action)
+    controller_s = controller.singularize
+    controller_c = controller_s.camelize
+    n = RailsHelper.namespace.to_s
+    nnh = (n == "" ? "" : "#{n}_")
+
+    case action
+    when :index
+      v = [/^GET$/]
+      p = "/#{controller}"
+      prefix = "#{nnh}#{controller}"
+      pht = "() -> String"
+    when :new
+      v = [/^GET$/]
+      p = "/#{controller}/new"
+
+      if n == ""
+        prefix = "#{controller_s}"
+      else
+        prefix = "new_#{nnh}#{controller_s}"
+      end
+
+      pht = "() -> String"
+    when :create
+      v = [/^POST$/]
+      p = "/#{controller}"
+      prefix = "#{nnh}#{controller}"
+      pht = "() -> String"
+    when :show
+      v = [/^GET$/]
+      p = "/#{controller}/:id"
+      prefix = "#{nnh}#{controller_s}"
+      pht = "(#{controller_c}) -> String"
+    when :edit
+      v = [/^GET$/]
+      p = "/#{controller}/:id/edit"
+      prefix = "edit_#{nnh}#{controller_s}"
+      pht = "(#{controller_c}) -> String"
+    when :update
+      v = [/^PUT$/, /^PATCH$/]
+      p = "/#{controller}/:id"
+      prefix = "#{nnh}#{controller_s}"
+      pht = "(#{controller_c}) -> String"
+    when :destroy
+      v = [/^DELETE$/]
+      p = "/#{controller}/:id"
+      prefix = "#{nnh}#{controller_s}"
+      pht = "(#{controller_c}) -> String"
+    else
+      raise Exception, "invalid action #{action.inspect}"
+    end
+
+    p = "/#{nnh[0..-2]}#{p}" if nnh != ""
+
+    ph = "#{prefix}_path".to_sym
+    uh = "#{prefix}_url".to_sym
+    uht = pht
+    {:verb => v, :path => p, :path_helper => [ph, pht], :url_helper => [uh, uht]}
+  end
+
+  def self.resource_routes_info_valid?(routes, controller, action, options={})
+    info = get_resource_info(controller, action)
+    r_p = info[:path]
+    r_v = info[:verb]
+
+    routes.any? {|r|
+      defaults = r.app.instance_variable_get(:@defaults)
+      path = r.path.spec.to_s.split('(')[0]
+
+      if defaults
+        defaults[:controller] == controller and defaults[:action] == action.to_s and path == r_p and r_v.include?(r.verb)
+      else
+        false
+      end
+    }
+  end
+
+  def self.resources_routes_info_valid?(routes, controller, action, options={})
+    info = get_resources_info(controller, action)
+    r_p = info[:path]
+    r_v = info[:verb]
+
+    namespace = self.namespace.to_s
+    namespace == "" ? c2 = controller : c2 = "#{namespace}/#{controller}"
+
+    routes.any? {|r|
+      defaults = r.app.instance_variable_get(:@defaults)
+      path = r.path.spec.to_s.split('(')[0]
+
+      if defaults
+        defaults[:controller] == c2 and defaults[:action] == action.to_s and path == r_p and r_v.include?(r.verb)
+      else
+        false
+      end
+    }
+  end
+
+  def self.resource_routes_valid?(routes, resources_args)
+    controller = resources_args[0].to_s.pluralize
+    controller_obj = controller.pluralize.camelize + "Controller"
+    controller_obj = eval(controller_obj)
+    options = resources_args[1].nil? ? {} : resources_args[1]
+    routes = Rails.application.routes.routes.to_a
+
+    actions = [:new, :create, :show, :edit, :update, :destroy]
+
+    if options.keys.include?(:only)
+      actions = options[:only]
+    elsif options.keys.include?(:except)
+      actions = actions - options[:except]
+    end
+
+    r1 = actions.all? {|action|
+      resource_routes_info_valid?(routes, controller, action, options)
+    }
+
+    r2 = actions.all? {|action|
+      info = get_resource_info(controller, action)
+      r_ph = info[:path_helper][0]
+      r_uh = info[:url_helper][0]
+
+      path_helper_added = controller_obj.instance_methods.include?(r_ph)
+      url_helper_added = controller_obj.instance_methods.include?(r_uh)
+
+      path_helper_added and url_helper_added
+    }
+
+    r1 and r2
+  end
+
+  def self.resources_routes_valid?(routes, resources_args)
+    controller = resources_args[0].to_s
+    controller_obj = controller.camelize + "Controller"
+    controller_obj = eval(controller_obj)
+    options = resources_args[1].nil? ? {} : resources_args[1]
+    routes = Rails.application.routes.routes.to_a
+
+    actions = [:index, :new, :create, :show, :edit, :update, :destroy]
+
+    if options.keys.include?(:only)
+      actions = options[:only]
+    elsif options.keys.include?(:except)
+      actions = actions - options[:except]
+    end
+
+    r1 = actions.all? {|action|
+      resources_routes_info_valid?(routes, controller, action, options)
+    }
+
+    r2 = actions.all? {|action|
+      info = get_resources_info(controller, action)
+      r_ph = info[:path_helper][0]
+      r_uh = info[:url_helper][0]
+
+      path_helper_added = controller_obj.instance_methods.include?(r_ph)
+      url_helper_added = controller_obj.instance_methods.include?(r_uh)
+
+      path_helper_added and url_helper_added
+    }
+
+    r1 and r2
+  end
+end
+
+module ActionDispatch
+  module Routing
+    class Mapper
+      extend RDL
+
+      spec :root do
+        post_cond do |ret, *args|
+          methods = [:root_path, :root_url]
+
+          methods.all? {|m|
+            puts "ApplicationController ##% #{m} : () -> String"
+
+            #add_typesig(ApplicationController, m, "() -> String")
+            ApplicationController.instance_methods.include?(m)
+          }
+        end
+      end
+
+      spec :namespace do
+        pre_task do |*args, &blk|
+          RailsHelper.namespace = args[0]
+        end
+
+        post_task do |ret, *args, &blk|
+          RailsHelper.namespace = nil
+        end
+      end
+
+      spec :get do
+        pre_cond do |*args, &blk|
+          options = args[1] || {}
+          
+          if options.keys.include?(:to) 
+            if options[:to].class == String
+              controller = options[:to].split("#")[0]
+              controller = controller.camelize
+              action = options[:to].split("#")[1]
+
+              controller_defined = Object.const_defined?(controller)
+
+              # TODO: see if action was added. Need late binding?
+
+              controller_defined
+            else
+              true
+            end
+          else
+            true
+          end
+        end
+
+        post_cond do |ret, *args|
+          if RailsHelper.inside_member and not parent_resource.actions.include?(args[0])
+            path_helper = RailsHelper.get_path_helper(args[0])
+            ctrl = parent_resource.controller.singularize.camelize
+
+            puts "ApplicationController ##% #{path_helper} : (#{ctrl}) -> String"
+
+            add_typesig(ApplicationController, path_helper, "() -> String")
+
+            ApplicationController.instance_methods.include?(path_helper)
+          else
+            true
+          end
+        end
+      end
+
+      spec :post do
+        post_cond do |ret, *args|
+          if RailsHelper.inside_member and not parent_resource.actions.include?(args[0])
+            path_helper = RailsHelper.get_path_helper(args[0])
+            ctrl = parent_resource.controller.singularize.camelize
+
+            puts "ApplicationController ##% #{path_helper} : (#{ctrl}) -> String"
+
+            add_typesig(ApplicationController, path_helper, "() -> String")
+
+            ApplicationController.instance_methods.include?(path_helper)
+          else
+            true
+          end
+        end
+      end
+
+      spec :member do
+        pre_task do |*args|
+          RailsHelper.inside_member = true
+        end
+
+        post_task do |*args|
+          RailsHelper.inside_member = false
+        end
+      end
+      
+      spec :resource do
+        post_task do |ret, *args, &blk|
+          return true if args[0] == :session or args[0] == :password or args[0] == :registration or args[0] == :confirmation
+
+          controller = args[0].to_s
+          controller_obj = controller.pluralize.camelize + "Controller"
+          controller_obj = eval(controller_obj)
+          options = args[1] || {}
+          routes = Rails.application.routes.routes.to_a
+     
+          actions = [:new, :create, :show, :edit, :update, :destroy]
+          
+          if options.keys.include?(:only)
+            actions = options[:only]
+          elsif options.keys.include?(:except)
+            actions = actions - options[:except]
+          end
+
+          actions.each {|action|
+            info = RailsHelper.get_resource_info(controller, action)
+            r_ph = info[:path_helper]
+            r_uh = info[:url_helper]
+
+            #typesig(controller_obj, r_ph[0], r_ph[1])
+            #typesig(controller_obj, r_uh[0], r_uh[1])
+          }
+        end
+
+        post_cond do |ret, *args, &blk|
+          return true if args[0] == :session or args[0] == :password or args[0] == :registration or args[0] == :confirmation
+
+          model = args[0].to_s
+          routes = Rails.application.routes.routes.to_a
+     
+          new_routes_valid = RailsHelper.resource_routes_valid?(routes, args)
+
+          new_routes_valid
+        end
+      end
+      
+      # TODO: resources arg can also be a list
+      spec :resources do
+        pre_task do |*args, &blk|
+          RailsHelper.resources_stack = [] if not RailsHelper.resources_stack
+          RailsHelper.resources_stack.push(args[0])
+        end
+
+        post_task do |ret, *args, &blk|
+          RailsHelper.resources_stack.pop
+
+          controller = args[0].to_s
+          controller_obj = controller.camelize + "Controller"
+          controller_obj = eval(controller_obj)
+          options = args[1] || {}
+          routes = Rails.application.routes.routes.to_a
+     
+          actions = [:index, :new, :create, :show, :edit, :update, :destroy]
+          
+          if options.keys.include?(:only)
+            actions = options[:only]
+          elsif options.keys.include?(:except)
+            actions = actions - options[:except]
+          end
+
+          actions.each {|action|
+            info = RailsHelper.get_resources_info(controller, action)
+            r_ph = info[:path_helper]
+            r_uh = info[:url_helper]
+
+            puts "#{controller_obj} ##% #{r_ph[0]} : #{r_ph[1]}"
+            puts "#{controller_obj} ##% #{r_uh[0]} : #{r_uh[1]}"
+
+            #typesig(controller_obj, r_ph[0], r_ph[1])
+            #typesig(controller_obj, r_uh[0], r_uh[1])
+          }
+        end
+
+        post_cond do |ret, *args, &blk|
+          model = args[0].to_s
+          routes = Rails.application.routes.routes.to_a
+     
+          new_routes_valid = RailsHelper.resources_routes_valid?(routes, args)
+
+          new_routes_valid
+        end
+      end
+    end
+  end
+end

data/types/rails-tmp/active_record.rb

@@ -0,0 +1,406 @@
+module ActiveRecord
+  module Associations
+    module ClassMethods
+      extend RDL
+
+      def __rdl_get_arg_method_typesig(mname, arg_options)
+        if arg_options.keys.include?(:class_name)
+          c = arg_options[:class_name]
+        else
+          c = mname.to_s.singularize.camelize
+        end
+        
+        t = "() -> Array<#{c}>"
+        
+        puts "#{self} ##% #{mname} : #{t}"
+        
+        t
+      end
+
+      def __rdl_option_keys_valid?(spec_valid_options, options_used)
+        # Original class association options can be found with
+        # ActiveRecord::Associations::Builder::Association.valid_options
+        # + some more found in ancestors.
+
+        common_options = [:class_name, :foreign_key, :select, :conditions, :include, :extend, :readonly, :validate, :autosave]
+        valid_options = common_options + spec_valid_options
+        options_used.keys.all? {|k| valid_options.include?(k)}
+      end
+
+      def __rdl_arg_objects_defined?(arg_name, arg_options)
+        if arg_options.keys.include?(:class_name)
+          n = arg_options[:class_name]
+        else
+          n = arg_name.to_s.singularize.camelize
+        end
+
+        r = true
+
+        if not (arg_options.keys.include?(:polymorphic) and arg_options[:polymorphic] == true)
+          begin
+            r = eval(n).ancestors.include?(ActiveRecord::Base)
+          rescue
+            r = false
+          end
+        end
+
+        r
+
+        # TODO: Fix this, late binding?
+        true
+      end
+
+      def __rdl_collection_methods_added?(collection, arg_options)
+        cstr = collection.to_s
+        cstr_s = cstr.singularize
+        new_self_methods = [cstr, "#{cstr}=", "#{cstr_s}_ids", "#{cstr_s}_ids="]
+        new_self_methods.map! {|m| m.to_sym}
+
+        # TODO: self.new is ok to call here, but may mutate global state in certain classes
+        # The class of self.new is Array here.
+
+        collection_obj = eval("#{self}.new.#{collection.to_s}")
+
+        new_collection_methods = [:push, :concat, :build, :create, :create!, :size, :length, :count, :sum, :empty?, :clear, :delete, :delete_all, :destroy_all, :find, :exists?, :uniq, :<<]
+        # TODO: reset is also defined on obj, according to the comment in associations.rb
+        # but collection_obj.respond(:reset) returns false
+        # However, http://guides.rubyonrails.org/association_basics.html does not list :reset
+        # as well as several methods from the above as auto-generated methods.
+
+        methods_added_on_self = new_self_methods.all? {|m| 
+          self.instance_methods.include?(m)
+        }
+
+        methods_added_on_collection = new_collection_methods.all? {|m|
+          collection_obj.respond_to?(m)
+        }
+
+        methods_added_on_self and methods_added_on_collection
+
+      end
+
+      def __rdl_singular_methods_added?(type, assoc, arg_options)
+        new_methods = {}
+
+        if arg_options.keys.include?(:class_name)
+          cls = arg_options[:class_name]
+        else
+          cls = assoc.to_s.camelize
+        end
+
+        if type == :belongs_to
+          if arg_options.keys.include?(:polymorphic) and arg_options[:polymorphic] == true 
+            new_methods[:"#{assoc}"] = "(?%bool) -> #{cls}"
+            new_methods[:"#{assoc}="] = "(#{cls}) -> #{cls}"
+          else
+            new_methods[:"#{assoc}"] = "(?%bool) -> #{cls}"
+            new_methods[:"#{assoc}="] = "(#{cls}) -> #{cls}"
+            new_methods[:"build_#{assoc}"] = "(Hash) -> #{cls}"
+            new_methods[:"create_#{assoc}"] = "(Hash) -> #{cls}"
+            new_methods[:"create_#{assoc}!"] = "(Hash) -> #{cls}"
+          end
+        elsif type == :has_one
+          new_methods[:"#{assoc}"] = "(?%bool) -> #{cls}"
+          new_methods[:"#{assoc}="] = "(#{cls}) -> #{cls}"
+          new_methods[:"build_#{assoc}"] = "(Hash) -> #{cls}"
+          new_methods[:"create_#{assoc}"] = "(Hash) -> #{cls}"
+          new_methods[:"create_#{assoc}!"] = "(Hash) -> #{cls}"
+        else
+          raise Exception, "type must be a singular association"
+        end
+
+        new_methods.each {|k, v|
+          puts "#{self} ##% #{k} : #{v}"
+
+          #add_typesig(self, k, v)
+        }        
+
+        new_methods.keys.all? {|m| self.instance_methods.include?(m)}
+      end
+
+      spec :belongs_to do
+        pre_task do |*args|
+          $belongs_to_arg_name = args[0]
+
+          if args.size == 2
+            $belongs_to_arg_options = args[1].dup 
+          else
+            $belongs_to_arg_options = {}
+          end
+
+          $belongs_to_self = self      
+        end
+
+        pre_cond do |*args|
+          $belongs_to_arg_name = args[0]
+          arg_name = $belongs_to_arg_name
+
+          if args.size == 2
+            $belongs_to_arg_options = args[1].dup 
+          else
+            $belongs_to_arg_options = {}
+          end
+
+          slf = eval("self")
+          arg_options = $belongs_to_arg_options 
+
+          spec_valid_options = [:foreign_type, :polymorphic, :touch, :remote, :dependent, :counter_cache, :primary_key, :inverse_of]
+          option_keys_valid = __rdl_option_keys_valid?(spec_valid_options, arg_options)
+          arg_classes_defined = __rdl_arg_objects_defined?(arg_name, arg_options)
+
+          if arg_options.keys.include?(:foreign_key) 
+            fk = arg_options[:foreign_key]
+          else
+            fk = "#{arg_name.to_s.underscore}_id" 
+          end
+
+          col_names = slf.columns.map {|x| x.name}
+          foreign_key_col_exist = col_names.include?(fk)
+
+          counter_cache_col_exist = true
+
+          if (arg_options.keys.include?(:counter_cache) and arg_options[:counter_cache]) and not (arg_options.keys.include?(:polymorphic) and arg_options[:polymorphic])
+            if arg_options.keys.include?(:class_name)
+              assoc = arg_options[:class_name]
+            else
+              assoc = arg_name.to_s.singularize.camelize
+            end
+
+            assoc_cls = eval(assoc)
+            assoc_cols = assoc_cls.columns.map {|x| x.name}
+
+            # can specify a symbol to override default 
+            if arg_options[:counter_cache] != true
+              cid = arg_options[:counter_cache]
+            else
+              cid = "#{slf.to_s.pluralize.camelize(:lower)}_count"
+            end
+
+            counter_cache_col_exist = assoc_cols.include?(cid.to_s)            
+          end
+
+          option_keys_valid and
+          arg_classes_defined and
+          foreign_key_col_exist and
+          counter_cache_col_exist 
+        end
+
+        post_cond do |ret, *args|
+          arg_name = $belongs_to_arg_name
+          arg_options = $belongs_to_arg_options
+          slf = $belongs_to_self
+
+          correct_methods_added = __rdl_singular_methods_added?(:belongs_to, arg_name, arg_options)
+
+          if arg_options.keys.include?(:foreign_key)
+            fk = arg_options[:foreign_key]
+          else
+            fk = "#{arg_name.to_s.underscore}_id"
+          end
+
+          foreign_key_added = (slf.reflections.keys.include?(arg_name) and
+                               (slf.reflections[arg_name].foreign_key == fk))
+
+          arg_method_added = self.instance_methods.include?(args[0])
+          arg_method_typesig = __rdl_get_arg_method_typesig(args[0], arg_options)
+
+          puts "#{self} ##% #{args[0]} : #{arg_method_typesig}"
+          #add_typesig(self, args[0], arg_method_typesig)
+
+          arg_method_added and correct_methods_added and foreign_key_added
+        end
+      end
+
+      spec :has_one do
+        pre_task do |*args|
+          $has_to_arg_name = args[0]
+
+          if args.size == 2
+            $has_to_arg_options = args[1].dup 
+          else
+            $has_to_arg_options = {}
+          end
+
+          $has_to_self = self          
+        end
+
+        pre_cond do |*args|
+          $has_one_arg_name = args[0]
+          arg_name = $has_one_arg_name
+
+          if args.size == 2
+            $has_one_arg_options = args[1].dup 
+          else
+            $has_one_arg_options = {}
+          end
+
+          slf = eval("self")
+          arg_options = $has_one_arg_options 
+
+          spec_valid_options = [:order, :as, :through, :remote, :dependent, :counter_cache, :primary_key, :inverse_of]
+          option_keys_valid = __rdl_option_keys_valid?(spec_valid_options, arg_options)
+          arg_classes_defined = __rdl_arg_objects_defined?(arg_name, arg_options)          
+
+          option_keys_valid and
+          arg_classes_defined
+        end
+
+        post_cond do |ret, *args|
+          arg_name = $has_one_arg_name
+          arg_options = $has_one_arg_options
+          slf = $has_one_self
+
+          correct_methods_added = __rdl_singular_methods_added?(:has_one, arg_name, arg_options)
+
+          arg_method_added = self.instance_methods.include?(args[0])
+          arg_method_typesig = __rdl_get_arg_method_typesig(args[0], arg_options)
+
+          puts "#{self} ##% #{args[0]} : #{arg_method_typesig}"
+          
+          arg_method_added and correct_methods_added
+        end
+      end
+
+      spec :has_many do
+        pre_task do |*args|
+          $has_many_arg_name = args[0]
+
+          if args.size == 2
+            $has_many_arg_options = args[1].dup 
+          else
+            $has_many_arg_options = {}
+          end
+
+          $has_many_self = self          
+        end
+
+        pre_cond do |*args|
+          arg_name = args[0]
+
+          if args.size == 2
+            arg_options = args[1].dup 
+          else
+            arg_options = {}
+          end
+
+          slf = eval("self")
+
+          spec_valid_options = [:primary_key, :dependent, :as, :through, :source, :source_type, :inverse_of, :table_name, :order, :group, :having, :limit, :offset, :uniq, :finder_sql, :counter_sql, :before_add, :after_add, :before_remove, :after_remove]
+          option_keys_valid = __rdl_option_keys_valid?(spec_valid_options, arg_options)
+          arg_classes_defined = __rdl_arg_objects_defined?(arg_name, arg_options)
+
+          option_keys_valid and
+          arg_classes_defined
+        end
+
+        post_cond do |ret, *args|
+          arg_name = $has_many_arg_name
+          arg_options = $has_many_arg_options
+          slf = $has_many_self
+
+          correct_methods_added = __rdl_collection_methods_added?(arg_name, arg_options)
+
+          if arg_options.keys.include?(:foreign_key)
+            fk = arg_options[:foreign_key]
+          elsif arg_options.keys.include?(:as)
+            fk = arg_options[:as].to_s + "_id"
+          elsif arg_options.keys.include?(:class_name)
+            fk = arg_options[:class_name].to_s.underscore.camelize(:lower) + "_id"
+          else
+            fk = "#{slf.to_s.camelize(:lower)}_id"
+          end
+
+          foreign_key_added = (slf.reflections.keys.include?(arg_name) and
+                               (slf.reflections[arg_name].foreign_key == fk))
+
+          if arg_options.keys.include?(:foreign_key) 
+            bad_fk = arg_options[:foreign_key]
+          else
+            bad_fk = "#{arg_name.to_s.underscore}_id" 
+          end
+
+          col_names = slf.columns.map {|x| x.name}
+          bad_foreign_key_col_not_exist = (not col_names.include?(fk))
+
+          arg_method_added = self.instance_methods.include?(args[0])
+          arg_method_typesig = __rdl_get_arg_method_typesig(args[0], arg_options)
+
+          #add_typesig(self, args[0], arg_method_typesig)
+
+          puts "#{self} ##% #{args[0]} : #{arg_method_typesig}"
+
+          arg_method_added and
+          correct_methods_added and foreign_key_added and
+          bad_foreign_key_col_not_exist
+        end
+      end
+
+      spec :has_and_belongs_to_many do
+        pre_task do |*args|
+          $has_and_belongs_to_many_arg_name = args[0]
+
+          if args.size == 2
+            $has_and_belongs_to_many_arg_options = args[1].dup 
+          else
+            $has_and_belongs_to_many_arg_options = {}
+          end
+
+          $has_and_belongs_to_many_self = self          
+        end
+
+        pre_cond do |*args|
+          $has_and_belongs_to_many_arg_name = args[0]
+          arg_name = $has_and_belongs_to_many_arg_name
+
+          if args.size == 2
+            $has_and_belongs_to_many_arg_options = args[1].dup 
+          else
+            $has_and_belongs_to_many_arg_options = {}
+          end
+
+          slf = eval("self")
+          arg_options = $has_and_belongs_to_many_arg_options 
+
+          spec_valid_options = [:join_table, :association_foreign_key, :delete_sql, :insert_sql, :table_name, :order, :group, :having, :limit, :offset, :uniq, :finder_sql, :counter_sql, :before_add, :after_add, :before_remove, :after_remove]
+          option_keys_valid = __rdl_option_keys_valid?(spec_valid_options, arg_options)
+
+          arg_classes_defined = __rdl_arg_objects_defined?(arg_name, arg_options)
+          
+          option_keys_valid and
+          arg_classes_defined
+        end
+
+        post_cond do |ret, *args|
+          arg_name = $has_and_belongs_to_many_arg_name
+          arg_options = $has_and_belongs_to_many_arg_options
+          slf = $has_and_belongs_to_many_self
+
+          correct_methods_added = __rdl_collection_methods_added?(arg_name, arg_options)
+
+          if arg_options.keys.include?(:foreign_key)
+            fk = arg_options[:foreign_key]
+          elsif arg_options.keys.include?(:as)
+            fk = arg_options[:as].to_s + "_id"
+          elsif arg_options.keys.include?(:class_name)
+            fk = arg_options[:class_name].to_s.underscore.camelize(:lower) + "_id"
+          else
+            fk = "#{slf.to_s.camelize(:lower)}_id"
+          end
+
+          arg_method_added = self.instance_methods.include?(args[0])
+          arg_method_typesig = __rdl_get_arg_method_typesig(args[0], arg_options)
+
+          # this adds methods like poster_lists, owned_lists, etc
+          #add_typesig(self, args[0], arg_method_typesig)
+
+          puts "#{self} ##% #{args[0]} : #{arg_method_typesig}"
+
+          foreign_key_added = (slf.reflections.keys.include?(arg_name) and
+                               (slf.reflections[arg_name].foreign_key == fk))
+          
+          arg_method_added and correct_methods_added and foreign_key_added
+        end
+      end
+    end
+  end
+end