typedeaf 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 --- 
 SHA1: 
-  metadata.gz: 3a8ff4243653190eb9017aabc61f79b3654f4dd2
-  data.tar.gz: 7d7c83e7048c3667c48096ebf812a311c5c375fb
+  metadata.gz: d9fea842c38105ee58ed6274182e98d48af63414
+  data.tar.gz: 1174982311c6dc067f43186110909fc3b8f9b2be
 SHA512: 
-  metadata.gz: a454e734801b2f24eef4d02d2e81d9f46c6b8aacb20ee6f2aad1a85056bcf98647e7375c8d64492c69d4a9dd64c49cfa98b29967b81dec0aa9f07160894fce54
-  data.tar.gz: 92f730e8823c3c7fe8900b051f6277785bac51b9fbf5aa816ce48bd5fe2fc08b03ae82360fb9ea86bcfaa99a10beb1207a6b1e32e4fd244de32147188c55627b
+  metadata.gz: 4cdb9589f43469a270fdea4efea6066ce48c4b95376abd16530b6e87851d7647da16bf6df452c8a24ade90186899c832be56a49035c99845cf5c96f1ae502ac5
+  data.tar.gz: ad794a1c79c07883854250e988f12f6b5901cc364ca85151fb3934fab0bac496d131cc61a15501e1f9453bb4bcb20250f31af0c6edc8a0db7d62348fb649cec0

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - jruby-19mode
+  - rbx-2
+  - ruby-head
+  - jruby-head
+  - 1.9.3
+

data/Gemfile

@@ -6,6 +6,8 @@ gemspec
 group :development do
   gem 'rake'
   gem 'rspec'
+  gem 'rspec-its'
   gem 'pry'
-  gem 'debugger-pry', :platform => :mri
+  gem 'debugger-pry', :platform => :mri_19
+  gem 'benchmark-ips'
 end

data/README.md

@@ -1,35 +1,94 @@
 # Typedeaf
 
+[![Build Status](https://travis-ci.org/rtyler/typedeaf.svg)](https://travis-ci.org/rtyler/typedeaf)
+
 Typedeaf is a gem to help add some type-checking to method declarations in Ruby
 
 
+[RDoc](http://www.rubydoc.info/github/rtyler/typedeaf/master/frames)
+
+
 ## Usage
 
+### Writing your Typedeaf'd code
+
+```ruby
+require 'typedeaf'
+
+class Logger
+  include Typedeaf
+
+  # Log an error
+  #
+  # @param [String] messaage
+  define :error, message: String do
+    # Just delegate to the #log method nad pass
+    # the level of error
+    self.log(message, :error)
+  end
+
+  # Log a simple message to STDOUT
+  #
+  # @param [String] message The log message to log 
+  # @param [Symbol] level The level at which to log the
+  #     message, defaults to :info
+  define :log, message: String, level: default(:info, Symbol) do
+    puts "[#{level}] #{message}"
+  end
+end
+```
+
+### Calling Typedeaf'd code
+
 ```
-[1] pry(main)> require 'typedeaf'
+[1] pry(main)> require './logger'
 => true
-[2] pry(main)> class Logger
-[2] pry(main)*   include Typedeaf
-[2] pry(main)*   
-[2] pry(main)*   define :log, message: String, level: Symbol do
-[2] pry(main)*     puts "Logging #{message} at level #{level}"
-[2] pry(main)*   end  
-[2] pry(main)* end  
-=> Logger
-[3] pry(main)> l = Logger.new
+[2] pry(main)> l = Logger.new
 => #<Logger:0x00000803c616b8>
-[4] pry(main)> l.log("Hello World", :debug)
-Logging Hello World at level debug
+[3] pry(main)> l.log 'test 1, 2, 3'
+[info] test 1, 2, 3
+=> nil
+[4] pry(main)> l.log 'this is SUPER SERIOUS', :critical
+[critical] this is SUPER SERIOUS
 => nil
-[5] pry(main)> l.log(4, :debug)
+[5] pry(main)> l.error(5) # wrong type!
 Typedeaf::InvalidTypeException: Expected `message` to be a kind of String but was Fixnum
-from /usr/home/tyler/source/github/ruby/typedeaf/lib/typedeaf.rb:41:in `type_validation!'
-[6] pry(main)> l.log('Whoopsies', 'debug')
-Typedeaf::InvalidTypeException: Expected `level` to be a kind of Symbol but was String
-from /usr/home/tyler/source/github/ruby/typedeaf/lib/typedeaf.rb:41:in `type_validation!'
+from /usr/home/tyler/source/github/ruby/typedeaf/lib/typedeaf.rb:58:in `type_validation!'
+[6] pry(main)> l.log("This doesn't use the right type either", 1)
+Typedeaf::InvalidTypeException: Expected `level` to be a kind of [Symbol] but was Fixnum
+from /usr/home/tyler/source/github/ruby/typedeaf/lib/typedeaf.rb:58:in `type_validation!'
 [7] pry(main)> 
+
 ```
 
+#### Passing blocks to Typedeaf code
+
+```ruby
+require 'typedeaf'
+
+class Logger
+  include Typedeaf
+
+  define :log, message: String, block: Proc do
+    puts "Loggin: #{message}"
+    block.call
+  end
+end
+
+Logger.new.log('hello world') do
+  puts 'called back!'
+end
+```
+
+## Caveats
+
+Here's a list of caveats, or things that don't quite work, with Typedeaf:
+
+* Typedeaf methods cannot use `return` or `break`, since they're technically
+  Ruby blocks and must follow the rules defined for block behaviors
+* `yield` will not properly work, if you want to pass blocks into your
+  Typedeafed method, see the above usage example
+
 
 ## Installation
 

data/benchmarks/bench_helper.rb

@@ -0,0 +1,6 @@
+require 'rubygems'
+
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__) + '/../lib'))
+require 'typedeaf'
+require 'benchmark/ips'
+

data/benchmarks/missing_arguments.rb

@@ -0,0 +1,27 @@
+require_relative 'bench_helper'
+
+class MissingArgs
+  include Typedeaf
+
+  def method_with_params(buffer)
+    buffer.size + rand + rand
+  end
+
+  define :typedeaf_with_params, buffer: String do
+    buffer.size + rand + rand
+  end
+end
+
+blk = lambda do |buffer|
+  buffer.size + rand + rand
+end
+
+p = MissingArgs.new
+
+
+Benchmark.ips do |x|
+  x.report('typedeaf method') { begin; p.typedeaf_with_params; rescue; end; }
+  x.report('normal method') { begin; p.method_with_params; rescue; end; }
+  x.report('a simple proc') { begin; blk.(); rescue; end; }
+  x.compare!
+end

data/benchmarks/missing_arguments.txt

@@ -0,0 +1,15 @@
+As of: 790130d
+
+Calculating -------------------------------------
+     typedeaf method      2292 i/100ms
+       normal method      2889 i/100ms
+       a simple proc      2594 i/100ms
+-------------------------------------------------
+     typedeaf method    27691.2 (±12.6%) i/s -     137520 in   5.057106s
+       normal method    34595.8 (±12.9%) i/s -     170451 in   5.028954s
+       a simple proc    31650.1 (±15.4%) i/s -     155640 in   5.058063s
+
+Comparison:
+       normal method:    34595.8 i/s
+       a simple proc:    31650.1 i/s - 1.09x slower
+     typedeaf method:    27691.2 i/s - 1.25x slower

data/benchmarks/parameter_calls.rb

@@ -0,0 +1,26 @@
+require_relative 'bench_helper'
+
+class Parametered
+  include Typedeaf
+
+  def method_with_params(buffer)
+    buffer.size + rand + rand
+  end
+
+  define :typedeaf_with_params, buffer: String do
+    buffer.size + rand + rand
+  end
+end
+
+blk = Proc.new do |buffer|
+  buffer.size + rand + rand
+end
+
+p = Parametered.new
+
+Benchmark.ips do |x|
+  x.report('typedeaf method') { |i| p.typedeaf_with_params(i.to_s) }
+  x.report('normal method') { |i| p.method_with_params(i.to_s) }
+  x.report('a simple proc') { |i| blk.(i.to_s) }
+  x.compare!
+end

data/benchmarks/parameter_calls.txt

@@ -0,0 +1,15 @@
+As of: c4f25f0
+
+Calculating -------------------------------------
+     typedeaf method      5197 i/100ms
+       normal method     20996 i/100ms
+       a simple proc     20478 i/100ms
+-------------------------------------------------
+     typedeaf method 357074776.5 (±25.7%) i/s -  675537242 in   2.718540s
+       normal method 6571250036.9 (±28.7%) i/s - 5290845028 in   1.359025s
+       a simple proc 6206517128.9 (±28.5%) i/s - 5476574886 in   1.375870s
+
+Comparison:
+       normal method: 6571250036.9 i/s
+       a simple proc: 6206517128.9 i/s - 1.06x slower
+     typedeaf method: 357074776.5 i/s - 18.40x slower

data/benchmarks/simple_calls.rb

@@ -0,0 +1,24 @@
+require_relative 'bench_helper'
+
+class Simple
+  include Typedeaf
+  def method_computer
+    rand + rand
+  end
+
+  define :typedeaf_computer do
+    rand + rand
+  end
+end
+
+s = Simple.new
+blk = Proc.new do
+  rand + rand
+end
+
+Benchmark.ips do |x|
+  x.report('typedeaf method') { s.typedeaf_computer }
+  x.report('normal method') { s.method_computer }
+  x.report('a simple proc') { blk.() }
+  x.compare!
+end

data/benchmarks/simple_calls.txt

@@ -0,0 +1,16 @@
+As of: af96558
+
+Calculating -------------------------------------
+     typedeaf method     12808 i/100ms
+       normal method     19336 i/100ms
+       a simple proc     18550 i/100ms
+-------------------------------------------------
+     typedeaf method   461399.4 (±11.7%) i/s -    2267016 in   5.001402s
+       normal method  1050875.4 (±15.6%) i/s -    5104704 in   5.008836s
+       a simple proc   912593.9 (±15.8%) i/s -    4433450 in   5.012059s
+
+Comparison:
+       normal method:  1050875.4 i/s
+       a simple proc:   912593.9 i/s - 1.15x slower
+     typedeaf method:   461399.4 i/s - 2.28x slower
+

data/lib/typedeaf.rb

@@ -1,4 +1,5 @@
-require 'typedeaf/errors'
+require 'typedeaf/classmethods'
+require 'typedeaf/instancemethods'
 require "typedeaf/version"
 
 module Typedeaf
@@ -7,68 +8,6 @@ module Typedeaf
     base.extend(ClassMethods)
   end
 
-  module InstanceMethods
-    def __typedeaf_varstack__
-      if @__typedeaf_varstack__.nil?
-        @__typedeaf_varstack__ = []
-      end
-      return @__typedeaf_varstack__
-    end
-
-    def method_missing(sym, *args)
-      # We only want to peek at the stack if we have no args (i.e. not trying
-      # to make a method call
-      if args.empty? && !(__typedeaf_varstack__.empty?)
-        params, values = __typedeaf_varstack__.last
-        # The top of our stack contains something that we want
-        return values[sym] if params[sym]
-      end
-
-      return super
-    end
-
-    def positional_validation!(params, args)
-      if params.size != args.size
-        raise ArgumentError, "wrong number of arguments (#{args.size} for #{params.size}"
-      end
-    end
-
-    def type_validation!(expected, param, value)
-      unless value.is_a?(expected)
-        raise InvalidTypeException,
-            "Expected `#{param}` to be a kind of #{expected} but was #{value.class}"
-      end
-    end
-  end
-
-  module ClassMethods
-    def define(method_sym, params={}, &block)
-      if block.nil?
-        raise MissingMethodException,
-            "You must provide a block for the #{method_sym} body"
-      end
-
-      define_method(method_sym) do |*args|
-        positional_validation!(params.keys, args)
-
-        param_indices = {}
-        params.each.with_index do |(param, type), index|
-          value = args[index]
-          type_validation!(type, param, value)
-          param_indices[param] = value
-        end
-        __typedeaf_varstack__ << [params, param_indices]
-
-        begin
-          instance_exec(*args, &block)
-        ensure
-          __typedeaf_varstack__.pop
-        end
-      end
-      return self
-    end
-  end
-
   # Install the Typedeaf methods onto Class to be used everywhere
   def self.global_install
     Class.class_eval do

data/lib/typedeaf/arguments.rb

@@ -0,0 +1,12 @@
+module Typedeaf
+  module Arguments
+    class DefaultArgument
+      attr_reader :value, :types
+      def initialize(value, *types)
+        @value = value
+        @types = types
+      end
+    end
+  end
+end
+

data/lib/typedeaf/classmethods.rb

@@ -0,0 +1,88 @@
+require 'concurrent'
+
+require 'typedeaf/arguments'
+require 'typedeaf/errors'
+
+module Typedeaf
+  module ClassMethods
+    def default(value, *types)
+      return Typedeaf::Arguments::DefaultArgument.new(value, *types)
+    end
+
+    def promise(method_sym, params={}, &block)
+      future(method_sym, params, primitive=Concurrent::Promise, &block)
+    end
+
+    def future(method_sym, params={}, primitive=Concurrent::Future, &block)
+      __typedeaf_validate_body_for(method_sym, block)
+      __typedeaf_method_parameters__[method_sym] = params
+
+      define_method(method_sym) do |*args, &blk|
+        __typedeaf_handle_nested_block(params, args, blk)
+        __typedeaf_handle_default_parameters(params, args)
+        __typedeaf_validate_positionals(params, args)
+
+        stack_element =  [method_sym, __typedeaf_validate_types(params, args)]
+        primitive.new do
+          # We're inserting into the varstack within the future to make sure
+          # we're using the right thread+instance combination
+          __typedeaf_varstack__ << stack_element
+          begin
+            instance_exec(&block)
+          ensure
+            __typedeaf_varstack__.pop
+          end
+        end.execute
+      end
+
+      return self
+    end
+
+    def define(method_sym, params={}, &block)
+      params = params.freeze
+      __typedeaf_validate_body_for(method_sym, block)
+      __typedeaf_method_parameters__[method_sym] = params
+
+      define_method(method_sym) do |*args, &blk|
+        # Optimization, if we're a parameter-less method, just pass right
+        # through without any checks whatsoever
+        if params.empty?
+          return instance_exec(&block)
+        end
+
+        __typedeaf_handle_nested_block(params, args, blk)
+        __typedeaf_handle_default_parameters(params, args)
+        __typedeaf_validate_positionals(params, args)
+
+        __typedeaf_varstack__ << [method_sym,
+                                  __typedeaf_validate_types(params, args)]
+
+        begin
+          instance_exec(&block)
+        ensure
+          __typedeaf_varstack__.pop
+        end
+      end
+
+      return self
+    end
+
+    def __typedeaf_method_parameters__
+      if @__typedeaf_method_parameters__.nil?
+        @__typedeaf_method_parameters__ = {}
+      end
+
+      return @__typedeaf_method_parameters__
+    end
+
+    private
+
+    def __typedeaf_validate_body_for(method, block)
+      if block.nil?
+        raise MissingMethodException,
+            "You must provide a block for the #{method} body"
+      end
+    end
+
+  end
+end

data/lib/typedeaf/instancemethods.rb

@@ -0,0 +1,145 @@
+require 'thread'
+
+require 'typedeaf/arguments'
+require 'typedeaf/errors'
+
+  module Typedeaf
+    module InstanceMethods
+    def method_missing(varname, *args)
+      # We only want to peek at the stack if we have no args (i.e. not trying
+      # to make a method call
+      if args.empty?
+        element = __typedeaf_varstack__.last
+
+        # If our stack is empty then we'll get a nil element back, making sure
+        # we only call into __typedeaf_varstack__ once for the #method_missing
+        # invocation
+        unless element.nil?
+          method_name = element.first
+          # The top of our stack contains something that we want
+          if self.class.__typedeaf_method_parameters__[method_name][varname]
+            return element.last[varname]
+          end
+        end
+      end
+
+      return super
+    end
+
+    private
+
+    # Access the current thread's and instance's varstack
+    #
+    # Since we're inside of an object instance already, we should make sure
+    # that we can isolate the method's varstack for our current thread and
+    # instance together.
+    #
+    # Instaed of using a thread local by itself, which would not provide the
+    # cross-object isolation, and instead of using just an instance variable,
+    # which would require thread-safety locks, serializing all calls into and
+    # out of the instance
+    #
+    # @return [Array] variable stack
+    def __typedeaf_varstack__
+      if @__typedeaf_varstack_id__.nil?
+        @__typedeaf_varstack_id__ = "typedeaf_varstack_#{self.object_id}".to_sym
+      end
+
+      if Thread.current[@__typedeaf_varstack_id__].nil?
+        Thread.current[@__typedeaf_varstack_id__] = []
+      end
+      return Thread.current[@__typedeaf_varstack_id__]
+    end
+
+    # Determine whether the supplied value is an instance of the given class
+    #
+    # @param [Object] value
+    # @param [Class] type Any class
+    def __typedeaf_valid_type?(value, type)
+      return value.is_a? type
+    end
+
+    # Valida
+    def __typedeaf_validate_types(parameters, args)
+      # We need to walk through the list of parameters and their types and
+      # perform type checking on each of them
+      parameter_indices = {}
+      index = 0
+      parameters.each do |param, types|
+        value = args[index]
+        index = index + 1
+
+        __typedeaf_validate_types_for(param, value, types)
+
+        # Adding the index of this parameter's value to our Hash so we can
+        # properly fish it back out when the method_missing magic is being
+        # invoked from within the block
+        parameter_indices[param] = value
+      end
+
+      return parameter_indices
+    end
+
+    # Validate the expected types for a param
+    def __typedeaf_validate_types_for(param, value, types)
+      validated = false
+
+      # If we've received a DefaultArgument, we need to dig into it to get our
+      # types to check back out
+      if types.is_a? Typedeaf::Arguments::DefaultArgument
+        types = types.types
+      end
+
+      if types.is_a? Array
+        types.each do |type|
+          validated = __typedeaf_valid_type? value, type
+          break if validated
+        end
+      else
+        validated = __typedeaf_valid_type? value, types
+      end
+
+      unless validated
+        raise InvalidTypeException,
+            "Expected `#{param}` to be a kind of #{types} but was #{value.class}"
+      end
+    end
+
+    # If we've been given a block, and it's in the params list properly,
+    # then we should just add it to the args as a "positional" argument
+    def __typedeaf_handle_nested_block(parameters, args, block)
+      if block && parameters[:block]
+        args << block
+      end
+      return nil
+    end
+
+    def __typedeaf_handle_default_parameters(parameters, args)
+      # If both parameters and args are of equal size, then we don't have any
+      # defaulted parameters that we need to insert
+      return unless parameters.size > args.size
+
+      # Check to see if we have any defaulted parameters
+      parameters.each do |name, argument|
+        # Unless it's a special kind of argument, skip it
+        next unless argument.is_a? Typedeaf::Arguments::DefaultArgument
+
+        args << argument.value
+      end
+
+      return nil
+    end
+
+    # Validate that we have the right number of positional arguments
+    #
+    # This is only really needed to make sure we're behaving the same
+    # was as natively defined method would
+    def __typedeaf_validate_positionals(parameters, args)
+      if parameters.size != args.size
+        raise ArgumentError,
+          "wrong number of arguments (#{args.size} for #{parameters.size})"
+      end
+      return nil
+    end
+  end
+end

data/lib/typedeaf/version.rb

@@ -1,3 +1,3 @@
 module Typedeaf
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/spec_helper.rb

@@ -1,6 +1,13 @@
 require 'rubygems'
 require 'typedeaf'
 
+require 'rspec'
+require 'rspec/its'
+
 unless RUBY_PLATFORM == 'java'
-  require 'debugger/pry'
+  begin
+    require 'debugger/pry'
+  rescue LoadError
+    puts 'Not loading debugger/pry'
+  end
 end

data/spec/typedeaf_spec.rb

@@ -12,7 +12,7 @@ describe Typedeaf do
     it { should respond_to :define }
   end
 
-  context 'defining typedeaf instance methods' do
+  context 'defining instance methods' do
     subject(:instance) { klass.new }
 
     context 'defining a method with an invalid block' do
@@ -25,7 +25,6 @@ describe Typedeaf do
       end
     end
 
-
     context 'defining a method with no arguments' do
       before :each do
         klass.class_eval do
@@ -42,8 +41,7 @@ describe Typedeaf do
       end
     end
 
-
-    context 'defining a method with arguments' do
+    context 'defining a method with positional arguments' do
       before :each do
         klass.class_eval do
           define :log, message: String do
@@ -69,5 +67,141 @@ describe Typedeaf do
         }.to raise_error(Typedeaf::InvalidTypeException)
       end
     end
+
+    context 'defining a method with multiple acceptable types' do
+      before :each do
+        klass.class_eval do
+          define :log, message: [String, Symbol] do
+            "hello #{message}"
+          end
+        end
+      end
+
+      it { should respond_to :log }
+      it 'should work for different types' do
+        expect(instance.log(:world)).to eql('hello world')
+        expect(instance.log('world')).to eql('hello world')
+      end
+    end
+
+    context 'defining a method with default arguments' do
+      before :each do
+        klass.class_eval do
+          define :log, message: String, level: default(:debug, Symbol) do
+            [message, level].map(&:to_s).join(' ')
+          end
+        end
+      end
+
+      it { should respond_to :log }
+      it 'a default call should use the arguments to create a result' do
+        expect(instance.log('hello')).to eql('hello debug')
+      end
+
+      it 'should be callable multiple times in a row' do
+        3.times do
+          expect(instance.log('hello')).to eql('hello debug')
+        end
+      end
+    end
+
+    context 'defining a recursing method' do
+      before :each do
+        klass.class_eval do
+          define :log, message: [String, Array] do
+            if message.is_a? Array
+              next message.map { |m| self.log(m) }
+            end
+            "hello #{message}"
+          end
+        end
+      end
+
+      it { should respond_to :log }
+
+      it 'should generate the right recursive behavior' do
+        expect(instance.log(['tom', 'jerry'])).to eql(['hello tom',
+                                                       'hello jerry'])
+      end
+    end
+
+    context 'defining a method which accepts a block' do
+      before :each do
+        klass.class_eval do
+          define :log, message: String, block: Proc do
+            block.call
+            'hello proc'
+          end
+        end
+      end
+
+      it { should respond_to :log }
+
+      it 'should return and yield the right thing' do
+        called = false
+        result = nil
+        result = instance.log('hello') do
+          called = true
+        end
+        expect(result).to eql('hello proc')
+        expect(called).to be_truthy
+      end
+    end
+
+    context 'defining a future method' do
+      before :each do
+        klass.class_eval do
+          future :log, message: String do
+            message
+          end
+        end
+      end
+
+      it { should respond_to :log }
+
+      context 'the method result' do
+        let(:msg) { 'hello' }
+        subject(:result) { instance.log(msg) }
+
+        it { should be_kind_of Concurrent::Future }
+
+        it 'should successfully execute' do
+          expect(result.value).to eql msg
+          expect(result.state).to eql(:fulfilled), "Failure: #{result.reason}"
+        end
+      end
+
+      context 'with the wrong parameter types' do
+        it 'should raise immediately' do
+          expect {
+            instance.log(:failboat)
+          }.to raise_error(Typedeaf::InvalidTypeException)
+        end
+      end
+    end
+
+    context 'defining a promise method' do
+      before :each do
+        klass.class_eval do
+          promise :log, message: String do
+            message
+          end
+        end
+      end
+
+      it { should respond_to :log }
+
+      context 'the method result' do
+        let(:msg) { 'hello' }
+        subject(:result) { instance.log(msg) }
+
+        it { should be_kind_of Concurrent::Promise }
+
+        it 'should successfully execute' do
+          expect(result.value).to eql msg
+          expect(result.state).to eql(:fulfilled), "Failure: #{result.reason}"
+        end
+      end
+    end
   end
 end

data/typedeaf.gemspec

@@ -17,6 +17,5 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_dependency 'concurrent-ruby', '~> 0.7.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: typedeaf
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors: 
 - R. Tyler Croy
@@ -9,28 +9,18 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2014-10-24 00:00:00 Z
+date: 2014-10-27 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: bundler
+  name: concurrent-ruby
   requirement: &id001 !ruby/object:Gem::Requirement 
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: "1.7"
-  type: :development
+        version: 0.7.0
+  type: :runtime
   prerelease: false
   version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: rake
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        version: "10.0"
-  type: :development
-  prerelease: false
-  version_requirements: *id002
 description: 
 email: 
 - tyler@monkeypox.org
@@ -43,12 +33,23 @@ extra_rdoc_files: []
 files: 
 - .gitignore
 - .rspec
+- .travis.yml
 - Gemfile
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmarks/bench_helper.rb
+- benchmarks/missing_arguments.rb
+- benchmarks/missing_arguments.txt
+- benchmarks/parameter_calls.rb
+- benchmarks/parameter_calls.txt
+- benchmarks/simple_calls.rb
+- benchmarks/simple_calls.txt
 - lib/typedeaf.rb
+- lib/typedeaf/arguments.rb
+- lib/typedeaf/classmethods.rb
 - lib/typedeaf/errors.rb
+- lib/typedeaf/instancemethods.rb
 - lib/typedeaf/version.rb
 - spec/spec_helper.rb
 - spec/typedeaf_spec.rb
@@ -65,13 +66,13 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - &id003 
+  - &id002 
     - ">="
     - !ruby/object:Gem::Version 
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
-  - *id003
+  - *id002
 requirements: []
 
 rubyforge_project: