rdl 1.0.0.rc1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e35c7df4fa4c7c7852d44fb9b82226bc58f75feb
+  data.tar.gz: c6c470102b2c15ff9df545c7f824fd3a354534f9
+SHA512:
+  metadata.gz: 4093b03c90a84370d15a225f9b527786b72886bf605674673ce72a4c9fbccac39bb19b64f2b51ba087816a314b65358380f75e1f2274ec20778c5f669fff5201
+  data.tar.gz: 1d31f30746169d02e578e49e39f973f4828c6793f1a77f3cea0b623c7323e84949d94649b6f5d501136519f78238f4092bcfc9ab9f112adc98b571dae1d78020

data/lib/rails_types.rb

@@ -0,0 +1 @@
+require_rel "../types/rails-#{Rails::VERSION::STRING}/*.rb"

data/lib/rdl.rb

@@ -0,0 +1,56 @@
+require 'set'
+require 'delegate'
+require 'require_all'
+
+module RDL
+end
+
+require_relative 'rdl/config.rb'
+def RDL.config
+  yield(RDL::Config.instance)
+end
+
+# Hash from class name to method name to :pre/:post/:type to array of contracts
+# class names are strings (because they need to be manipulated in case they include ::)
+#  (class names may have Util.add_singleton_marker applied to them to indicate they're singleton classes.)
+# method names are symbols
+$__rdl_contracts = Hash.new
+
+# Map from full_method_name to number of times called when wrapped
+$__rdl_wrapped_calls = Hash.new 0
+
+# Hash from class name to array of symbols that are the class's type parameters
+$__rdl_type_params = Hash.new
+
+# Hash from class name to method name to its alias method name
+# class names are strings
+# method names are symbols
+$__rdl_aliases = Hash.new
+
+# Set of [class, method] pairs to wrap.
+# class is a string
+# method is a symbol
+$__rdl_to_wrap = Set.new
+
+# List of contracts that should be applied to the next method definition
+$__rdl_deferred = []
+
+# Create switches to control whether wrapping happens and whether
+# contracts are checked. These need to be created before rdl/wrap.rb
+# is loaded.
+require_rel 'rdl/switch.rb'
+$__rdl_wrap_switch = RDL::Switch.new
+$__rdl_contract_switch = RDL::Switch.new
+
+require_rel 'rdl/types/*.rb'
+require_rel 'rdl/contracts/*.rb'
+require_rel 'rdl/util.rb'
+require_rel 'rdl/wrap.rb'
+#require_rel 'rdl/stats.rb'
+
+$__rdl_parser = RDL::Type::Parser.new
+
+# Hash from special type names to their values
+$__rdl_special_types = {'%any' => RDL::Type::TopType.new,
+                        '%bool' => RDL::Type::UnionType.new(RDL::Type::NominalType.new(TrueClass),
+                                                            RDL::Type::NominalType.new(FalseClass)) }

data/lib/rdl/config.rb

