rdl 2.0.0.rc2 → 2.0.0.rc3

data/types/rails-tmp/active_record.rb

@@ -1,406 +0,0 @@
-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

data/types/rails-tmp/devise_contracts.rb

@@ -1,216 +0,0 @@
-require'rdl'
-
-module MapperHelper
-  class << self
-    attr_accessor :namespace_stack
-  end
-
-  def self.devise_for_info_valid?(model, type, action, routes, path_prefix)
-    ctrl_cls = model.to_s.pluralize.camelize + "Controller"
-    ctrl_cls = eval(ctrl_cls) 
-
-    info = get_devise_for_info(model, type, action, path_prefix)
-    path_helper_method = info[:path_helper][0]
-    url_helper_method = info[:url_helper][0]
-    path_helper_method_type = info[:path_helper][0]
-    url_helper_method_type = info[:url_helper][0]
-    path = info[:path]
-    verb = info[:verb]
-    ctrl = info[:controller]
-
-    # TODO: this part should be in post_task, but need a better way to 
-    # take care of shared code?
-
-    # typesig(ctrl_cls, path_helper_method, path_helper_method_type)
-    # typesig(ctrl_cls, url_helper_method, url_helper_method_type)
-
-    route_added = routes.any? {|r|
-      defaults = r.defaults
-      route_path = r.path.spec.to_s.split('(')[0]
-
-      route_path == path and verb.include?(r.verb) and
-      defaults[:action] == action.to_s and defaults[:controller] == ctrl
-    }
-
-    ctrl_cls.instance_methods.include?(path_helper_method) and
-    ctrl_cls.instance_methods.include?(url_helper_method) and
-    route_added
-  end
-
-  def self.get_devise_for_info(model, type, action, path_prefix="")
-    # TODO: the arg types may be (*Hash), where each Hash is a user_session?
-    #       where is this defined?
-
-    model_s = model.to_s.singularize
-    model_s_c = model_s.camelize    
-
-    ns = MapperHelper.namespace_stack
-    namespace_str = ns.empty? ? "" : ns.join("_") + "_"
-    namespace_path_str = ns.empty? ? "" : ns.join("/") + "/"
-    ctrl_prefix = namespace_path_str == "" ? "devise/" : namespace_path_str
-
-    case type
-    when :session
-      case action
-      when :new
-        h = :"new_#{namespace_str}#{model_s}_session"
-        v = [/^GET$/]
-        p = "#{path_prefix}/#{model}/sign_in"
-        pht = "(?Hash) -> String"
-      when :create
-        h = :"#{namespace_str}#{model_s}_session"
-        v = [/^POST$/]
-        p = "#{path_prefix}/#{model}/sign_in"
-        pht = "(?Hash) -> String"
-      when :destroy
-        h = :"destroy_#{namespace_str}#{model_s}_session"
-        v = [/^DELETE$/]
-        p = "#{path_prefix}/#{model}/sign_out"
-        # TODO: Is there a better way to specify arg is a user session?
-        pht = "(?Hash) -> String"
-      else 
-        raise Exception, "invalid action for #{type.inspect}"
-      end
-
-      controller = "#{ctrl_prefix}sessions"
-    when :password
-      case action
-      when :new
-        h = :"new_#{namespace_str}#{model_s}_password"
-        v = [/^GET$/]
-        p = "#{path_prefix}/#{model}/password/new"
-        pht = "(?Hash) -> String"
-      when :edit
-        h = :"edit_#{namespace_str}#{model_s}_password"
-        v = [/^GET$/]
-        p = "#{path_prefix}/#{model}/password/edit"
-        pht = "(?Hash) -> String"
-      when :update
-        h = :"#{namespace_str}#{model_s}_password"
-        v = [/^PUT$/]
-        p = "#{path_prefix}/#{model}/password"
-        pht = "(?Hash) -> String"
-      when :create
-        h = :"#{namespace_str}#{model_s}_password"
-        v = [/^POST$/]
-        p = "#{path_prefix}/#{model}/password"
-        pht = "(?Hash) -> String"
-      else 
-        raise Exception, "invalid action for #{type.inspect}"
-      end
-
-      controller = "#{ctrl_prefix}passwords"
-    when :confirmation
-      case action
-      when :new
-        h = :"new_#{namespace_str}#{model_s}_confirmation"
-        v = [/^GET$/]
-        p = "#{path_prefix}/#{model}/confirmation/new"
-        pht = "(?Hash) -> String"
-      when :show
-        h = :"#{namespace_str}#{model_s}_confirmation"
-        v = [/^GET$/]
-        p = "#{path_prefix}/#{model}/confirmation"
-        pht = "(?Hash) -> String"
-      when :create
-        h = :"#{namespace_str}#{model_s}_confirmation"
-        v = [/^POST$/]
-        p = "#{path_prefix}/#{model}/confirmation"
-        pht = "(?Hash) -> String"
-      else 
-        raise Exception, "invalid action for #{type.inspect}"
-      end
-
-      controller = "#{ctrl_prefix}confirmations"
-    else
-      raise Exception, "invalid action"
-    end
-
-    ph = :"#{h}_path"
-    uh = :"#{h}_url"
-    uht = pht
-
-    {:verb => v, :path => p, :path_helper => [ph, pht], :url_helper => [uh, uht], :controller => controller}
-  end
-end
-
-module ActionDispatch::Routing
-  class Mapper
-    extend RDL
-
-    spec :namespace do
-      pre_task do |arg|
-        MapperHelper.namespace_stack = [] if not MapperHelper.namespace_stack
-        MapperHelper.namespace_stack.push(arg)
-      end
-
-      post_task do |ret, *arg|
-        MapperHelper.namespace_stack.pop
-      end
-    end
-
-    # TODO: other valid options for devise_for
-    spec :devise_for do
-      post_cond do |ret, *args|
-        model = args[0].to_s
-        model_s = model.singularize
-        model_cls = eval(model_s.camelize)
-
-        if args[-1].class == Hash and args[-1].keys.include?(:path_prefix)
-          path_prefix = "/#{args[-1][:path_prefix]}"
-        else
-          path_prefix = ""
-        end
-
-        routes = Rails.application.routes.routes.to_a
-
-        # default is session
-        actions = [:new, :create, :destroy]
-        
-        session_info_valid = actions.all? {|action|
-          MapperHelper.devise_for_info_valid?(model, :session, action, routes, path_prefix)
-        }
-
-        if model_cls.devise_modules.include?(:recoverable)
-          actions = [:new, :edit, :update, :create]
-          
-          password_info_valid = actions.all? {|action|
-            MapperHelper.devise_for_info_valid?(model, :password, action, routes, path_prefix)
-          }
-        else
-          password_info_valid = true
-        end
-
-        if model_cls.devise_modules.include?(:confirmable)
-          actions = [:new, :show, :create]
-          
-          confirmation_info_valid = actions.all? {|action|
-            MapperHelper.devise_for_info_valid?(model, :confirmation, action, routes, path_prefix)
-          }
-        else
-          confirmation_info_valid = true
-        end
-
-        ns = MapperHelper.namespace_stack
-        namespace_str = ns.empty? ? "" : ns.join("_") + "_"
-
-        helper_methods = {}
-        helper_methods[:"current_#{namespace_str}#{model_s}"] = "() -> #{model_cls}"
-        helper_methods[:"#{namespace_str}#{model_s}_signed_in?"] = "() -> %bool"
-        helper_methods[:"authenticate_#{namespace_str}#{model_s}!"] = "() -> #{model_cls}"
-        
-        helper_info_valid = helper_methods.keys.all? {|m|
-          ApplicationController.instance_methods.include?(m)
-        }
-
-        # this should be in post_task? but how to take care of shared code
-        helper_methods.each {|method, type|
-          #add_typesig(ApplicationController, method, type)
-        }
-
-        session_info_valid and password_info_valid and confirmation_info_valid and helper_info_valid
-      end
-    end
-  end
-end
-