contracts 0.0.1

data/lib/builtin_contracts.rb

@@ -0,0 +1,169 @@
+module Contracts
+  class Num
+    def self.valid? val
+      val.is_a? Numeric
+    end
+  end
+
+  class Pos
+    def self.valid? val
+      val > 0
+    end
+  end
+
+  class Neg
+    def self.valid? val
+      val < 0
+    end
+  end
+
+  class Any
+    def self.valid? val
+      true
+    end
+  end
+
+  class None
+    def self.valid? val
+      false
+    end
+  end
+
+  class CallableClass
+    def self.[](*vals)
+      self.new(*vals)
+    end
+  end
+
+  class Or < CallableClass
+    def initialize(*vals)
+      @vals = vals
+    end
+
+    def valid?(val)
+      @vals.any? do |contract|
+        res, _ = Contract.valid?(val, contract)
+        res
+      end
+    end
+
+    def to_s
+      @vals[0, @vals.size-1].join(", ") + " or " + @vals[-1].to_s
+    end
+  end
+
+  class Xor < CallableClass
+    def initialize(*vals)
+      @vals = vals
+    end
+
+    def valid?(val)
+      results = @vals.map do |contract|
+        res, _ = Contract.valid?(val, contract)
+        res
+      end
+      results.count(true) == 1
+    end
+
+    def to_s
+      @vals[0, @vals.size-1].join(", ") + " xor " + @vals[-1].to_s
+    end
+  end  
+
+  class And < CallableClass
+    def initialize(*vals)
+      @vals = vals
+    end
+
+    def valid?(val)
+      @vals.all? do |contract|
+        res, _ = Contract.valid?(val, contract)
+        res
+      end
+    end
+
+    def to_s
+      @vals[0, @vals.size-1].join(", ") + " and " + @vals[-1].to_s
+    end
+  end
+
+  class RespondsTo < CallableClass
+    def initialize(*meths)
+      @meths = meths
+    end
+
+    def valid?(val)
+      @meths.all? do |meth|
+        val.respond_to? meth
+      end
+    end
+
+    def to_s
+      "a value that responds to #{@meths.inspect}"
+    end
+  end
+
+  class Send < CallableClass
+    def initialize(*meths)
+      @meths = meths
+    end
+
+    def valid?(val)
+      @meths.all? do |meth|
+        val.send(meth)
+      end
+    end
+
+    def to_s
+      "a value that returns true for all of #{@meths.inspect}"
+    end  
+  end
+
+  class IsA < CallableClass
+    def initialize(cls)
+      @cls = cls
+    end
+
+    def valid?(val)
+      val.is_a? @cls
+    end
+
+    def to_s
+      "a #{@cls.inspect}"
+    end
+  end
+
+  class Not < CallableClass
+    def initialize(*vals)
+      @vals = vals
+    end
+
+    def valid?(val)
+      @vals.all? do |contract|
+        res, _ = Contract.valid?(val, contract)
+        !res
+      end
+    end
+
+    def to_s
+      "a value that is none of #{@vals.inspect}"
+    end
+  end
+
+  class ArrayOf < CallableClass
+    def initialize(contract)
+      @contract = contract
+    end
+
+    def valid?(vals)
+      vals.all? do |val|
+        res, _ = Contract.valid?(val, @contract)
+        res
+      end
+    end
+
+    def to_s
+      "an array of #{@contract}"
+    end
+  end
+end

data/lib/contracts.rb