@@ -0,0 +1,121 @@
+require 'singleton'
+
+class RDL::Config
+  include Singleton
+
+  attr_accessor :nowrap
+  attr_accessor :gather_stats
+  
+  def initialize
+    @nowrap = Set.new
+    @gather_stats = true
+  end
+
+  def add_nowrap(*klasses)
+    klasses.each { |klass| @nowrap.add klass }
+  end
+
+  def remove_nowrap(*klasses)
+    klasses.each { |klass| @nowrap.delete klass }
+  end
+  
+  # To use, copy these 3 lines to the test file of a gem
+=begin
+require_relative '../rdl3/rdl/lib/rdl.rb'
+require_relative '../rdl3/rdl/lib/rdl_types.rb'
+RDL::Config.instance.profile_stats
+=end
+  def profile_stats(outname="/#{__FILE__[0...-3]}",outdir="")
+    require 'profile'
+    Profiler__.stop_profile # Leave setup out of stats
+    
+    at_exit do
+      Profiler__.stop_profile
+      $__rdl_contract_switch.off {
+        puts "START."
+        puts "Performing Profile Analysis"
+        # Class Name => [Times Contract Called | Times Called | Time | Time | Class Profile]
+        # Implications:
+        #   [nil] -> Method exists in object space, but not used
+        #   [-1] -> Contract exists for method, but method not profiled
+        #   [-1, ...] -> Method profiled, but no contract exists
+        totals = {}
+        
+        puts "Retrieving Profiler Data"
+        Profiler__.class_variable_get(:@@maps).values.each do |threadmap|
+          threadmap.each do |key, data|
+            total_data = (totals[key.to_s] ||= [-1, 0, 0.0, 0.0, key])
+            total_data[1] += data[0]
+            total_data[2] += data[1]
+            total_data[3] += data[2]
+          end
+        end
+        
+        puts "Scanning Object Space"
+        kls = []
+        ObjectSpace.each_object { |obj|
+          if kls.include? obj.class then
+            next
+          end
+          kls << obj.class
+          mthds = obj.public_methods(false) + obj.private_methods(false) + obj.protected_methods(false)
+          puts "Class #{obj.class}"
+          mthds.each{ |mthd|
+            puts "    :#{mthd}"
+            totals["#{obj.class}::#{mthd.to_s}".gsub('::','#')] ||= [nil] unless mthd.to_s =~ /new/
+          }
+        }
+        
+        p "Scanning RDL Contract Log"
+        $__rdl_wrapped_calls.each{ |mname,ct|
+          if (totals[mname]) then
+            if (totals[mname][0]) then
+              totals[mname][0] = ct
+            else
+              totals[mname][0] = -1
+            end
+          end
+        }
+        
+        puts "Analyzing Statistics"
+        filtered = {}
+        totals.each{ |k,v|
+          if (not (k=~/(rdl)|(RDL)/)) and (v[0].nil? or v[0]==-1) then filtered[k]=v end
+        }
+        
+        puts "Writing Output"
+        require 'json'
+        fpath = "#{outdir}/#{outname}_rdlstat.json".gsub('//','')
+        File.open(fpath,'w') do |file|
+          file.puts "POTENTIAL PROBLEMS"
+          filtered.each{ |k,v|
+            begin
+              k =~ /((?:.+\#)*)(.+)/
+              x = $1[0...-1] # Store $1 and $2 before overriden
+              y = $2
+              if (x =~ /\<Class\:/) then
+                puts "Cannot evaluate user-defined class #{x}"
+              else
+                kls = eval x.gsub('#','::')
+                mthds = kls.public_methods(false) + kls.protected_methods(false) # Ignoring private methods
+                if (mthds.include? y.to_sym)
+                  file.printf "%-20s %-s", k, v.to_s
+                  file.puts ""
+                else
+                  puts "Ignoring inheritance problem for #{k}"
+                end
+              end
+            rescue
+            end
+          }
+          file.puts " "
+          file.puts "JSON OBJECT"
+          file.puts totals.to_json
+        end
+        puts "DONE."
+      }
+    end
+    
+    Profiler__.start_profile # Restart profiler after setup
+  end
+end

data/lib/rdl/contracts/and.rb

@@ -0,0 +1,29 @@
+module RDL::Contract
+  class AndContract < Contract
+    attr_reader :contracts
+    
+    def initialize(*contracts)
+      @contracts = contracts
+    end
+
+    # [:slf:] is bound to self when the contracts are checked
+    def check(slf, *v, &blk)
+      AndContract.check_array(@contracts, slf, *v, &blk)
+    end
+
+    # Check an array of contracts a
+    # [:slf:] is bound to self when the contracts are checked
+    def self.check_array(a, slf, *v, &blk)
+      # All contracts must be satisfied
+      a.all? { |c| c.check(slf, *v, &blk) }
+    end
+    
+    def to_s
+      AndContract.array_to_s(@contracts)
+    end
+
+    def self.array_to_s(a)
+      a.join(' && ')
+    end
+  end
+end

data/lib/rdl/contracts/contract.rb

@@ -0,0 +1,7 @@
+module RDL::Contract
+  class ContractError < StandardError
+  end
+
+  class Contract
+  end
+end

data/lib/rdl/contracts/flat.rb

@@ -0,0 +1,31 @@
+module RDL::Contract
+  class FlatContract < Contract
+    attr_accessor :desc
+
+    def initialize(desc="No Description", &blk)
+      @pred = blk
+      @desc = desc
+    end
+
+    def check(slf, *v, &blk)
+      $__rdl_contract_switch.off {
+        if (@pred &&
+            ((@pred.arity < 0) ? (@pred.arity.abs - 1) <= v.size : @pred.arity == v.size)) then
+          unless blk ? slf.instance_exec(*v, blk, &@pred) : slf.instance_exec(*v, &@pred) # TODO: Fix blk
+#          unless blk ? pred.call(*v, &blk) : pred.call(*v) 
+            raise ContractError,
+                  "#{v.inspect} does not satisfy #{self.to_s}"
+          end
+        else
+          raise ContractError,
+                "Invalid number of arguments: Expecting #{@pred.arity}, got #{v.size}"
+        end
+      }
+      return true
+    end
+
+    def to_s
+      @desc
+    end
+  end
+end

data/lib/rdl/contracts/or.rb

@@ -0,0 +1,25 @@
+module RDL::Contract
+  class OrContract < Contract
+    attr_reader :contracts
+    
+    def initialize(*contracts)
+      @contracts = contracts
+    end
+
+    def check(slf, *v, &blk)
+      # All contracts must be satisfied
+      @contracts.each { |c|
+        begin
+          c.check(slf, *v, &blk)
+          return true
+        rescue ContractError
+        end
+      }
+      raise ContractError, "#{v.inspect} does not satisfy #{self}"
+    end
+    
+    def to_s
+      @contracts.join(' && ')
+    end
+  end
+end

data/lib/rdl/contracts/proc.rb

@@ -0,0 +1,24 @@
+module RDL::Contract
+  class ProcContract < Contract
+    attr_accessor :pre_cond, :post_cond
+
+    def initialize(pre_cond:nil, post_cond:nil)
+      @pre_cond = pre_cond
+      @post_cond = post_cond
+    end
+
+    def wrap(slf, &blk)
+      Proc.new {|*v, &other_blk|
+        @pre_cond.check(slf, *v, &other_blk)
+        tmp = other_blk ? slf.instance_exec(*v, other_blk, &blk) : slf.instance_exec(*v, &blk) # TODO fix blk
+        # tmp = blk.call(*v, &other_blk) # TODO: Instance eval with self
+        @post_cond.check(slf, tmp, *v, &other_blk)
+        tmp
+      }
+    end
+    
+    def to_s
+      "(#{@pre_cond}) -> (#{@post_cond})"
+    end
+  end
+end

data/lib/rdl/switch.rb

@@ -0,0 +1,20 @@
+class RDL::Switch
+  def initialize
+    @switch = true
+  end
+  def off?()
+    return not(@switch)
+  end
+  def off()
+    return unless @switch
+    tmp = @switch
+    @switch = false
+    begin
+      ret = yield
+    ensure
+      @switch = tmp
+    end
+    return ret
+  end
+end
+

data/lib/rdl/types/annotated_arg.rb

@@ -0,0 +1,41 @@
+require_relative 'type'
+
+module RDL::Type
+  class AnnotatedArgType < Type
+    attr_reader :name
+    attr_reader :type
+
+# Note: Named argument types aren't hashconsed.
+
+    def initialize(name, type)
+      @name = name
+      @type = type
+      raise RuntimeError, "Attempt to create vararg type with non-type" unless type.is_a? Type
+      super()
+    end
+
+    def to_s
+      "#{@type.to_s} #{@name}"
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other) # :nodoc:
+      return (other.instance_of? AnnotatedArgType) && (other.name == @name) && (other.type == @type)
+    end
+
+    def hash # :nodoc:
+      return (57 + @name.hash) * @type.hash
+    end
+
+    def member?(obj, *args)
+      @type.member?(obj, *args)
+    end
+
+    def instantiate(inst)
+      return AnnotatedArgType.new(@name, @type.instantiate(inst))
+    end
+  end
+end

data/lib/rdl/types/finitehash.rb

@@ -0,0 +1,81 @@
+require_relative 'type'
+
+module RDL::Type
+  # A specialized GenericType for fixed-sized maps from values to
+  # types, for "named" arguments in Ruby. Values are compared with ==
+  # to see if they match.
+  class FiniteHashType < Type
+    attr_reader :elts
+
+    @@cache = {}
+
+    class << self
+      alias :__new__ :new
+    end
+
+    def self.new(elts)
+      t = @@cache[elts]
+      return t if t
+      t = FiniteHashType.__new__(elts)
+      return (@@cache[elts] = t) # assignment evaluates to t
+    end
+
+    def initialize(elts)
+      elts.each { |k, t|
+        raise RuntimeError, "Got #{t.inspect} where Type expected" unless t.is_a? Type
+        raise RuntimeError, "Type may not be annotated or vararg" if (t.instance_of? AnnotatedArgType) || (t.instance_of? VarargType)
+      }
+      @elts = elts
+      super()
+    end
+
+    def to_s
+      "{" + @elts.map { |k, t| k.to_s + ": " + t.to_s }.join(', ') + "}"
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def ==(other) # :nodoc:
+      return (other.instance_of? FiniteHashType) && (other.elts == @elts)
+    end
+
+    def <=(other)
+      return true if other.instance_of? TopType
+      return self == other
+      # Subtyping with Hash not allowed
+      # All positions of HashTuple are invariant since tuples are mutable
+    end
+    
+    def member?(obj, *args)
+      t = RDL::Util.rdl_type obj
+      return t <= self if t
+      rest = @elts.clone # shallow copy
+
+      return false unless obj.instance_of? Hash
+      
+      # Check that every mapping in obj exists in @map and matches the type
+      obj.each_pair { |k, v|
+        return false unless @elts.has_key?(k)
+        t = @elts[k]
+        t = t.type if t.instance_of? OptionalType
+        return false unless t.member?(v)
+        rest.delete(k)
+      }
+
+      # Check that any remaining types are optional
+      rest.each_pair { |k, t|
+        return false unless t.instance_of? OptionalType
+      }
+    end
+
+    def instantiate(inst)
+      FiniteHashType.new(Hash[@elts.map { |k, t| [k, t.instantiate(inst)] }])
+    end
+    
+    def hash
+      h = 229 * @elts.hash
+    end
+  end
+end