antidote-types 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 80a6d4abd0f6d721c3930e49e871b176c9344ef2
+  data.tar.gz: 1f96bc904f5e4ccc894fdcbb213b90e7e3ece3c5
+SHA512:
+  metadata.gz: 9fe3ce19d7d26e89ad543e35e967d2a261fc78417d045fbb8ce4b7219efa66a12c4aca3eb24b02ada204115d94c25ae97ff217916b84c2a86889c6305255c5b4
+  data.tar.gz: 38c3acf4a50fd93b009550697b835c745fa58903607a31709232145733ded57c00ac3e3e269ef494e21c0bc8addffa9dc394231e88352266e65253017352bafd

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2015 Mathias Jean Johansen <mathias@mjj.io>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,85 @@
+# Antidote
+Antidote is a small, highly experimental library that performs runtime type
+assertions in Ruby in the same vein as
+[Rubype](https://github.com/gogotanaka/Rubype),
+[contracts.ruby](https://github.com/egonSchiele/contracts.ruby),
+[sig](https://github.com/janlelis/sig), and so on. This repository should mainly
+be considered a proof of concept.
+
+It relies heavily on metaprogramming, and it is unsafe for method calls with
+side-effects. Nonetheless, it works.
+
+Antidote exposes two methods: `annotate`, and `annotate_class_method` which can
+be used a such:
+
+```ruby
+require_relative 'lib/antidote'
+
+class Adder
+  include Antidote
+
+  annotate Fixnum, Fixnum, Fixnum do
+  def add(x, y)
+    x + y
+  end
+  end
+end
+
+adder = Adder.new.add(1, 2)
+```
+
+Here, `annotate Fixnum, Fixnum, Fixnum` means that we expect two `Fixnum` as
+input, and we should return a `Fixnum` as result.
+
+This program returns 3 as expected since we comply with the type signature, but
+if we change `x` to be a `String`, we receive the following error message:
+
+```
+Variable `x` in method `add` expected a String, but received a Fixnum
+(Antidote::VariableTypeError)
+```
+
+If we change the return type, we'll see a similar message:
+
+```
+Expected `add` to return a String, but it returned a Fixnum instead
+(Antidote::ReturnTypeError)
+```
+
+You can obviously handle both `Antidote::VariableTypeError` and
+`Antidote::ReturnTypeError` in your code if needed.
+
+Please, visit [`example.rb`](example.rb) for a full example.
+
+## Requirements
+* Ruby 2.2.0 or newer.
+
+## Installation
+Add this line to your Gemfile:
+
+```ruby
+gem 'antidote-types'
+```
+
+And then run:
+
+```
+bundle
+```
+
+Or simply install it yourself:
+
+```
+gem install antidote-types
+```
+
+## Contribute
+1. [Fork it](https://github.com/majjoha/antidote/fork).
+2. Create your feature branch (`git checkout -b my-new-feature`).
+3. Commit your changes (`git commit -am 'Add some new feature.'`).
+4. Push to the branch (`git push origin my-new-feature`).
+5. Create a new pull request.
+
+## License
+See [LICENSE](https://github.com/majjoha/antidote/blob/master/LICENSE).
+Copyright (c) 2014 Mathias Jean Johansen <<mathias@mjj.io>>

data/lib/antidote.rb

@@ -0,0 +1,85 @@
+require_relative "antidote/variable_type_error"
+require_relative "antidote/return_type_error"
+
+module Antidote
+  class << self
+    def included(klass)
+      klass.extend(ClassMethods)
+    end
+  end
+
+  module ClassMethods
+    @@type_constraints = Hash.new { |h, k| h[k] = [] } 
+
+    def annotate(*variables, return_type, &method_name)
+      method_name = method_name.call.to_s
+      add_type_constraints(method_name, variables, return_type)
+      redefine_instance_method(method_name)
+    end
+
+    def annotate_class_method(*variables, return_type, &method_name)
+      method_name = "self.#{method_name.call.to_s}"
+      add_type_constraints(method_name, variables, return_type)
+      redefine_class_method(method_name)
+    end
+
+    private
+
+    def add_type_constraints(method_name, variables, return_type)
+      variables.each { |variable| @@type_constraints[method_name] << variable }
+      @@type_constraints[method_name] << {__returns: return_type}
+    end
+
+    def redefine_class_method(method_name)
+      method_name = method_name.split(".").last
+      new_name_for_old_method = "#{method_name}_old".to_sym
+      self.singleton_class.send(:alias_method, new_name_for_old_method, method_name)
+
+      define_singleton_method(method_name) do |*args|
+        args.each_with_index do |argument, index|
+          class_method = "self.#{method_name}"
+          actual = argument.class
+          expected = @@type_constraints[class_method][index]
+          parameters = self.method(new_name_for_old_method).parameters.map(&:last)
+          variable_name = parameters[index]
+          @__return_type = @@type_constraints[class_method].last[:__returns]
+
+          unless actual == expected
+            raise VariableTypeError, [actual, expected, variable_name, class_method]
+          end
+        end
+
+        if (klass = self.send(new_name_for_old_method, *args).class) != @__return_type 
+          raise ReturnTypeError, [klass, @__return_type, class_method]
+        else
+          self.send(new_name_for_old_method, *args)
+        end
+      end
+    end
+
+    def redefine_instance_method(method_name)
+      new_name_for_old_method = "#{method_name}_old".to_sym
+      alias_method(new_name_for_old_method, method_name)
+
+      define_method(method_name) do |*args|
+        args.each_with_index do |argument, index|
+          actual = argument.class
+          expected = @@type_constraints[method_name][index]
+          parameters = self.method(new_name_for_old_method).parameters.map(&:last)
+          variable_name = parameters[index]
+          @__return_type = @@type_constraints[method_name].last[:__returns]
+
+          unless actual == expected
+            raise VariableTypeError, [actual, expected, variable_name, method_name]
+          end
+        end
+
+        if (klass = self.send(new_name_for_old_method, *args).class) != @__return_type 
+          raise ReturnTypeError, [klass, @__return_type, method_name]
+        else
+          self.send(new_name_for_old_method, *args)
+        end
+      end
+    end
+  end
+end

data/lib/antidote/return_type_error.rb

@@ -0,0 +1,12 @@
+module Antidote
+  class ReturnTypeError < StandardError
+    def initialize(types)
+      @actual_type, @expected_type, @method_name = types
+    end
+
+    def message
+      "Expected `#{@method_name}` to return a #{@expected_type}, but it " \
+      "returned a #{@actual_type} instead"
+    end
+  end
+end

data/lib/antidote/variable_type_error.rb

@@ -0,0 +1,12 @@
+module Antidote
+  class VariableTypeError < StandardError
+    def initialize(types)
+      @actual_type, @expected_type, @variable_name, @method_name = types
+    end
+
+    def message
+      "Variable `#{@variable_name}` in method `#{@method_name}` expected a " \
+      "#{@expected_type}, but received a #{@actual_type}"
+    end
+  end
+end

data/lib/antidote/version.rb

@@ -0,0 +1,3 @@
+module Antidote
+  VERSION = "1.0.0"
+end

data/spec/antidote_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Antidote do
+  describe Foo do
+    let(:foo) { Foo.new }
+
+    describe "#bar" do
+      it "raises an error when the method is given the wrong type" do
+        expect { foo.bar(5.4) }.to raise_error(Antidote::VariableTypeError)
+      end
+
+      it "returns x when given the right argument" do
+        expect(foo.bar(5)).to eq 5
+      end
+    end
+
+    describe "#baz" do
+      let(:custom_type) { CustomType.new(1, 2) }
+
+      it "raises an error when the method is given the wrong types" do
+        expect { foo.baz(5.5) }.to raise_error(Antidote::VariableTypeError)
+      end
+
+      it "returns x.a + x.b when given the right arguments" do
+        expect(foo.baz(custom_type)).to eq 3
+      end
+    end
+
+    describe "#qux" do
+      it "raises an error when the return type is wrong" do
+        expect { foo.qux(1,2) }.to raise_error(Antidote::ReturnTypeError)
+      end
+    end
+
+    describe ".quux" do
+      it "raises an error when the method is given the wrong types" do
+        expect { Foo.quux(43, 6.66) }.to raise_error(Antidote::VariableTypeError)
+      end
+
+      it "returns [name, y] when given the right arguments" do
+        expect(Foo.quux(6.66, "Hello")).to eq ["Hello", 6.66]
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require './lib/antidote'
+
+class CustomType
+  attr_accessor :a, :b
+
+  def initialize(a, b)
+    @a = a
+    @b = b
+  end
+end
+
+class Foo
+  include Antidote
+
+  annotate Fixnum, Fixnum do
+  def bar(x)
+    x
+  end
+  end
+
+  annotate CustomType, Fixnum do
+  def baz(z)
+    z.a + z.b
+  end
+  end
+
+  annotate Fixnum, Fixnum, String do
+  def qux(a, b)
+    a + b
+  end
+  end
+
+  annotate_class_method Float, String, Array do
+  def self.quux(y, name)
+    [name, y]
+  end
+  end
+end

metadata

@@ -0,0 +1,98 @@
+--- !ruby/object:Gem::Specification
+name: antidote-types
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mathias Jean Johansen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.3.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+description: |-
+  Antidote is a small, highly experimental library that
+                    performs runtime type assertions in Ruby
+email: mathias@mjj.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/antidote.rb
+- lib/antidote/return_type_error.rb
+- lib/antidote/variable_type_error.rb
+- lib/antidote/version.rb
+- spec/antidote_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/majjoha/antidote
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: A highly experimental type assertion library
+test_files:
+- spec/antidote_spec.rb
+- spec/spec_helper.rb
+has_rdoc: