rdl 1.0.0.rc1

data/types/rails-tmp/devise_contracts.rb

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

data/types/ruby-2.2.0/_aliases.rb

@@ -0,0 +1,4 @@
+type_alias '%real', 'Integer or Float or Rational'
+type_alias '%string', '[to_str: () -> String]'
+type_alias '%path', '%string or Pathname'
+type_alias '%open_args', '{external_encoding: ?String, internal_encoding: ?String, encoding: ?String, textmode: ?%any, binmode: ?%any, autoclose: ?%any, mode: ?String}'

data/types/ruby-2.2.0/abbrev.rb

@@ -0,0 +1,5 @@
+module Abbrev
+  nowrap
+
+  type 'self.abbrev', '(Array<String>) -> Hash<String,String>'
+end

data/types/ruby-2.2.0/array.rb

@@ -0,0 +1,137 @@
+class Array
+  nowrap
+
+  type_params [:t], :all?
+  
+  type :<<, '(t) -> Array<t>'
+  type :[], '(Range<Fixnum>) -> Array<t>'
+  type :[], '(Fixnum or Float) -> t'
+  type :[], '(Fixnum, Fixnum) -> Array<t>'
+  type :&, '(Array<u>) -> Array<t>'
+  type :*, '(Fixnum) -> Array<t>'
+  type :*, '(String) -> String'
+  type :+, '(Enumerable<u>) -> Array<u or t>'
+  type :-, '(Array<u>) -> Array<u or t>'
+  type :slice, '(Range<Fixnum>) -> Array<t>'
+  type :slice, '(Fixnum) -> t'
+  type :slice, '(Fixnum, Fixnum) -> Array<t>'
+  type :[]=, '(Fixnum, t) -> t'
+  type :[]=, '(Fixnum, Fixnum, t) -> t'
+  #type :[]=, '(Fixnum, Fixnum, Array<t>) -> Array<t>'
+  #type :[]=, '(Range, Array<t>) -> Array<t>'
+  type :[]=, '(Range<Fixnum>, t) -> t'
+  type :assoc, '(t) -> Array<t>'
+  type :at, '(Fixnum) -> t'
+  type :clear, '() -> Array<t>'
+  type :map, '() {(t) ->u} -> Array<u>'
+  type :map, '() -> Enumerator<t>'
+  type :map!, '() {(t) ->u} -> Array<u>'
+  type :map!, '() -> Enumerator<t>'
+  type :collect, '() { (t) -> u } -> Array<u>'
+  type :collect, '() -> Enumerator<t>'
+  type :combination, '(Fixnum) { (Array<t>) -> %any } -> Array<t>'
+  type :combination, '(Fixnum) -> Enumerator<t>'
+  type :push, '(?t) -> Array<t>'
+  type :compact, '() -> Array<t>'
+  type :compact!, '() -> Array<t>'
+  type :concat, '(Array<t>) -> Array<t>'
+  type :count, '() -> Fixnum'
+  type :count, '(t) -> Fixnum'
+  type :count, '() { (t) -> %bool } -> Fixnum'
+  type :cycle, '(?Fixnum) { (t) -> %any } -> %any'
+  type :cycle, '(?Fixnum) -> Enumerator<t>'
+  type :delete, '(u) -> t'
+  type :delete, '(u) { () -> v } -> t or v'
+  type :delete_at, '(Fixnum) -> Array<t>'
+  type :delete_if, '() { (t) -> %bool } -> Array<t>'
+  type :delete_if, '() -> Enumerator<t>'
+  type :drop, '(Fixnum) -> Array<t>'
+  type :drop_while, '() { (t) -> %bool } -> Array<t>'
+  type :drop_while, '() -> Enumerator<t>'
+  type :each, '() -> Enumerator<t>'
+  type :each, '() { (t) -> %any } -> Array<t>'
+  type :each_index, '() { (Fixnum) -> %any } -> Array<t>'
+  type :each_index, '() -> Enumerator<t>'
+  type :empty?, '() -> %bool'
+  type :fetch, '(Fixnum) -> t'
+  type :fetch, '(Fixnum, u) -> u'
+  type :fetch, '(Fixnum) { (Fixnum) -> u } -> t or u'
+  type :fill, '(t) -> Array<t>'
+  type :fill, '(t,Fixnum,?Fixnum) -> Array<t>'
+  type :fill, '(t, Range<Fixnum>) -> Array<t>'
+  type :fill, '() { (Fixnum) -> t } -> Array<t>'
+  type :fill, '(Fixnum, ?Fixnum) { (Fixnum) -> t } -> Array<t>'
+  type :fill, '(Range<Fixnum>) { (Fixnum) -> t } -> Array<t>'
+  type :flatten, '() -> Array<%any>' # Can't give a more precise type
+  type :index, '(u) -> Fixnum'
+  type :index, '() { (t) -> %bool } -> Fixnum'
+  type :index, '() -> Enumerator<t>'
+  type :first, '() -> t'
+  type :first, '(Fixnum) -> Array<t>'
+  type :include?, '(u) -> %bool'
+  type :insert, '(Fixnum, *t) -> Array<t>'
+  type :inspect, '() -> String'
+  type :join, '(?String) -> String'
+  type :keep_if, '() { (t) -> %bool } -> Array<t>'
+  type :last, '() -> t'
+  type :last, '(Fixnum) -> Array<t>'
+  type :member, '(u) -> %bool'
+  type :length, '() -> Fixnum'
+  type :permutation, '(?Fixnum) -> Enumerator<t>'
+  type :permutation, '(?Fixnum) { (Array<t>) -> %any } -> Array<t>'
+  type :pop, '(Fixnum) -> Array<t>'
+  type :pop, '() -> t'
+  type :product, '(*Array<u>) -> Array<Array<t or u>>'
+  type :rassoc, '(u) -> t'
+  type :reject, '() { (t) -> %bool } -> Array<t>'
+  type :reject, '() -> Enumerator<t>'
+  type :reject!, '() { (t) -> %bool } -> Array<t>'
+  type :reject!, '() -> Enumerator<t>'
+  type :repeated_combination, '(Fixnum) { (Array<t>) -> %any } -> Array<t>'
+  type :repeated_combination, '(Fixnum) -> Enumerator<t>'
+  type :repeated_permutation, '(Fixnum) { (Array<t>) -> %any } -> Array<t>'
+  type :repeated_permutation, '(Fixnum) -> Enumerator<t>'
+  type :reverse, '() -> Array<t>'
+  type :reverse!, '() -> Array<t>'
+  type :reverse_each, '() { (t) -> %any } -> Array<t>'
+  type :reverse_each, '() -> Enumerator<t>'
+  type :rindex, '(u) -> t'
+  type :rindex, '() { (t) -> %bool } -> Fixnum'
+  type :rindex, '() -> Enumerator<t>'
+  type :rotate, '(?Fixnum) -> Array<t>'
+  type :rotate!, '(?Fixnum) -> Array<t>'
+  type :sample, '() -> t'
+  type :sample, '(Fixnum) -> Array<t>'
+  type :select, '() { (t) -> %bool } -> Array<t>'
+  type :select, '() -> Enumerator<t>'
+  type :select!, '() { (t) -> %bool } -> Array<t>'
+  type :select!, '() -> Enumerator<t>'
+  type :shift, '() -> t'
+  type :shift, '(Fixnum) -> Array<t>'
+  type :shuffle, '() -> Array<t>'
+  type :shuffle!, '() -> Array<t>'
+  rdl_alias :size, :length
+  rdl_alias :slice, :[]
+  type :slice!, '(Range<Fixnum>) -> Array<t>'
+  type :slice!, '(Fixnum, Fixnum) -> Array<t>'
+  type :slice!, '(Fixnum or Float) -> t'
+  type :sort, '() -> Array<t>'
+  type :sort, '() { (t,t) -> Fixnum } -> Array<t>'
+  type :sort!, '() -> Array<t>'
+  type :sort!, '() { (t,t) -> Fixnum } -> Array<t>'
+  type :sort_by!, '() { (t) -> u } -> Array<t>'
+  type :sort_by!, '() -> Enumerator<t>'
+  type :take, '(Fixnum) -> Array<t>'
+  type :take_while, '() { (t) ->%bool } -> Array<t>'
+  type :take_while, '() -> Enumerator<t>'
+  type :to_a, '() -> Array<t>'
+  type :to_ary, '() -> Array<t>'
+  rdl_alias :to_s, :inspect
+  type :transpose, '() -> Array<t>'
+  type :uniq, '() -> Array<t>'
+  type :uniq!, '() -> Array<t>'
+  type :unshift, '(*t) -> Array<t>'
+  type :values_at, '(*Range<Fixnum> or Fixnum) -> Array<t>'
+  type :zip, '(*Array<u>) -> Array<Array<t or u>>'
+  type :|, '(Array<u>) -> Array<t or u>'
+end

