rubycube 0.2.1 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 103592cc3433918459db3c3aaa11f5da53bfa839
-  data.tar.gz: 9d40125b33e7f53ac0754b969ac715825d5e0b5e
+  metadata.gz: c136c0dc0b938dbd1ffe392203ae39781e7ebaf1
+  data.tar.gz: 355531cf507cee9bd3c68a69e7ebe59255ef6773
 SHA512:
-  metadata.gz: b63f85ed3b18c48159ed5b926f7396a0900c3f704b0e1e8293d993ea5b95f26b8cecbce20b3df2160673701c5d198a77daa6d60cd4c3e6cd85b2bb41f4104813
-  data.tar.gz: a2452695f47eb3c3c1b231fe5f9f9c0526a1983518b0fa87ad90637274ac164127a800a2226a6fa1b2f64faed066b61cbabfb3dc082676f64c9ca089771ca3ac
+  metadata.gz: 5064b3d52cbe81ee4429a6054d33046b279f0b6fdcb52d1667503d82e17fb6667157c1bc7ace38d7dde154388340c38dac20d2f779c02fd8241070040f56969a
+  data.tar.gz: 2a6b3e2fa5c0282e5d2529a81c22722e57a427fa9059112fccb6edfb8a4405767ad4b92cf81acb853272cfa283b3552297386aa92ce211ca9f6bf1d76bf6dd8f

data/README.md

@@ -6,13 +6,15 @@ It provides interfaces, traits and runtime interface checks in Ruby
 `gem install rubycube` OR
 `gem rubycube` in your Gemfile
 
+### Theory
+
+http://web.archive.org/web/20061209142330/http://www.iam.unibe.ch/~scg/Archive/Papers/Scha02bTraits.pdf
+
 ### Synopsis
 See [this annotated example](examples/demo.rb)
 
 ### General Notes
 
-Subinterfaces work as well. 
-
 Since runtime checks are meant to be invoked for every invocation of a method,
 there is a runtime overhead associated which may not be desirable in
 production. Hence these checks are guarded by an environment variable

data/cube.gemspec

@@ -2,7 +2,7 @@ require 'rubygems'
 
 Gem::Specification.new do |spec|
   spec.name       = 'rubycube'
-  spec.version    = '0.2.1'
+  spec.version    = '0.3.0'
   spec.author     = 'Aditya Godbole'
   spec.license    = 'Artistic 2.0'
   spec.email      = 'code.aa@gdbl.me'

data/examples/demo.rb

@@ -1,12 +1,12 @@
 # run as `RUBY_CUBE_TYPECHECK= 1 ruby examples/demo.rb`
 require_relative '../lib/cube'
 
-Adder = interface {
+Adder = Cube.interface {
   # sum is a method that takes an array of Integer and returns an Integer
   proto(:sum, [Integer]) { Integer }
 }
 
-Calculator = interface {
+Calculator = Cube.interface {
   # interfaces can be composed
   extends Adder
   # method fact takes an Integer and returns an Integer
@@ -15,7 +15,7 @@ Calculator = interface {
   proto(:pos, [Integer], Integer) { [Integer, NilClass].to_set }
 }
 
-class SimpleCalc
+class SimpleCalcImpl
   def fact(n)
     (2..n).reduce(1) { |m, e| m * e }
   end
@@ -27,63 +27,55 @@ class SimpleCalc
   def pos(arr, i)
     arr.index(i)
   end
-
-#  implements Calculator #, runtime_checks: false # default is true
 end
 
-c = SimpleCalc.as_interface(Calculator).new
-# If SimpleCalc does not have `implements Calculator`, but its methods match the interface
-# you can "cast" it to Calculator - `SimpleCalc.as_interface(Calculator).new`
-# This is useful for casting classes that you did not write
+SimpleCalc = Cube[SimpleCalcImpl].as_interface(Calculator)
+# OR
+# SimpleCalc = Cube.from(SimpleCalcImpl).as_interface(Calculator)
+c = SimpleCalc.new
 p c.sum([1, 2])
 p c.pos([1, 2, 3], 4)
 
-AdvancedCalculator = interface {
+AdvancedCalculator = Cube.interface {
   extend Calculator
   proto(:product, Integer, Integer) { Integer }
+  proto(:avg, [Integer]) { Float }
 }
 
-module AdvancedCalcT
-  extend Cube::Trait
+ProductCalcT = Cube.trait do
   def product(a, b)
     ret = 0
     a.times { ret = sum([ret, b]) }
     ret
   end
-
-  def sum; end # A class method always takes precedence, no conflict here
-  def foo; end # this conflicts with DummyCalcT. Needs to be aliased (see below)
-  def bar; end # this conflicts with DummyCalcT. Needs to be aliased (see below)
-
+  # This specifies the interface that the including Class must satisfy in order for
+  # this trait to work properly.
+  # Eg, the product method above uses `sum`, which it expects to get from the including
+  # class
   requires_interface Adder # Note that this will give an error if SimpleCalc#sum is removed
                            # even if this trait itself has a `sum` method
 end
 
-module DummyCalcT
-  extend Cube::Trait
-  def sum; end # this method conflicts with AdvancedCalcT, but SimpleCalc#sum takes precedence
-  def foo; end
-  def bar; end
-  class << self
-    def included(_)
-      $stderr.puts "Works like a regular module as well"
-    end
+StatsCalcT = Cube.trait do
+  def product; end
+
+  def avg(arr)
+    arr.reduce(0, &:+) / arr.size
   end
 end
-
+#
 # This is how we compose behaviours
 # AdvancedCalc is a class which mixes traits AdvancedCalcT and DummyCalcT
 # into SimpleCalc and implements the interface AdvancedCalculator
 # To avoid conflicts, alias methods in AdvancedCalcT (otherwise error will be raised)
 # One can also suppress methods in DummyCalcT
-AdvancedCalc = SimpleCalc.with_trait(AdvancedCalcT,
-                                     aliases: { foo: :adfoo, bar: :adbar })
-                         .with_trait(DummyCalcT, suppresses: [:foo, :bar])
+AdvancedCalc = SimpleCalc.with_trait(ProductCalcT)
+                         .with_trait(StatsCalcT, suppress: [:product])
                          .as_interface(AdvancedCalculator)
-
 sc = AdvancedCalc.new
 p sc.product(3, 2)
 
+__END__
 
 # Benchmarks. Run with RUBY_INTERFACE_TYPECHECK=0 and 1 to compare
 

data/examples/traits.rb

@@ -0,0 +1,69 @@
+ENV['RUBY_CUBE_TYPECHECK'] = "1"
+require_relative '../lib/cube'
+EmailNotifierT = Cube.trait do
+  def notify
+    puts "email sent to #{email}"
+  end
+  requires_interface Cube.interface {
+    proto(:email) { String }
+  }
+end
+
+AndroidNotifierT = Cube.trait do
+  def notify
+    puts "push notification sent to android device #{mobile_number}"  
+  end
+
+  requires_interface Cube.interface {
+    proto(:mobile_number) { String }
+  }
+end
+
+IOSNotifierT = Cube.trait do
+  def notify
+    puts "push notification sent to ios device #{mobile_number}"  
+  end
+
+  requires_interface Cube.interface {
+    proto(:mobile_number) { String }
+  }
+end
+
+CombinedNotifierT = Cube.trait do
+  def notify
+    mobile_notify
+    email_notify
+  end
+  requires_interface Cube.interface {
+    proto(:mobile_notify)
+    proto(:email_notify)
+  }
+end
+
+AndroidCombinedNotifier = Cube.trait.with_trait(AndroidNotifierT, rename: { notify: :mobile_notify })
+                              .with_trait(EmailNotifierT, rename: { notify: :email_notify })
+                              .with_trait(CombinedNotifierT)
+
+IOSCombinedNotifier = Cube.trait.with_trait(IOSNotifierT, rename: { notify: :mobile_notify })
+                          .with_trait(EmailNotifierT, rename: { notify: :email_notify })
+                          .with_trait(CombinedNotifierT)
+
+MobileEmailUser = Cube.interface {
+  proto(:email) { String }
+  proto(:mobile_number) { String }
+}
+
+Services = {
+  android: AndroidCombinedNotifier.wrap(MobileEmailUser),
+  ios: IOSCombinedNotifier.wrap(MobileEmailUser)
+}
+User = Struct.new(:email, :mobile_number, :type)
+Cube.mark_interface!(User, MobileEmailUser)
+CubeUser = Cube[User].as_interface(MobileEmailUser)
+
+u1 = User.new('u1@foo.com', '1234567890', :android)
+u2 = User.new('u2@foo.com', '1234567899', :ios)
+
+[u1, u2].each do |u|
+  Services[u.type].new(u).notify
+end

data/lib/cube.rb

@@ -1,2 +1,3 @@
 require_relative 'cube/interfaces'
 require_relative 'cube/traits'
+require_relative 'cube/toplevel'

data/lib/cube/interfaces.rb

@@ -5,22 +5,45 @@ require 'set'
 #
 # http://java.sun.com/docs/books/tutorial/java/concepts/interface.html
 #
+
+# Top level module for RubyCube
 module Cube
   module Interface
-    # The version of the interface library.
-    Interface::VERSION = '0.2.0'
 
-    # Raised if a class or instance does not meet the interface requirements.
+    def self.match_specs(i1specs, i2specs)
+      i1specs.each do |meth, i1spec|
+        i2spec = i2specs[meth]
+        raise InterfaceMatchError, "Method `#{meth}` not found" unless i2spec
+        i2_in = i2spec[:in]
+        i1_in = i1spec[:in]
+        if i1_in && (!i2_in || i1_in.size != i2_in.size)
+          raise InterfaceMatchError, "Method `#{meth}` prototype does not match"
+        end
+        (i1_in || []).each_index do |i|
+          Cube.check_type_spec(i1_in[i], i2_in[i]) { |t1, t2| t2 == t1 }
+        end
+        i1_out = i1spec[:out]
+        if i1_out
+          i2_out = i2spec[:out]
+          raise InterfaceMatchError, "Method `#{meth}` prototype does not match" unless i2_out
+          Cube.check_type_spec(i1_out, i2_out) { |t1, t2| t2 == t1 }
+        end
+      end
+    end
+
+    # Exceptions thrown while checking interfaces
     class MethodMissing < RuntimeError; end
     class PrivateVisibleMethodMissing < MethodMissing; end
     class PublicVisibleMethodMissing < MethodMissing; end
     class MethodArityError < RuntimeError; end
     class TypeMismatchError < RuntimeError; end
+    class InterfaceMatchError < RuntimeError; end
 
     alias :extends :extend
 
     private
 
+    # convert a proc to lambda
     def convert_to_lambda &block
       obj = Object.new
       obj.define_singleton_method(:_, &block)
@@ -33,20 +56,20 @@ module Cube
       included(obj)
     end
 
+    # This is called before `included`
     def append_features(mod)
       return super if Interface === mod
-  
+
       # Is this a sub-interface?
+      # Get specs from super interfaces
       inherited = (self.ancestors-[self]).select{ |x| Interface === x }
       inherited_ids = inherited.map{ |x| x.instance_variable_get('@ids') }
-  
+
       # Store required method ids
-      inherited_specs = map_spec(inherited_ids.flatten)
-      specs = @ids.merge(inherited_specs)
+      specs = to_spec
       ids = @ids.keys + map_spec(inherited_ids.flatten).keys
       @unreq ||= []
-  
-  
+
       # Iterate over the methods, minus the unrequired methods, and raise
       # an error if the method has not been defined.
       mod_public_instance_methods = mod.public_instance_methods(true)
@@ -57,79 +80,87 @@ module Cube
         end
         spec = specs[id]
         if spec.is_a?(Hash) && spec.key?(:in) && spec[:in].is_a?(Array)
+          # Check arity and replace method with type checking method
           replace_check_method(mod, id, spec[:in], spec[:out])
         end
       end
-  
-      inherited_private_ids = inherited.map{ |x| x.instance_variable_get('@private_ids') }
-      # Store required method ids
-      private_ids = @private_ids.keys + map_spec(inherited_private_ids.flatten).keys
-  
-      # Iterate over the methods, minus the unrequired methods, and raise
-      # an error if the method has not been defined.
-      mod_all_methods = mod.instance_methods(true) + mod.private_instance_methods(true)
-  
-      (private_ids - @unreq).uniq.each do |id|
-        id = id.to_s if RUBY_VERSION.to_f < 1.9
-        unless mod_all_methods.include?(id)
-          raise Interface::PrivateVisibleMethodMissing, "#{mod}: #{self}##{id}"
-        end
-      end
-  
+
       super mod
     end
-  
+
+    # Stash a method in the module for future checks
+    def stash_method(mod, id)
+      unless mod.instance_variable_defined?('@__interface_stashed_methods')
+        mod.instance_variable_set('@__interface_stashed_methods', {})
+      end
+      mod.instance_variable_get('@__interface_stashed_methods')[id] = mod.instance_method(id)
+    end
+
+    # Get a stashed method for the module
+    def stashed_method(mod, id)
+      return nil unless mod.instance_variable_defined?('@__interface_stashed_methods')
+      mod.instance_variable_get('@__interface_stashed_methods')[id]
+    end
+
+    # Check arity
+    # Replace with type_checking method if demanded
     def replace_check_method(mod, id, inchecks, outcheck)
-      orig_method = mod.instance_method(id)
-  
+      # Get the previously stashed method if it exists
+      stashed_meth = stashed_method(mod, id)
+      orig_method = stashed_meth || mod.instance_method(id)
       unless mod.instance_variable_defined?("@__interface_arity_skip") \
         && mod.instance_variable_get("@__interface_arity_skip")
         orig_arity = orig_method.parameters.size
         check_arity = inchecks.size
         if orig_arity != check_arity
           raise Interface::MethodArityError,
-            "#{mod}: #{self}##{id} arity mismatch: #{orig_arity} instead of #{check_arity}"
+                "#{mod}: #{self}##{id} arity mismatch: #{orig_arity} instead of #{check_arity}"
         end
       end
-  
+
+      # return if we are not doing runtime checks for this class
       unless ENV['RUBY_CUBE_TYPECHECK'].to_i > 0 \
         && mod.instance_variable_defined?("@__interface_runtime_check") \
         && mod.instance_variable_get("@__interface_runtime_check")
         return
       end
+      # if the stashed method exists, it already exists. return
+      return if stashed_meth
       iface = self
+      stash_method(mod, id)
+      # replace method with a type checking wrapper
       mod.class_exec do
+        # random alias name to avoid conflicts
         ns_meth_name = "#{id}_#{SecureRandom.hex(3)}".to_sym 
         alias_method ns_meth_name, id
+        # The type checking wrapper
         define_method(id) do |*args|
           args.each_index do |i|
+            # the value and expected type of the arg
             v, t = args[i], inchecks[i]
             begin
-              check_type(t, v)
+              Cube.check_type(t, v)
             rescue Interface::TypeMismatchError => e
               raise Interface::TypeMismatchError,
-                "#{mod}: #{iface}##{id} (arg: #{i}): #{e.message}"
+                    "#{mod}: #{iface}##{id} (arg: #{i}): #{e.message}"
             end
           end
+          # types look good, call the original method
           ret = send(ns_meth_name, *args)
+          # check return type if it exists
           begin
-            check_type(outcheck, ret) if outcheck
+            Cube.check_type(outcheck, ret) if outcheck
           rescue Interface::TypeMismatchError => e
             raise Interface::TypeMismatchError,
               "#{mod}: #{iface}##{id} (return): #{e.message}"
           end
+          # looks good, return
           ret
         end
       end
     end
-  
-    #  def verify_arity(mod, meth)
-    #    arity = mod.instance_method(meth).arity
-    #    unless arity == @ids[meth]
-    #      raise Interface::MethodArityError, "#{mod}: #{self}##{meth}=#{arity}. Should be #{@ids[meth]}"
-    #    end
-    #  end
-  
+
+    # massage array spec and hash spec into hash spec
     def map_spec(ids)
       ids.reduce({}) do |res, m|
         if m.is_a?(Hash)
@@ -139,7 +170,8 @@ module Cube
         end
       end
     end
-  
+
+    # validate the interface spec is valid
     def validate_spec(spec)
       [*spec].each do |t|
         if t.is_a?(Array)
@@ -151,8 +183,9 @@ module Cube
         end
       end
     end
-  
+
     public
+
     # Accepts an array of method names that define the interface.  When this
     # module is included/implemented, those method names must have already been
     # defined.
@@ -160,14 +193,30 @@ module Cube
     def required_public_methods
       @ids.keys
     end
-  
+
+    def to_spec
+      inherited = (self.ancestors-[self]).select{ |x| Interface === x }
+      inherited_ids = inherited.map{ |x| x.instance_variable_get('@ids') }
+
+      # Store required method ids
+      inherited_specs = map_spec(inherited_ids.flatten)
+      @ids.merge(inherited_specs)
+    end
+
+    def assert_match(intf)
+      raise ArgumentError, "#{intf} is not a Cube::Interface" unless intf.is_a?(Interface)
+      intf_specs = intf.to_spec
+      self_specs = to_spec
+      Interface.match_specs(self_specs, intf_specs)
+    end
+
     def proto(meth, *args)
       out_spec = yield if block_given?
       validate_spec(args)
       validate_spec(out_spec) if out_spec
-      @ids.merge!({ meth.to_sym => { in: args, out: out_spec }})
+      @ids.merge!({ meth.to_sym => { in: args, out: out_spec } })
     end
-  
+
     def public_visible(*ids)
       unless ids.all? { |id| id.is_a?(Symbol) || id.is_a?(String) }
         raise ArgumentError, "Arguments should be strings or symbols"
@@ -175,23 +224,21 @@ module Cube
       spec = map_spec(ids)
       @ids.merge!(spec)
     end
-  
-    def private_visible(*ids)
-      unless ids.all? { |id| id.is_a?(Symbol) || id.is_a?(String) }
-        raise ArgumentError, "Arguments should be strings or symbols"
+
+    def impotent
+      cl = Cube.interface {}.extend(self)
+      cl.module_exec do
+        def extend_object(mod)
+          super
+        end
+        def append_features(mod)
+          super
+        end
       end
-      spec = map_spec(ids)
-      @private_ids.merge!(spec)
+      cl
     end
-    # Accepts an array of method names that are removed as a requirement for
-    # implementation. Presumably you would use this in a sub-interface where
-    # you only wanted a partial implementation of an existing interface.
-    #
-    def unrequired_methods(*ids)
-      @unreq ||= []
-      @unreq += ids
-    end
-  
+
+    # creates a shell object for testing
     def shell
       ids = @ids
       unreq = @unreq
@@ -200,67 +247,9 @@ module Cube
           define_method(m) { |*args| }
         end
       end
-      cls.send(:shell_implements, self)
+      Cube[cls].send(:shell_implements, self)
     end
   end
 end
 
-class Object
-  def interface(&block)
-    mod = Module.new
-    mod.extend(Cube::Interface)
-    mod.instance_variable_set('@ids', {})
-    mod.instance_variable_set('@private_ids', {})
-    mod.instance_eval(&block)
-    mod
-  end
-
-  if ENV['RUBY_CUBE_TYPECHECK'].to_i > 0
-    def check_type(t, v)
-      if t.is_a?(Set)
-        unless t.any? { |tp| check_type(tp, v) rescue false }
-          raise Cube::Interface::TypeMismatchError,
-            "#{v.inspect} is not any of #{tp.to_a}" unless v.is_a?(tp)
-        end
-        return
-      end
-      if t.is_a? Array
-        raise Cube::Interface::TypeMismatchError,
-          "#{v} is not an Array" unless v.is_a? Array
-        check_type(t.first, v.first)
-        check_type(t.first, v.last)
-        return
-      end
-      raise Cube::Interface::TypeMismatchError, "#{v.inspect} is not type #{t}" unless v.is_a? t
-      true
-    end
-  else
-    def check_type(*_); end
-  end
-end
-
-class Module
-  def implements(mod, runtime_checks: true)
-    unless is_a? Class
-      raise "Non-Class modules should not implement interfaces"
-    end
-    instance_variable_set(:@__interface_runtime_check, true) if runtime_checks
-    include(mod)
-  end
-
-  def as_interface(iface, runtime_checks: true)
-    clone.implements(iface, runtime_checks: runtime_checks)
-  end
-
-  def assert_implements(iface)
-    clone.implements(iface, false)
-  end
-
-  def shell_implements(mod)
-    instance_variable_set(:@__interface_runtime_check, false)
-    instance_variable_set(:@__interface_arity_skip, true)
-    include(mod)
-  end
-end
-
 

data/lib/cube/toplevel.rb

@@ -0,0 +1,104 @@
+module Cube
+  def self.mark_interface!(cls, iface)
+    Cube[cls].as_interface(iface, runtime_checks: false)
+    cl_iface = iface.impotent
+    cls.include(cl_iface)
+  end
+
+  def self.[](mod)
+    return mod if mod.is_a?(CubeMethods)
+    unless mod.is_a?(Class)
+      raise ArgumentError, "Only classes can be be converted to Cube classes"
+    end
+    Class.new(mod).extend(CubeMethods)
+  end
+
+  class << self
+    alias_method :from, :[]
+  end
+
+  def self.interface(&block)
+    mod = Module.new
+    mod.extend(Cube::Interface)
+    mod.instance_variable_set('@ids', {})
+    mod.instance_eval(&block)
+    mod
+  end
+
+  def self.trait(&blk)
+    m = Module.new
+    m.extend(Cube::Trait)
+    m.module_exec(&blk) if block_given?
+    m
+  end
+
+  def self.check_type_spec(t, v, &blk)
+    if t.is_a?(Set)
+      if v.is_a?(Set)
+        if v != t
+          raise Cube::Interface::TypeMismatchError, "#{t.to_a} is not eql to #{v.to_a}"
+        end
+        return true
+      end
+      unless t.any? { |tp| check_type(tp, v, &blk) rescue false }
+        raise Cube::Interface::TypeMismatchError,
+          "#{v.inspect} is not any of #{t.to_a}"
+      end
+      return
+    end
+    if t.is_a? Array
+      raise Cube::Interface::TypeMismatchError,
+        "#{v} is not an Array" unless v.is_a? Array
+      check_type(t.first, v.first, &blk)
+      check_type(t.first, v.last, &blk)
+      return
+    end
+    raise Cube::Interface::TypeMismatchError, "#{v.inspect} is not type #{t}" unless blk.call(t, v) 
+    true
+  end
+
+  if ENV['RUBY_CUBE_TYPECHECK'].to_i > 0
+    def self.check_type(t, v)
+      if t.is_a?(Set)
+        unless t.any? { |tp| check_type(tp, v) rescue false }
+          raise Cube::Interface::TypeMismatchError,
+                "#{v.inspect} is not any of #{t.to_a}"
+        end
+        return
+      end
+      if t.is_a? Array
+        raise Cube::Interface::TypeMismatchError,
+              "#{v} is not an Array" unless v.is_a? Array
+        check_type(t.first, v.first)
+        check_type(t.first, v.last)
+        return
+      end
+      raise Cube::Interface::TypeMismatchError, "#{v.inspect} is not type #{t}" unless v.is_a? t
+      true
+    end
+  else
+    def self.check_type(*_); end
+  end
+
+  module CubeMethods
+    def as_interface(iface, runtime_checks: true)
+      raise ArgumentError, "#{iface} is not a Cube::Interface" unless iface.is_a?(Cube::Interface)
+      implements = lambda { |this|
+        unless this.is_a? Class
+          raise "Non-Class modules cannot implement interfaces"
+        end
+        this.instance_variable_set(:@__interface_runtime_check, true) if runtime_checks
+        this.include(iface)
+      }
+      implements.call(clone)
+    end
+
+
+    def shell_implements(mod)
+      instance_variable_set(:@__interface_runtime_check, false)
+      instance_variable_set(:@__interface_arity_skip, true)
+      include(mod)
+    end
+  end
+end
+

data/lib/cube/traits.rb

@@ -1,4 +1,5 @@
 require_relative 'interfaces'
+require 'delegate'
 
 module Cube
   module Trait
@@ -13,6 +14,9 @@ module Cube
     end
 
     def append_features(mod)
+      if mod.is_a?(Class) && !mod.is_a?(CubeMethods)
+        raise IncludeError, "Traits can only be mixed into cube classes"
+      end
       unless mod.instance_variable_defined?(:@__trait_allow_include) &&
         mod.instance_variable_get(:@__trait_allow_include)
         raise IncludeError, "Traits can only be mixed in using method `with_trait`"
@@ -26,27 +30,59 @@ module Cube
         message = "\n" + errors.map { |e| e[:meth].to_s }.join("\n")
         raise MethodConflict, message
       end
-      if @__interface__trait_required_interface
+      if @__interface_trait_required_interface && mod.is_a?(Class)
         intf = @__interface_trait_required_interface
-        mod.include?(intf) || mod.assert_implements(intf)
+        mod.include?(intf) || mod.as_interface(intf, runtime_checks: false)
+      end
+      super
+    end
+
+    def wrap(intf)
+      assert_match(intf)
+      cls = Class.new(SimpleDelegator) do
+        define_method(:initialize) do |obj|
+          $stderr.puts "Checking with #{intf}"
+          Cube.check_type(intf, obj)
+          super(obj)
+        end
+      end
+      inc_trait = clone
+      inc_trait.instance_variable_set(:@__interface_trait_required_interface, nil)
+      inc_trait.instance_variable_set(:@__trait_cloned_from, self)
+      Cube[cls].with_trait(inc_trait)
+    end
+
+    def assert_match(intf)
+      self_methods = instance_methods
+      inherited = self.ancestors.select{ |x| Trait === x }
+      required_interface_spec = inherited.inject({}) { |acc, x|
+        req = x.instance_variable_get('@__interface_trait_required_interface')
+        if req
+          acc.merge(req.to_spec)
+        else
+          acc
+        end
+      }
+      self_methods.each do |sm|
+        required_interface_spec.delete(sm)
       end
-      super(mod)
+      Interface.match_specs(required_interface_spec, intf.to_spec)
     end
   end
 end
 
 class Module
-  def with_trait(trait, aliases: {}, suppresses: [])
+  def with_trait(trait, rename: {}, suppress: [])
     unless trait.is_a? Cube::Trait
       raise ArgumentError, "#{trait} is not an Cube::Trait"
     end
     cls = clone
     cls.instance_variable_set(:@__trait_allow_include, true)
     cls.instance_variable_set(:@__trait_cloned_from, self)
-    raise ArgumentError, "aliases must be a Hash" unless aliases.is_a?(Hash)
-    raise ArgumentError, "supresses must be a Array" unless suppresses.is_a?(Array)
+    raise ArgumentError, "aliases must be a Hash" unless rename.is_a?(Hash)
+    raise ArgumentError, "supresses must be a Array" unless suppress.is_a?(Array)
 
-    al_trait = trait_with_resolutions(trait, aliases, suppresses)
+    al_trait = trait_with_resolutions(trait, rename, suppress)
     al_trait.instance_variable_set(:@__interface_runtime_check, false)
     cls.include(al_trait)
     cls
@@ -58,7 +94,7 @@ class Module
     cl = trait.clone
     cl.module_exec do
       suppress.each do |sup|
-        undef_method(sup)
+        remove_method(sup)
       end
       aliases.each do |before, after|
         begin
@@ -67,7 +103,7 @@ class Module
           $stderr.puts "with_trait(#{trait}): #{e.message}"
           raise ArgumentError, "with_trait(#{trait}): #{e.message}"
         end
-        undef_method(before)
+        remove_method(before)
       end
     end
     cl

data/test/test_interface.rb

@@ -10,13 +10,13 @@ require 'cube'
 
 class TC_Interface < Test::Unit::TestCase
   def self.startup
-    alpha_interface = interface{
+    alpha_interface = Cube.interface{
       public_visible(:alpha, :beta)
       proto(:beta) { [Integer, NilClass].to_set }
       proto(:delta, Integer, String, Integer) { Integer }
     }
 
-    gamma_interface = interface{
+    gamma_interface = Cube.interface{
       extends alpha_interface
       public_visible :gamma
     }
@@ -47,11 +47,7 @@ class TC_Interface < Test::Unit::TestCase
 
 
   def checker_method(arg)
-    check_type(@@gamma_interface, arg)
-  end
-
-  def test_version
-    assert_equal('0.2.0', Cube::Interface::VERSION)
+    Cube.check_type(@@gamma_interface, arg)
   end
 
   def test_interface_requirements_not_met
@@ -70,34 +66,44 @@ class TC_Interface < Test::Unit::TestCase
 
   def test_gamma_interface_requirements_met
     assert_raise(Cube::Interface::MethodArityError) { C.new.extend(@@gamma_interface) }
-    assert_raise(Cube::Interface::MethodArityError) { C.as_interface(@@gamma_interface) }
+    assert_raise(Cube::Interface::MethodArityError) { Cube[C].as_interface(@@gamma_interface) }
   end
 
   def test_method_check
-    assert_raise(Cube::Interface::TypeMismatchError) { checker_method(B.as_interface(@@alpha_interface).new) }
+    assert_raise(Cube::Interface::TypeMismatchError) { checker_method(Cube[B].as_interface(@@alpha_interface).new) }
   end
 
   def test_runtime_error_check
     assert_nothing_raised {
-      B.as_interface(@@alpha_interface, runtime_checks: true).new.beta
+      Cube[Cube[B]]
+    }
+    assert(Cube[B].is_a?(Cube::CubeMethods))
+    assert_raise(ArgumentError) {
+      Cube[@@gamma_interface]
+    }
+    assert_nothing_raised {
+      Cube[B].as_interface(@@alpha_interface).as_interface(@@alpha_interface)
+    }
+    assert_nothing_raised {
+      Cube[B].as_interface(@@alpha_interface, runtime_checks: true).new.beta
     }
     assert_raise(ArgumentError) {
-      B.as_interface(@@alpha_interface).new.delta
+      Cube[B].as_interface(@@alpha_interface).new.delta
     }
     assert_raise(ArgumentError) {
-      B.as_interface(@@alpha_interface).new.delta(1)
+      Cube[B].as_interface(@@alpha_interface).new.delta(1)
     }
     assert_raise(Cube::Interface::TypeMismatchError) {
-      B.as_interface(@@alpha_interface).new.delta(1, 2)
+      Cube[B].as_interface(@@alpha_interface).new.delta(1, 2)
     }
     assert_raise(Cube::Interface::TypeMismatchError) {
-      B.as_interface(@@alpha_interface).new.delta(1, "2", "3")
+      Cube[B].as_interface(@@alpha_interface).new.delta(1, "2", "3")
     }
     assert_nothing_raised {
-      B.as_interface(@@alpha_interface).new.delta(1, "2")
+      Cube[B].as_interface(@@alpha_interface).new.delta(1, "2")
     }
     assert_nothing_raised {
-      B.as_interface(@@alpha_interface).new.delta(1, "2", 3)
+      Cube[B].as_interface(@@alpha_interface).new.delta(1, "2", 3)
     }
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rubycube
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - Aditya Godbole
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain:
 - certs/djberg96_pub.pem
-date: 2016-07-12 00:00:00.000000000 Z
+date: 2016-08-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: test-unit
@@ -120,9 +120,12 @@ files:
 - doc/js/searcher.js.gz
 - doc/table_of_contents.html
 - examples/demo.rb
+- examples/traits.rb
 - lib/cube.rb
 - lib/cube/interfaces.rb
+- lib/cube/toplevel.rb
 - lib/cube/traits.rb
+- rubycube-0.2.1.gem
 - test/test_interface.rb
 homepage: http://github.com/adityagodbole/rubycube
 licenses: