rubype 0.2.6 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 942f53bc7020fb73e9af0158cd6c5d75fa7476f7
-  data.tar.gz: e1fe176b85235b86007b967c040d5971a3851093
+  metadata.gz: 11e9ed5d164e542b00c10907afbe3267e85782d4
+  data.tar.gz: 9fd19b2b530147fb64d00e1f35a10d654c830f9a
 SHA512:
-  metadata.gz: 5c60d752bd40eedcb3a85163d3c92d091f2a2e5e0098dd35afd61412a42cbec86416b67bec1cff60fa087b20b8eccabf9f413294e179dff9fed2d1dfe7ab45c0
-  data.tar.gz: f62bfe664a071c7f5c86490f708b483da6b5e837530cfc843f388c50938b7c0e61bd99f76f7fc2acb1f595acb292158d12ff0277e3a9fe410240a19fce2be064
+  metadata.gz: 727672e8759985e9d1a5dabbfe6082c9637bf43897028783d513ce24ca5ce697da54fde51e47c334de55e0b1a7b87390e3c0bdebf3fbc51224bfd9f515d405d8
+  data.tar.gz: f0c745f01fc40523eab21e642c0d50368920304564bf14443f09c55ec693e604a5baf26ff553c6bafa32d551e608d38dc2f5925ad5e6a7433a423accff537b45

data/.gitignore

@@ -12,3 +12,4 @@
 *.o
 *.a
 mkmf.log
+/vendor/

data/.travis.yml

@@ -1,9 +1,13 @@
 language: ruby
+sudo: false
+cache:
+- bundler
+
+bundler:
 rvm:
-  - 2.2.0
-  - 2.1.5
-  - 2.0.0
-  - rbx-2
+  - 2.2
+  - 2.1
+  - 2.0
   - ruby-head
   # - jruby-head
 notifications:

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## CHANGELOG
+
+### 0.3.0
+
+* First release with C ext.

data/Gemfile

@@ -1,4 +1,5 @@
 source 'https://rubygems.org'
 
 gem 'pry'
+gem 'benchmark-ips'
 gemspec

data/README.md

@@ -246,25 +246,44 @@ This gem requires Ruby 2.0.0+.
 
 ### Contributing
 
-Fork it ( https://github.com/[my-github-username]/rubype/fork )
+* I really wanna make Rubype elegant source code.
 
-Create your feature branch (`git checkout -b my-new-feature`)
+* Any feature or comments are welcome.
+
+#### How to develop
+
+Now Rubype is written with 100% Ruby.
+In terms of performance, only core module(https://github.com/gogotanaka/Rubype/blob/develop/lib/rubype.rb#L4-L80) will be translate to C.
+
+Only two API will be translate to C, it means you don't need to know what C dose!
+
+1. Fork it ( https://github.com/[my-github-username]/rubype/fork )
+
+2. Create your feature branch (`git checkout -b my-new-feature`)
 
     $ bundle install --path vendor/bundle
 
-Commit your changes (`git commit -am 'Add some feature'`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+
+4. Run tests
 
     $ bundle exec rake test
 
     ......
 
-    Finished in 0.010961s, 547.3953 runs/s, 5017.7903 assertions/s.
+5. Run benchmerk(optional)
+
+    $ bundle exec rake bm
 
-    7 runs, 61 assertions, 0 failures, 0 errors, 0 skips
+    ......
 
-Push to the branch (`git push origin my-new-feature`)
+6. Push to the branch (`git push origin my-new-feature`)
 
-Create a new Pull Request to `develop` branch
+7. Create a new Pull Request to `develop` branch
 
 ## Credits
 [@chancancode](https://github.com/chancancode) and [This article](http://blog.codeclimate.com/blog/2014/05/06/gradual-type-checking-for-ruby/) first brought this to my attention. I've stolen some idea from them.
+
+## License
+
+MIT license (© 2015 Kazuki Tanaka)

data/Rakefile

@@ -1,8 +1,57 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
+require "rake/extensiontask"
 
+#  Test
+#-----------------------------------------------
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
 end
 
-task default: :test
+#  Compile C extension
+#-----------------------------------------------
+Rake::ExtensionTask.new("rubype") do |ext|
+  ext.lib_dir = "lib/rubype"
+end
+
+task :compile_and_test do
+  Rake::Task['compile'].invoke
+  Rake::Task['test'].invoke
+end
+
+#  Benchmark
+#-----------------------------------------------
+desc "Compare with pure ruby"
+task :benchmark do
+  require "benchmark/ips"
+  require "rubype"
+  require "rubype/version"
+
+  puts "ruby version: #{RUBY_VERSION}"
+  class PureClass
+    def sum(x, y)
+      x + y
+    end
+  end
+  pure_instance = PureClass.new
+
+  puts "rubype version: #{Rubype::VERSION}"
+  class RubypeClass
+    def sum(x, y)
+      x + y
+    end
+    typesig :sum, [Numeric, Numeric] => Numeric
+  end
+  rubype_instance = RubypeClass.new
+
+  Benchmark.ips do |x|
+    x.report('Pure Ruby') { pure_instance.sum(4, 2) }
+    x.report('Rubype') { rubype_instance.sum(4, 2) }
+
+    x.compare!
+  end
+end
+task bm: :benchmark
+
+
+task default: :compile_and_test

data/ext/rubype/rubype.c

@@ -1,38 +1,100 @@
 #include "rubype.h"
 
-VALUE rb_mRubype, rb_cAny, rb_mBoolean, rb_cTypePair;
+VALUE rb_mRubype, rb_cContract, rb_eRubypeArgumentTypeError, rb_eRubypeReturnTypeError, rb_eInvalidTypesigError;
+static ID id_is_a_p, id_to_s, id_meth, id_owner, id_arg_types, id_rtn_type;
 
-#define STR2SYM(x) ID2SYM(rb_intern(x))
+#define error_fmt "\nfor %"PRIsVALUE"\nExpected: %"PRIsVALUE"\nActual:   %"PRIsVALUE""
+#define unmatch_type_p(obj, type_info) !(match_type_p(obj, type_info))
+
+int match_type_p(VALUE obj, VALUE type_info)
+{
+  switch (TYPE(type_info)) {
+    case T_SYMBOL: return rb_respond_to(obj, rb_to_id(type_info));
+                   break;
+
+    case T_MODULE: return (int)rb_funcall(obj, id_is_a_p, 1, type_info);
+                   break;
+
+    case T_CLASS:  return (int)rb_funcall(obj, id_is_a_p, 1, type_info);
+                   break;
+
+    default:       return 0;
+                   break;
+  }
+}
+
+VALUE expected_mes(VALUE expected)
+{
+  switch (TYPE(expected)) {
+    case T_SYMBOL: return rb_sprintf("respond to #%"PRIsVALUE, expected);
+                   break;
+
+    case T_MODULE: return rb_funcall(expected, id_to_s, 0);
+                   break;
+
+    case T_CLASS:  return rb_funcall(expected, id_to_s, 0);
+                   break;
+
+    default:       return rb_str_new2("");
+                   break;
+  }
+}
 
 static VALUE
-rb_mod_prepend(int argc, VALUE *argv, VALUE module)
+rb_rubype_assert_type(VALUE self, VALUE args, VALUE rtn)
 {
   int i;
-  ID id_prepend_features, id_prepended;
-
-  CONST_ID(id_prepend_features, "prepend_features");
-  CONST_ID(id_prepended, "prepended");
-  for (i = 0; i < argc; i++)
-    Check_Type(argv[i], T_MODULE);
-    while (argc--) {
-      rb_funcall(argv[argc], id_prepend_features, 1, module);
-      rb_funcall(argv[argc], id_prepended, 1, module);
+  VALUE target;
+  VALUE meth_caller, meth, arg_types, arg_type, rtn_type, arg;
+
+  meth_caller = rb_ivar_get(self, id_owner);
+  meth        = rb_ivar_get(self, id_meth);
+  arg_types   = rb_ivar_get(self, id_arg_types);
+  rtn_type    = rb_ivar_get(self, id_rtn_type);
+
+  for (i=0; i<RARRAY_LEN(args); i++) {
+    arg      = rb_ary_entry(args, i);
+    arg_type = rb_ary_entry(arg_types, i);
+
+    if (unmatch_type_p(arg, arg_type)){
+      target = rb_sprintf("%"PRIsVALUE"#%"PRIsVALUE"'s %d argument", meth_caller, meth, i+1);
+      rb_raise(rb_eRubypeArgumentTypeError, error_fmt, target, expected_mes(arg_type), arg);
     }
+  }
+
+  if (unmatch_type_p(rtn, rtn_type)){
+    target = rb_sprintf("%"PRIsVALUE"#%"PRIsVALUE"'s return", meth_caller, meth);
+    rb_raise(rb_eRubypeReturnTypeError, error_fmt, target, expected_mes(rtn_type), rtn);
+  }
+  return rtn;
+}
 
-  return module;
+static VALUE
+rb_rubype_initialize(VALUE self, VALUE arg_types, VALUE rtn_type, VALUE owner, VALUE meth) {
+  rb_ivar_set(self, id_owner,     owner);
+  rb_ivar_set(self, id_meth,      meth);
+  rb_ivar_set(self, id_arg_types, arg_types);
+  rb_ivar_set(self, id_rtn_type,  rtn_type);
+  return Qnil;
 }
 
 void
 Init_rubype(void)
 {
-  // rb_mRubype  = rb_define_module("Rubype");
-  // rb_cAny     = rb_define_class("Any", rb_cObject);
-  // rb_mBoolean = rb_define_module("Boolean");
-  // rb_include_module(rb_cTrueClass, rb_mBoolean);
-  // rb_include_module(rb_cFalseClass, rb_mBoolean);
-  // rb_define_class(
-  //   "TypePair",
-  //   rb_funcall(rb_cStruct, rb_intern("new"), 2, STR2SYM("last_arg_type"), STR2SYM("rtn_type"))
-  // );
-  rb_define_method(rb_cModule, "prepend", rb_mod_prepend, -1);
+  rb_mRubype  = rb_define_module("Rubype");
+
+  rb_eRubypeArgumentTypeError = rb_define_class_under(rb_mRubype, "ArgumentTypeError",   rb_eTypeError);
+  rb_eRubypeReturnTypeError   = rb_define_class_under(rb_mRubype, "ReturnTypeError",     rb_eTypeError);
+  rb_eInvalidTypesigError     = rb_define_class_under(rb_mRubype, "InvalidTypesigError", rb_eTypeError);
+
+  rb_cContract = rb_define_class_under(rb_mRubype, "Contract", rb_cObject);
+  rb_define_method(rb_cContract, "initialize", rb_rubype_initialize, 4);
+  rb_define_method(rb_cContract, "assert_type", rb_rubype_assert_type, 2);
+
+  id_meth      = rb_intern("@meth");
+  id_owner     = rb_intern("@owner");
+  id_arg_types = rb_intern("@arg_types");
+  id_rtn_type  = rb_intern("@rtn_type");
+  id_is_a_p    = rb_intern("is_a?");
+  id_to_s      = rb_intern("to_s");
 }

data/lib/rubype.rb

@@ -1,104 +1,48 @@
-require 'rubype/ordinal'
-# === Rubype core === #
-class Module
-  private
-    def __rubype__
-      prepend (@__rubype__ = Module.new) unless @__rubype__
-      @__rubype__
-    end
-    # typesig :__rubype__, [] => Rubype
-
-    def typesig(meth, type_info_hash)
-      ::Rubype.define_typed_method(self, meth, type_info_hash, __rubype__)
-      self
-    end
-    # typesig :typesig, [Symbol, Hash] => Module
-end
+require_relative 'rubype/version'
+require_relative 'rubype/contract'
 
 module Rubype
-  @@typed_method_info = Hash.new({})
-  class ArgumentTypeError < ::TypeError; end
-  class ReturnTypeError   < ::TypeError; end
+  module TypeInfo; end
+  Module.send(:include, TypeInfo)
+  Symbol.send(:include, TypeInfo)
+  @@typed_methods = Hash.new({})
+
   class << self
     def define_typed_method(owner, meth, type_info_hash, __rubype__)
+      raise InvalidTypesigError unless valid_type_info_hash?(type_info_hash)
       arg_types, rtn_type = *type_info_hash.first
 
-      @@typed_method_info[owner][meth] = { arg_types => rtn_type }
-
+      contract = Contract.new(arg_types, rtn_type, owner, meth)
+      @@typed_methods[owner][meth] = contract
+      method_visibility = get_method_visibility(owner, meth)
       __rubype__.send(:define_method, meth) do |*args, &block|
-        ::Rubype.assert_arg_type(self, meth, args, arg_types, caller)
-        super(*args, &block).tap do |rtn|
-          ::Rubype.assert_rtn_type(self, meth, rtn, rtn_type, caller)
-        end
+        contract.assert_type(args, super(*args, &block))
       end
-    end
 
-    def assert_arg_type(meth_caller, meth, args, type_infos, caller_trace)
-      args.zip(type_infos).each.with_index(1) do |(arg, type_info), i|
-        unless match_type?(arg, type_info)
-          raise ArgumentTypeError,
-            error_mes("#{meth_caller.class}##{meth}'s #{i}#{ordinal(i)} argument", type_info, arg, caller_trace)
-        end
-      end
+      __rubype__.send(method_visibility, meth)
     end
 
-    def assert_rtn_type(meth_caller, meth, rtn, type_info, caller_trace)
-      unless match_type?(rtn, type_info)
-        raise ReturnTypeError,
-          error_mes("#{meth_caller.class}##{meth}'s return", type_info, rtn, caller_trace)
+    def get_method_visibility(owner, meth)
+      case
+      when owner.private_method_defined?(meth)
+        :private
+      when owner.protected_method_defined?(meth)
+        :protected
+      else
+        :public
       end
     end
 
-    def typed_method_info
-      @@typed_method_info
+    def typed_methods
+      @@typed_methods
     end
 
     private
-      def match_type?(obj, type_info)
-        case type_info
-        when Module; (obj.is_a?(type_info) || type_info == Any)
-        when Symbol; (obj.respond_to?(type_info))
-        end
-      end
-
-      def error_mes(target, expected, actual, caller_trace)
-        expected_mes = case expected
-        when Module; expected
-        when Symbol; "respond to :#{expected}"
-        end
-        <<-ERROR_MES
-for #{target}
-Expected: #{expected_mes},
-Actual:   #{actual.inspect}
-
-#{caller_trace.join("\n")}
-        ERROR_MES
+      def valid_type_info_hash?(type_info_hash)
+        return false unless type_info_hash.is_a?(Hash)
+        type_info_hash.first[0].is_a?(Array)
       end
   end
 end
-# === end (only 79 lines :D)=== #
-
-# Builtin Contracts
-class  Any;     end
-module Boolean; end
-TrueClass.send(:include, Boolean)
-FalseClass.send(:include, Boolean)
-
-class Method
-  def type_info
-    if methods_hash = Rubype.typed_method_info[owner]
-      methods_hash[name]
-    end
-  end
-  typesig :type_info, [] => Hash
 
-  def arg_types
-    type_info.first.first if type_info
-  end
-  typesig :arg_types, [] => Array
-
-  def return_type
-    type_info.first.last if type_info
-  end
-  typesig :arg_types, [] => Any
-end
+require_relative 'rubype/core_ext'

data/lib/rubype/contract.rb

@@ -0,0 +1,10 @@
+require_relative 'ordinalize'
+require 'rubype/rubype'
+
+class Rubype::Contract
+  attr_accessor :arg_types, :rtn_type
+
+  def info
+    { @arg_types => @rtn_type }
+  end
+end

data/lib/rubype/core_ext.rb

@@ -0,0 +1,35 @@
+module Boolean; end
+TrueClass.send(:include, Boolean)
+FalseClass.send(:include, Boolean)
+Any = BasicObject
+
+class Module
+  private
+
+  def __rubype__
+    prepend (@__rubype__ = Module.new) unless @__rubype__
+    @__rubype__
+  end
+
+  def typesig(meth, type_info_hash)
+    ::Rubype.define_typed_method(self, meth, type_info_hash, __rubype__)
+    self
+  end
+end
+
+class Method
+  def type_info
+    Rubype.typed_methods[owner][name].info
+  end
+  typesig :type_info, [] => Hash
+
+  def arg_types
+    Rubype.typed_methods[owner][name].arg_types
+  end
+  typesig :arg_types, [] => Array
+
+  def return_type
+    Rubype.typed_methods[owner][name].rtn_type
+  end
+  typesig :arg_types, [] => Any
+end

data/lib/rubype/ordinalize.rb

@@ -0,0 +1,13 @@
+# Borrowed from ActiveSupport::Inflector
+def ordinalize(number)
+  if (11..13).include?(number % 100)
+    "#{number}th"
+  else
+    case number % 10
+      when 1 then "#{number}st"
+      when 2 then "#{number}nd"
+      when 3 then "#{number}rd"
+      else        "#{number}th"
+    end
+  end
+end

data/lib/rubype/version.rb

@@ -1,3 +1,3 @@
 module Rubype
-  VERSION = "0.2.6"
+  VERSION = "0.3.0"
 end

data/rubype.gemspec

@@ -15,6 +15,7 @@ Gem::Specification.new do |spec|
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.extensions    = ["ext/rubype/extconf.rb"]
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
@@ -23,4 +24,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "minitest"
+  spec.add_development_dependency "rake-compiler"
 end

data/test/test_rubype.rb

@@ -1,10 +1,5 @@
 require 'minitest_helper'
-class TypePair
-  def to_s
-    "#{last_arg_type} => #{rtn_type}"
-  end
-end
-class TestRubype < MiniTest::Unit::TestCase
+class TestRubype < Minitest::Test
   def setup
     @string  = 'str'
     @numeric = 1
@@ -109,6 +104,34 @@ class TestRubype < MiniTest::Unit::TestCase
     #assert_equal err.message, %|Expected MyClass#test_mth's 2nd argument to be Numeric but got "2" instead|
   end
 
+  def test_respects_method_visibility
+    klass = Class.new.class_eval <<-RUBY_CODE
+      private
+      def private_mth(n1, n2)
+      end
+      typesig :private_mth, [Numeric, Numeric] => NilClass
+
+      protected
+      def protected_mth(n1, n2)
+      end
+      typesig :protected_mth, [Numeric, Numeric] => NilClass
+    RUBY_CODE
+    instance = klass.new
+
+    # assert_raises(NoMethodError){ instance.private_mth(1,2) }
+    assert_raises(NoMethodError){ instance.protected_mth(1,2) }
+  end
+
+  def test_invalid_typesig
+    assert_raises(Rubype::InvalidTypesigError) do
+       Class.new.class_eval <<-RUBY_CODE
+        def mth(n1, n2)
+        end
+        typesig :private_mth, Numeric => NilClass
+      RUBY_CODE
+    end
+  end
+
   private
     def assert_equal_to_s(str, val)
       assert_equal str, val.to_s

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rubype
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.0
 platform: ruby
 authors:
 - gogotanaka
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-13 00:00:00.000000000 Z
+date: 2015-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -52,18 +52,33 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Ruby with type.
 email:
 - mail@tanakakazuki.com
 executables:
 - rubype
-extensions: []
+extensions:
+- ext/rubype/extconf.rb
 extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
-- LICENSE.txt
 - README.md
 - Rakefile
 - bin/rubype
@@ -71,7 +86,9 @@ files:
 - ext/rubype/rubype.c
 - ext/rubype/rubype.h
 - lib/rubype.rb
-- lib/rubype/ordinal.rb
+- lib/rubype/contract.rb
+- lib/rubype/core_ext.rb
+- lib/rubype/ordinalize.rb
 - lib/rubype/version.rb
 - rubype.gemspec
 - test/minitest_helper.rb

data/LICENSE.txt

@@ -1,22 +0,0 @@
-Copyright (c) 2014 gogotanaka
-
-MIT License
-
-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/lib/rubype/ordinal.rb

@@ -1,13 +0,0 @@
-# Borrowed from ActiveSupport::Inflector
-def ordinal(number)
-  if (11..13).include?(number % 100)
-    "th"
-  else
-    case number % 10
-      when 1; "st"
-      when 2; "nd"
-      when 3; "rd"
-      else    "th"
-    end
-  end
-end