rdl 2.0.1 → 2.1.0

data/lib/types/core-ruby-2.x/strscan.rb

@@ -1,7 +0,0 @@
-class StringScanner
-  rdl_nowrap
-
-  type :eos?, '() -> %bool'
-  type :scan, '(Regexp) -> String'
-  type :getch, '() -> String'
-end

data/lib/types/core-ruby-2.x/symbol.rb

@@ -1,29 +0,0 @@
-class Symbol
-  rdl_nowrap
-
-  type 'self.all_symbols', '() -> Array<Symbol>'
-  type :<=>, '(Symbol other) -> Fixnum or nil'
-  type :==, '(%any obj) -> %bool'
-  type :=~, '(%any obj) -> Fixnum or nil'
-  type :[], '(Fixnum idx) -> String'
-  type :[], '(Fixnum b, Fixnum n) -> String'
-  type :[], '(Range<Fixnum>) -> String'
-  type :capitalize, '() -> Symbol'
-  type :casecmp, '(Symbol other) -> Fixnum or nil'
-  type :downcase, '() -> Symbol'
-  type :empty?, '() -> %bool'
-  type :encoding, '() -> Encoding'
-  type :id2name, '() -> String'
-  type :inspect, '() -> String'
-  type :intern, '() -> self'
-  type :length, '() -> Fixnum'
-  type :match, '(%any obj) -> Fixnum or nil'
-  type :succ, '() -> Symbol'
-  rdl_alias :size, :length
-  rdl_alias :slice, :[]
-  type :swapcase, '() -> Symbol'
-  type :to_proc, '() -> Proc' # TODO proc
-  rdl_alias :to_s, :id2name
-  rdl_alias :to_sym, :intern
-  type :upcase, '() -> Symbol'
-end

data/lib/types/core-ruby-2.x/time.rb

@@ -1,68 +0,0 @@
-class Time
-  rdl_nowrap
-
-  type 'self.at', '(Time) -> Time'
-  type 'self.at', '(Numeric seconds_with_frac) -> Time'
-  type 'self.at', '(Numeric seconds, Numeric microseconds_with_frac) -> Time'
-  type 'self.gm', '(Fixnum year, ?(Fixnum or String) month, ?Fixnum day, ?Fixnum hour, ?Fixnum min, ?Numeric sec, ?Numeric usec_with_frac) -> Time'
-  type 'self.local', '(Fixnum year, ?(Fixnum or String) month, ?Fixnum day, ?Fixnum hour, ?Fixnum min, ?Numeric sec, ?Numeric usec_with_frac) -> Time'
-  rdl_alias 'self.mktime', 'self.local'
-  type 'self.new', '(?Fixnum year, ?(Fixnum or String) month, ?Fixnum day, ?Fixnum hour, ?Fixnum min, ?Numeric sec, ?Numeric usec_with_frac) -> Time'
-  type 'self.now', '() -> Time'
-  type 'self.utc', '(Fixnum year, ?(Fixnum or String) month, ?Fixnum day, ?Fixnum hour, ?Fixnum min, ?Numeric sec, ?Numeric usec_with_frac) -> Time'
-
-  type :+, '(Numeric) -> Time'
-  type :-, '(Time) -> Float'
-  type :-, '(Numeric) -> Time'
-  type :<=>, '(Time other) -> -1 or 0 or 1 or nil'
-  type :asctime, '() -> String'
-  type :ctime, '() -> String'
-  type :day, '() -> Fixnum'
-  type :dst?, '() -> %bool'
-  type :eql?, '(%any) -> %bool'
-  type :friday?, '() -> %bool'
-  type :getgm, '() -> Time'
-  type :getlocal, '(?Fixnum utc_offset) -> Time'
-  type :getutc, '() -> Time'
-  type :gmt?, '() -> %bool'
-  type :gmt_offset, '() -> Fixnum'
-  type :gmtime, '() -> self'
-  rdl_alias :gmtoff, :gmt_offset
-  type :hash, '() -> Fixnum'
-  type :hour, '() -> Fixnum'
-  type :inspect, '() -> String'
-  type :isdst, '() -> %bool'
-  type :localtime, '(?String utc_offset) -> self'
-  type :mday, '() -> Fixnum'
-  type :min, '() -> Fixnum'
-  type :mon, '() -> Fixnum'
-  type :monday?, '() -> %bool'
-  rdl_alias :month, :mon
-  type :nsec, '() -> Fixnum'
-  type :round, '(Fixnum) -> Time'
-  type :saturday, '() -> %bool'
-  type :sec, '() -> Fixnum'
-  type :strftime, '(String) -> String'
-  type :subsec, '() -> Numeric'
-  type :succ, '() -> Time'
-  type :sunday?, '() -> %bool'
-  type :thursday?, '() -> %bool'
-  type :to_a, '() -> [Fixnum, Fixnum, Fixnum, Fixnum, Fixnum, Fixnum, Fixnum, Fixnum, %bool, String]'
-  type :to_f, '() -> Float'
-  type :to_i, '() -> Numeric'
-  type :to_r, '() -> Rational'
-  type :to_s, '() -> String'
-  type :tuesday?, '() -> %bool'
-  type :tv_nsec, '() -> Numeric'
-  type :tv_sec, '() -> Numeric'
-  type :tv_usec, '() -> Numeric'
-  type :usec, '() -> Numeric'
-  type :utc, '() -> self'
-  type :utc?, '() -> %bool'
-  type :utc_offset, '() -> Fixnum'
-  type :wday, '() -> Fixnum'
-  type :wednesday?, '() -> %bool'
-  type :yday, '() -> Fixnum'
-  type :year, '() -> Fixnum'
-  type :zone, '() -> String'
-end