data/types/ruby-2.2.0/base64.rb

@@ -0,0 +1,10 @@
+module Base64
+  nowrap
+
+  type 'self.decode64', '(String) -> String'
+  type 'self.encode64', '(String) -> String'
+  type 'self.strict_decode64', '(String) -> String'
+  type 'self.strict_encode64', '(String) -> String'
+  type 'self.urlsafe_decode64', '(String) -> String'
+  type 'self.urlsafe_encode64', '(String) -> String'
+end

data/types/ruby-2.2.0/basic_object.rb

@@ -0,0 +1,13 @@
+class BasicObject
+  nowrap
+  type :==, '(%any other) -> %bool'
+  type :equal?, '(%any other) -> %bool'
+  type :!, '() -> %bool'
+  type :!=, '(%any other) -> %bool'
+  type :instance_eval, '(String, ?String filename, ?Fixnum lineno) -> %any'
+  type :instance_eval, '() { () -> %any } -> %any'
+  type :instance_exec, '(*%any args) { (*%any) -> %any } -> %any'
+  type :__send__, '(Symbol, *%any) -> %any obj'
+  rdl_alias :__id__, :object_id
+  type :object_id, '() -> Fixnum'
+end

data/types/ruby-2.2.0/benchmark.rb

@@ -0,0 +1,11 @@
+module Benchmark
+  nowrap
+
+  type 'self.benchmark', '(String, ?Fixnum, ?String, *String) -> Array<Benchmark::Tms>'
+  type 'self.bm', '(?Fixnum, *String) { (Benchmark::Process) -> nil} -> Array<Benchmark::Tms>'
+  #type 'self.benchmark', '(Caption: String, Label_Width: ?Fixnum, Format: ?String, Labels: *String) -> Benchmark::Tms'
+  #type 'self.bm', '(Label_Width: ?Fixnum, Labels: *String) { (Benchmark::Process) -> nil} -> Array<Benchmark::Tms>'
+  type 'self.bmbm', '(?Fixnum label_width) { (Benchmark::Process) -> nil} -> Array<Benchmark::Tms>'
+  type 'self.measure', '(?String label) -> Benchmark::Tms'
+  type 'self.realtime', '() {(*%any) -> %any} -> Fixnum'
+end

data/types/ruby-2.2.0/bigdecimal.rb

@@ -0,0 +1,15 @@
+class BigDecimal
+  nowrap
+  
+  #type 'self._load', '()'
+  type 'self.double_fig', '() -> Fixnum'
+  type 'self.limit', '(Fixnum) -> Fixnum'
+  type 'self.mode', '(Fixnum mode, ?(%bool or Symbol) value) -> Fixnum'
+  #type 'self.new', '(Integer or Float or Rational or BigDecimal or String, Fixnum) -> BigDecimal'
+  type 'self.save_exception_mode', '() { (*%any) -> %any } -> %any'
+  type 'self.save_limit', '() { (*%any) -> %any } -> %any'
+  type 'self.save_rounding_mode', '() { (*%any) -> %any } -> %any'
+  type 'self.ver', '() -> String'
+  
+  # TODO
+end

data/types/ruby-2.2.0/bigmath.rb

@@ -0,0 +1,12 @@
+module BigMath
+  nowrap
+
+  type 'self.exp', '(Fixnum, Fixnum) -> BigDecimal'
+  type 'self.log', '(Fixnum, Fixnum) -> BigDecimal'
+  type :E, '(Fixnum) -> BigDecimal'
+  type :PI, '(Fixnum) -> BigDecimal'
+  type :atan, '(Fixnum, Fixnum) -> BigDecimal'
+  type :cos, '(Fixnum, Fixnum) -> BigDecimal'
+  type :sin, '(Fixnum, Fixnum) -> BigDecimal'
+  type :sqrt, '(Fixnum, Fixnum) -> BigDecimal'
+end

data/types/ruby-2.2.0/class.rb

@@ -0,0 +1,17 @@
+class Class
+  nowrap
+  
+  type 'allocate', '() -> %any' # Instance of class self
+  type 'inherited', '(Class) -> %any'
+  #type 'initialize', '() -> '
+  #type 'new', '(*%any) -> %any' #Causes two other test cases to fail
+  type 'superclass', '() -> Class or nil'
+  
+  #  type :class_eval, '() {() -> %any} -> %any'
+  #  type :method_defined?, '(String or Symbol) -> %bool'
+  #  type :define_method, '(String or Symbol) {(*%any) -> %any} -> Proc'
+  type :instance_methods, '(?%bool) -> Array<Symbol>'
+  type :class, '() -> Class'
+  type :superclass, '() -> Class'
+  type :name, '() -> String'
+end