@@ -0,0 +1,106 @@
+require 'decorators'
+require 'builtin_contracts'
+
+class Class
+  include MethodDecorators
+end
+
+class Contract < Decorator
+  attr_accessor :contracts, :klass, :method
+  decorator_name :contract
+  def initialize(klass, method, *contracts)
+    @klass, @method, @contracts = klass, method, contracts
+  end
+
+  def self.mkerror(validates, arg, contract)
+    if validates
+      [true, {}]
+    else
+      [false, { :arg => arg, :contract => contract }]
+    end
+  end
+
+  def self.failure_msg(data)
+   # TODO __file__ and __line__ won't work in Ruby 1.9.
+   # It provides a source_location method instead.
+%{Contract violation:
+    Expected: #{data[:contract]},
+    Actual: #{data[:arg].inspect}
+    Value guarded in: #{data[:class]}::#{data[:method].name}
+    With Contract: #{data[:contracts].map { |t| t.is_a?(Class) ? t.name : t.class.name }.join(", ") }
+    At: #{data[:method].__file__}:#{data[:method].__line__} }
+  end
+  def self.failure_callback(data)
+    raise failure_msg(data)
+  end
+
+  def self.success_callback(data)
+  end  
+
+  def self.validate_hash(arg, contract)
+    arg.keys.each do |k|
+      result, info = validate(arg[k], contract[k])
+      return [result, info] unless result
+    end
+  end
+
+  def self.validate_proc(arg, contract)
+    mkerror(contract[arg], arg, contract)
+  end
+
+  def self.validate_class(arg, contract)
+    valid = if contract.respond_to? :valid?
+              contract.valid? arg
+            else
+              contract == arg.class
+            end
+    mkerror(valid, arg, contract)
+  end
+
+  def self.validate_all(args, contracts, klass, method)
+    args.zip(contracts).each do |arg, contract|
+      validate(arg, contract, klass, method, contracts)
+    end
+  end
+
+  def self.validate(arg, contract, klass, method, contracts)
+    result, _ = valid?(arg, contract)
+    if result
+      success_callback({:arg => arg, :contract => contract, :class => klass, :method => method, :contracts => contracts})
+    else
+      failure_callback({:arg => arg, :contract => contract, :class => klass, :method => method, :contracts => contracts})
+    end
+  end
+
+  # arg to method -> contract it should satisfy -> (Boolean, metadata)
+  def self.valid?(arg, contract)
+    case contract
+    when Class
+      validate_class arg, contract
+    when Proc
+      validate_proc arg, contract
+    when Array
+      # TODO account for these errors too
+      return mkerror(false, arg, contract) unless arg.is_a?(Array)
+      validate_all(arg, contract)
+    when Hash
+      return mkerror(false, arg, contract) unless arg.is_a?(Hash)
+      validate_hash(arg, contract)
+    else
+      if contract.respond_to? :valid?
+        mkerror(contract.valid?(arg), arg, contract)
+      else
+        mkerror(arg == contract, arg, contract)
+      end
+    end
+  end
+
+  def call(this, *args)
+    Contract.validate_all(args, @contracts, @klass, @method)
+    result = @method.bind(this).call(*args)
+    if args.size == @contracts.size - 1
+      Contract.validate(result, @contracts[-1], @klass, @method, @contracts)
+    end
+    result
+  end
+end

data/lib/decorators.rb

@@ -0,0 +1,84 @@
+module MethodDecorators
+  def self.extended(klass)
+    class << klass
+      attr_accessor :decorated_methods
+    end
+  end
+
+  def method_missing(name, *args, &blk)
+    # if the const isn't capitalized, then const_defined will throw an
+    # error. So first check to make sure it is capitalized.
+    letter = name.to_s[0]
+    if letter >= 65 && letter <= 90 && Object.const_defined?(name)
+      const = Object.const_get(name)
+    elsif Decorator.decorators.key?(name)
+      const = Decorator.decorators[name]
+    else
+      return super
+    end
+
+    instance_eval <<-ruby_eval, __FILE__, __LINE__ + 1
+      def #{name}(*args, &blk)
+        decorate(#{const.name}, *args, &blk)
+      end
+    ruby_eval
+
+    send(name, *args, &blk)
+  end
+
+  def method_added(name)
+    return unless @decorators
+
+    decorators = @decorators.dup
+    @decorators = nil
+    @decorated_methods ||= Hash.new {|h,k| h[k] = []}
+
+    class << self; attr_accessor :decorated_methods; end
+
+    decorators.each do |klass, args|
+      decorator = klass.respond_to?(:new) ? klass.new(self, instance_method(name), *args) : klass
+      @decorated_methods[name] << decorator
+    end
+
+    class_eval <<-ruby_eval, __FILE__, __LINE__ + 1
+      def #{name}(*args, &blk)
+        ret = nil
+        self.class.decorated_methods[#{name.inspect}].each do |decorator|
+          ret = decorator.call(self, *args, &blk)
+        end
+        ret
+      end
+    ruby_eval
+  end
+
+  def decorate(klass, *args)
+    @decorators ||= []
+    @decorators << [klass, args]
+  end
+end
+
+class Decorator
+  class << self
+    attr_accessor :decorators
+    def decorator_name(name)
+      Decorator.decorators ||= {}
+      Decorator.decorators[name] = self
+    end
+  end
+
+  def self.inherited(klass)
+    name = klass.name.gsub(/^./) {|m| m.downcase}
+
+    return if name =~ /^[^A-Za-z_]/ || name =~ /[^0-9A-Za-z_]/
+
+    MethodDecorators.module_eval <<-ruby_eval, __FILE__, __LINE__ + 1
+      def #{klass}(*args, &blk)
+        decorate(#{klass}, *args, &blk)
+      end
+    ruby_eval
+  end
+
+  def initialize(klass, method)
+    @method = method
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: contracts
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Aditya Bhargava
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-06-07 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: "This library provides contracts for Ruby. Contracts let you clearly \xE2\x80\x93 even beautifully \xE2\x80\x93 express how your code behaves, and free you from writing tons of boilerplate, defensive code."
+email: bluemangroupie@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/builtin_contracts.rb
+- lib/contracts.rb
+- lib/decorators.rb
+has_rdoc: true
+homepage: http://github.com/egonSchiele/contracts.ruby
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Contracts for Ruby.
+test_files: []
+