Type-Checking Interface in Ruby ◰ « Prefer: Censorship
» 2015 Media Reviews

2014-08-27 1:29
Code: boundaries, experiment, interfaces, POODR, Ruby
2 comments

module Notifier
  def notify message
    raise NotImplementedError
  end
 
  def acknowledged?
    raise NotImplemented Error
  end
end
 
class TextMessageSender
  include Notifier
 
  def notify message
    SMSGateway.send(...)
  end
 
  # ...
end
 
class EmailSender
  include Notifier
 
  def notify message
    Email.new(...).deliver!
  end
 
  # ...
end
 
class ShoppingCart
  def checkout notifier
    # billing code, etc.
    notifier.notify "Thanks for buying our stuff..."
  end
end

class Class
  def enforce requirements
    caller_binding = binding.of_caller(1)
    params = method(caller_binding.eval('__method__').parameters
    params.each do |type, name|
      next unless type == :req
      # formating for width of blog here...
      if requirements.has_key? name
        unless caller_binding.local_variable_get(name).is_a? Kernel::const_get(requirements[name])
          raise ArgumentError, "#{name} didn't include #{requirements[name]}"
        end
      end
    end
  end
end
 
# for example:
class ShoppingCart
  def checkout notifier
    enforce notifier: Notifier
    # billing code, etc.
    notifier.notify "Thanks for buying our stuff..."
  end
end

require 'set'
 
# here's the Interface model:
 
class Interface
  attr_reader :messages
  def initialize messages
    @messages = Set.new(messages)
  end
 
  def knows? message
    @messages.include(message)
  end
end
 
# and a handy shortcut for defining one:
 
class Kernel
  def interface name, messages
    iface = Interface.new messages
    Kernel::const_set name, iface
  end
end
 
# so somewhere in the code an interface can be cleanly defined with:
interface :Notifier, [:notify, :acknowledged?]
 
# and then we'll set up objects to be checked for interfaces:
class Object
  def provides iface
    @_interfaces ||= []
    @_interfaces << iface
    unless defined? :provides?
      define_method :provides? do |iface|
        @_interfaces.include? iface
 
        # Yes, this is wasteful to check on every method call using 'enforce',
        # but I didn't want to put the 'provides' after the class definition,
        # and I suppose it's required if your object does something really
        # dynamic and tricky. If this were real, I might remove this check from
        # here and add a separate 'dynamically_provides' class method with this check.
        unresponded = iface.messages.select { |m| !arg.respond_to?(m) }
        raise ArgumentError, "Arg #{name} claims to provide #{iface} but doesn't respond_to? #{unresponded.join(', ')}" unless unresponded.empty?
      end
      end
  end
end
 
# this is used as:
class TextMessageSender
  provides Notifier
  def notify ; ... ; end
  def acknowledged? ; ... ; end
end
 
# and enforce changes its check:
class Class
  def enforce requirements
    caller_binding = binding.of_caller(1)
    params = method(caller_binding.eval('__method__').parameters
    params.each do |type, name|
      next unless type == :req
      if requirements.has_key? name
        raise ArgumentError, "Arg #{name} does not provide #{iface}" unless arg.respond_to?(:provides?) and arg.provides? iface
      end
    end
  end
end
 
# so, finally, the interface is enforced the same way:
class ShoppingCart
  # ...
  def checkout notifier
    enforce notifier: Notifier
    # billing code, etc.
    notifier.notify "Thanks for buying our stuff..."
  end
end