data/lib/types/core-ruby-2.x/uri.rb

@@ -1,20 +0,0 @@
-module URI
-  rdl_nowrap
-
-  type :decode_www_form, '(String, ?Encoding, ?String separator, %bool use_charset, %bool isindex) -> Array<[String,String]>'
-  type :decode_www_form_component, '(String, ?Encoding) -> Array<[String,String]>'
-  # type 'encode_www_form', '(Array<Array<String>>, ?) -> String' #Doublesplat
-  # type 'encode_www_form_component', '(String, ?) -> String'
-  type :extract, '(String, ?Array) { (*%any) -> %any} -> Array<String>'
-  type :join, '(*String) -> URI::HTTP'
-  type :parse, '(String) -> URI::HTTP'
-  type :regexp, '(?Array schemes) -> Array<String>' #Assume schemes are strings
-  type :scheme_list, '() -> Hash<String,Class>'
-  type :split, '(String) -> Array<String or nil>'
-
-  type :escape, '(String, *Regexp) -> String'
-  type :escape, '(String, *String) -> String'
-  type :unescape, '(*String) -> String'
-  rdl_alias :encode, :escape
-  rdl_alias :decode, :unescape
-end

data/lib/types/core-ruby-2.x/yaml.rb

@@ -1,5 +0,0 @@
-module YAML
-  rdl_nowrap
-
-  type 'self.load_file', '(String) -> Array<String>'
-end

data/lib/types/rails-5.x/_helpers.rb

@@ -1,52 +0,0 @@
-# :integer, :bigint, :float, :decimal, :numeric, :datetime, :time, :date, :binary, :boolean.
-# null allowed
-
-type_alias '%symstr', 'Symbol or String'
-
-module RDL
-  class Rails
-
-    # [+ rails_type +] is a Rails column type (:string, :integer, etc)
-    # returns a String containing an RDL type
-    def self.column_to_rdl(rails_type)
-      case rails_type
-      when :string, :text, :binary
-        return 'String'
-      when :integer
-        return 'Fixnum'
-      when :float
-        return 'Float'
-      when :decimal
-        return 'BigDecimal'
-      when :boolean
-        return '%bool'
-      when :date
-        return 'Date'
-      when :time
-        return 'Time'
-      when :datetime
-        return 'DateTime'
-      else
-        raise RuntimeError, "Unrecoganized column type #{rails_type}"
-      end
-    end
-
-    # [+ model +] is an ActiveRecord::Base subclass that has been loaded.
-    # Gets the columns_hash of the model and returns a String that can
-    # serve as the paramter list to a method that accepts any number
-    # of the model's attributes keyed by the attribute names.
-    def self.attribute_types(model)
-      args = []
-
-      model.columns_hash.each { |name, col|
-        t = column_to_rdl(col.type)
-        if col.null
-          args << "#{name}: ?#{t}"
-        else
-          args << "#{name}: ?!#{t}"
-        end
-      }
-      return args.join ','
-    end
-  end
-end

data/lib/types/rails-5.x/action_controller/mime_responds.rb

@@ -1,11 +0,0 @@
-module ActionController
-  module MimeResponds
-    type :respond_to, '(*(String or Symbol)) { (ActionController::MimeResponds::Collector) -> %any } -> Array<String> or String'
-
-    class Collector
-      Mime::EXTENSION_LOOKUP.each { |mime|
-        type :method_missing, "(#{mime[1].symbol.inspect}) { (ActionController::MimeResponds::Collector::VariantCollector) -> %any } -> %any"
-      }
-    end
-  end
-end

data/lib/types/rails-5.x/action_dispatch/routing.rb

@@ -1,10 +0,0 @@
-module ActionDispatch
-  module Routing
-    class RouteSet
-      post(:draw) { |ret|
-#        puts "Routes are: #{Rails.application.routes.named_routes.helper_names}"
-        true
-      }
-    end
-  end
-end

data/lib/types/rails-5.x/active_model/errors.rb

@@ -1,15 +0,0 @@
-class ActiveModel::Errors
-  type :clear, '() -> %any'
-  type :delete, '(%symstr) -> %any'
-  type :[], '(%symstr) -> Array<String>'
-  type :each, '() { (%symstr, String) -> %any } -> %any'
-  type :size, '() -> %integer'
-  rdl_alias :count, :size
-  type :values, '() -> Array<String>'
-  type :keys, '() -> Array<Symbol>'
-  type :empty?, '() -> %bool'
-  rdl_alias :blank?, :empty?
-  type :hash, '(?%bool full_messages) -> Hash<Symbol, String>'
-  type :add, '(%symstr, %symstr, Hash<Symbol, %any>) -> %any'
-  type :add, '(%symstr, { () -> String }, Hash<Symbol, %any>) -> %any' # TODO: combine with prev with union once supported
-end

data/lib/types/rails-5.x/active_model/validations.rb

@@ -1,5 +0,0 @@
-module ActiveModel
-  module Validations
-    type :errors, '() -> ActiveModel::Errors'
-  end
-end

data/lib/types/rails-5.x/active_record/associations.rb

@@ -1,190 +0,0 @@
-class ActiveRecord::Associations::CollectionProxy
-  type_params [:t], :all?
-
-  type :<<, '(*(t or Array<t>)) -> self'
-  type :==, '(%any) -> %bool'
-  type :any?, '() ?{ (t) -> %bool } -> %bool'
-  rdl_alias :append, :<<
-  type :build, '(Hash<Symbol, %any> or Array<Hash<Symbol, %any>>) -> self'
-  type :clear, '() -> self'
-  type :concat, '(*t) -> self'
-  type :count, '() -> %integer'
-  type :create, '(Hash<Symbol, %any> or Array<Hash<Symbol, %any>>) -> self'
-  type :create!, '(Hash<Symbol, %any> or Array<Hash<Symbol, %any>>) -> self'
-  type :delete, '(*t) -> Array<t>'
-  type :delete_all, '(?Symbol dependent) -> Array<t>'
-  type :destroy, '(*t) -> Array<t>'
-  type :destroy_all, '() -> %any'
-  type :distinct, '() -> self'
-  type :empty?, '() -> %bool'
-  type :find, '(%integer) -> t'
-  type :find, '(%integer, %integer, *%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
-  type :include?, '(t) -> %bool'
-  type :length, '() -> %integer'
-  type :load_target, '() -> %any'
-  type :loaded?, '() -> %bool'
-  type :many?, '() ?{ (t) -> %bool } -> %bool'
-  rdl_alias :new, :build
-  rdl_alias :push, :<<
-  type :reload, '() -> self'
-  type :replace, '(Array<t>) -> %any'
-  type :reset, '() -> self'
-  type :scope, '() -> ActiveRecord::Relation' # TODO fix
-  type :select, '(*Symbol) -> t'
-  type :select, '() { (t) -> %bool } -> ActiveRecord::Associations::CollectionProxy<t>'
-  type :size, '() -> %integer'
-  rdl_alias :spawn, :scope
-  type :take, '() -> t or nil'
-  type :take, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
-  type :to_ary, '() -> Array<t>'
-  rdl_alias :to_a, :to_ary
-  rdl_alias :unique, :distinct
-
-  type :first, '() -> t or nil'
-  type :first, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
-  type :second, '() -> t or nil'
-  type :second, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
-  type :third, '() -> t or nil'
-  type :third, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
-  type :fourth, '() -> t or nil'
-  type :fourth, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
-  type :fifth, '() -> t or nil'
-  type :fifth, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
-  type :forty_two, '() -> t or nil'
-  type :forty_two, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
-  type :third_to_last, '() -> t or nil'
-  type :third_to_last, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
-  type :second_to_last, '() -> t or nil'
-  type :second_to_last, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
-  type :last, '() -> t or nil'
-  type :last, '(%integer) -> ActiveRecord::Associations::CollectionProxy<t>'
-end
-
-module ActiveRecord::Associations::ClassMethods
-
-  # TODO: Check presence of methods required by, e.g., foreign_key, primary_key, etc.
-  # TODO: Check counter_cache, add to model attr_readonly_type
-
-
-  type :belongs_to, '(%symstr name, ?{ (?ActiveRecord::Base) -> %any } scope, class_name: ?%symstr, foreign_key: ?%symstr,' +
-                    'primary_key: ?%symstr, dependent: ?(:delete or :destroy), counter_cache: ?(%bool or %symstr),' +
-                    'polymorphic: ?%bool, validate: ?%bool, autosave: ?%bool, touch: ?(%bool or %symstr),' +
-                    'inverse_of: ?%symstr, optional: ?%bool, required: ?%bool, anonymous_class: ?Class) -> %any'
-
-  pre :belongs_to do |name, scope=nil, class_name: nil, foreign_key: nil, primary_key: nil,
-                      dependent: nil, counter_cache: nil, polymorphic: nil,
-                      validate: nil, autosave: nil, touch: nil, inverse_of: nil,
-                      optional: nil, required: nil, anonymous_class: nil|
-    if polymorphic
-      assoc_type = '%any' # type is data-driven, can't determine statically
-    elsif class_name
-      assoc_type = class_name.to_s.classify
-    elsif anonymous_class
-      assoc_type = anonymous_class.to_s
-    else
-      assoc_type = name.to_s.classify # camelize?
-    end
-    type name, "(?%bool force_reload) -> #{assoc_type}"
-    type "#{name}=", "(#{assoc_type}) -> #{assoc_type}"
-    unless polymorphic
-      rdl_at(:model) { |sym|
-        assoc_attribute_types = RDL::Rails.attribute_types(assoc_type.constantize)
-        type "build_#{name}", "(#{assoc_attribute_types}) -> #{assoc_type}"
-        type "create_#{name}", "(#{assoc_attribute_types}) -> #{assoc_type}"
-        type "create_#{name}!", "(#{assoc_attribute_types}) -> #{assoc_type}"
-      }
-    end
-    true
-  end
-
-  type :has_one, '(%symstr name, ?{ (?ActiveRecord::Base) -> %any } scope, class_name: ?%symstr,'+
-                 'dependent: ?(:destroy or :delete or :nullify or :restrict_with_exception or :restrict_with_error),' +
-                 'foreign_key: ?%symstr, foreign_type: ?%symstr, primary_key: ?%symstr, as: ?%symstr,' +
-                 'through: ?%symstr, source: ?%symstr, source_type: ?%symstr, validate: ?%bool, autosave: ?%bool,' +
-                 'inverse_of: ?%symstr, required: ?%bool, anonymous_class: ?Class) -> %any'
-
-  pre :has_one do |name, scope=nil, class_name: nil, dependent: nil, foreign_key: nil,
-                   foreign_type: nil, primary_key: nil, as: nil, through: nil, source: nil,
-                   source_type: nil, vadliate: nil, autosave: nil, inverse_of: nil,
-                   required: nil|
-   if as
-     assoc_type = '%any' # type is data-driven, can't determine statically
-   elsif class_name
-     assoc_type = class_name.to_s.classify
-   elsif anonymous_class # not sure this has anonymou_class
-     assoc_type = anonymous_class.to_s.classify
-   else
-     assoc_type = name.to_s.classify # camelize?
-   end
-   type name, "(?%bool force_reload) -> #{assoc_type}"
-   type "#{name}=", "(#{assoc_type}) -> #{assoc_type}"
-   unless as
-     rdl_at(:model) { |sym|
-       assoc_attribute_types = RDL::Rails.attribute_types(assoc_type.constantize)
-       type "build_#{name}", "(#{assoc_attribute_types}) -> #{assoc_type}"
-       type "create_#{name}", "(#{assoc_attribute_types}) -> #{assoc_type}"
-       type "create_#{name}!", "(#{assoc_attribute_types}) -> #{assoc_type}"
-     }
-   end
-  end
-
-  type :has_many, '(%symstr name, ?{ (?ActiveRecord::Base) -> %any } scope, class_name: ?%symstr,' +
-                  'foreign_key: ?%symstr, foreign_type: ?%symstr, primary_key: ?%symstr,' +
-                  'dependent: ?(:destroy or :delete_all or :nullify or :restrict_with_exception or :restrict_with_error),' +
-                  'counter_cache: ?(%bool or %symstr), as: ?%symstr, through: ?%symstr, source: ?%symstr,' +
-                  'source_type: ?%symstr, validate: ?%bool, inverse_of: ?%symstr, extend: ?(Module or Array<Module>))' +
-                  '?{ () -> %any } -> %any'
-
-  pre :has_many do |name, scope=nil, class_name: nil, foreign_key: nil, foreign_type: nil, primary_key: nil,
-                    dependent: nil, counter_cache: nil, as: nil, through: nil, source: nil, source_type: nil,
-                    validate: nil, inverse_of: nil, extend: nil|
-    if class_name
-      collect_type = class_name.to_s.classify
-    else
-      collect_type = name.to_s.singularize.classify
-    end
-    type name, "() -> ActiveRecord::Associations::CollectionProxy<#{collect_type}>"
-    type "#{name}=", "(Array<t>) -> ActiveRecord::Associations::CollectionProxy<#{collect_type}>" # TODO not sure of type
-    id_type = RDL::Rails.column_to_rdl(collect_type.constantize.columns_hash['id'].type) # TODO assumes id field is "id"
-    type "#{name.to_s.singularize}_ids", "() -> Array<#{id_type}>"
-    type "#{name.to_s.singularize}_ids=", "() -> Array<#{id_type}>"
-
-    true
-  end
-
-  type :has_and_belongs_to_many, '(%symstr name, ?{ (?ActiveRecord::Base) -> %any } scope, class_name: ?%symstr,' +
-                                 'join_table: ?%symstr, foreign_key: ?%symstr, association_foreign_key: ?%symstr,' +
-                                 'validate: ?%bool, autosave: ?%bool) ?{ () -> %any } -> %any'
-
-  pre :has_and_belongs_to_many do |name, scope=nil, class_name: nil, join_table: nil,
-                                  foreign_key: nil, association_foreign_key: nil,
-                                  validate: nil, autosave: nil|
-    if class_name
-      collect_type = class_name.to_s.classify
-    else
-      collect_type = name.to_s.singularize.classify
-    end
-    type name, "() -> ActiveRecord::Associations::CollectionProxy<#{collect_type}>"
-    type "#{name}=", "(Array<t>) -> ActiveRecord::Associations::CollectionProxy<#{collect_type}>" # TODO not sure of type
-    id_type = RDL::Rails.column_to_rdl(collect_type.constantize.columns_hash['id'].type) # TODO assumes id field is "id"
-    type "#{name.to_s.singularize}_ids", "() -> Array<#{id_type}>"
-    type "#{name.to_s.singularize}_ids=", "() -> Array<#{id_type}>"
-
-    # Remaining methods are from CollectionProxy
-    # TODO give these precise types for this particular model
-    # collection<<(object, ...)
-    # collection.delete(object, ...)
-    # collection.destroy(object, ...)
-    # collection.clear
-    # collection.empty?
-    # collection.size
-    # collection.find(...)
-    # collection.where(...)
-    # collection.exists?(...)
-    # collection.build(attributes = {})
-    # collection.create(attributes = {})
-    # collection.create!(attributes = {})
-    true
-  end
-
-end

data/lib/types/rails-5.x/active_record/core.rb

@@ -1,3 +0,0 @@
-module ActiveRecord::Core
-  type :==, '(%any) -> %bool'
-end

data/lib/types/rails-5.x/active_record/model_schema.rb

@@ -1,39 +0,0 @@
-module ActiveRecord
-  module ModelSchema
-    module ClassMethods
-      post(:load_schema!) { |ret| # load_schema! doesn't return anything interesting
-        columns_hash.each { |name, col|
-          t = RDL::Rails.column_to_rdl(col.type)
-          if col.null
-            # may be null; show nullability in return type
-            type name,       "() -> #{t} or nil"     # getter
-            type "#{name}=", "(#{t}) -> #{t} or nil" # setter
-            type "write_attribute", "(:#{name}, #{t}) -> %bool"
-            type "update_attribute", "(:#{name}, #{t}) -> %bool"
-            type "update_column", "(:#{name}, #{t}) -> %bool"
-          else
-            # not null; can't truly check in type system but hint via the name
-            type name,       "() -> !#{t}"                 # getter
-            type "#{name}=", "(!#{t}) -> !#{t}" # setter
-            type "write_attribute", "(:#{name}, !#{t}) -> %bool"
-            type "update_attribute", "(:#{name}, #{t}) -> %bool"
-            type "update_column", "(:#{name}, #{t}) -> %bool"
-          end
-        }
-
-        attribute_types = RDL::Rails.attribute_types(self)
-        type 'self.find_by', '(' + attribute_types + ") -> #{self} or nil"
-        type 'self.find_by!', '(' + attribute_types + ") -> #{self}"
-        type 'update', '(' + attribute_types + ') -> %bool'
-        type 'update_columns', '(' + attribute_types + ') -> %bool'
-        type 'attributes=', '(' + attribute_types + ') -> %bool'
-
-        # If called with String arguments, can't check types as precisely
-        type 'write_attribute', '(String, %any) -> %bool'
-        type 'update_attribute', '(String, %any) -> %bool'
-        type 'update_column', '(String, %any) -> %bool'
-        true
-      }
-    end
-  end
-end