doodle 0.2.2 → 0.2.3

data/lib/doodle/info.rb

@@ -0,0 +1,298 @@
+class Doodle
+
+  # place to stash bookkeeping info
+  class DoodleInfo
+    attr_accessor :this
+    attr_accessor :local_attributes
+    attr_accessor :local_validations
+    attr_accessor :local_conversions
+    attr_accessor :validation_on
+    attr_accessor :arg_order
+    attr_accessor :errors
+    attr_accessor :parent
+
+    # takes one param - the object being doodled
+    def initialize(object)
+      @this = object
+      @local_attributes = Doodle::OrderedHash.new
+      @local_validations = []
+      @validation_on = true
+      @local_conversions = {}
+      @arg_order = []
+      @errors = []
+      #@parent = nil
+      @parent = Doodle.parent
+    end
+
+    # hide from inspect
+    m = instance_method(:inspect)
+    define_method :__inspect__ do
+      m.bind(self).call
+    end
+
+    # hide from inspect
+    def inspect
+      ''
+    end
+
+    # handle errors either by collecting in :errors or raising an exception
+    def handle_error(name, *args)
+      # don't include duplicates (FIXME: hacky - shouldn't have duplicates in the first place)
+      if !errors.include?([name, *args])
+        errors << [name, *args]
+      end
+      if Doodle.raise_exception_on_error
+        raise(*args)
+      end
+    end
+
+    # provide an alternative inheritance chain that works for singleton
+    # classes as well as modules, classes and instances
+    def parents
+      anc = if @this.respond_to?(:ancestors)
+              if @this.ancestors.include?(@this)
+                @this.ancestors[1..-1]
+              else
+                # singletons have no doodle_parents (they're orphans)
+                []
+              end
+            else
+              @this.class.ancestors
+            end
+      anc.select{|x| x.kind_of?(Class)}
+    end
+
+    # send message to all doodle_parents and collect results
+    def collect_inherited(message)
+      result = []
+      parents.each do |klass|
+        if klass.respond_to?(:doodle) && klass.doodle.respond_to?(message)
+          result.unshift(*klass.doodle.__send__(message))
+        else
+          break
+        end
+      end
+      result
+    end
+    private :collect_inherited
+
+    # collect results of calling method which returns a hash
+    # - if tf == true, returns all inherited attributes
+    # - if tf == false, returns only those attributes defined in the current object/class
+    def handle_inherited_hash(tf, method)
+      if tf
+        collect_inherited(method).inject(Doodle::OrderedHash.new){ |hash, item|
+          hash.merge(Doodle::OrderedHash[*item])
+        }.merge(@this.doodle.__send__(method))
+      else
+        @this.doodle.__send__(method)
+      end
+    end
+    private :handle_inherited_hash
+
+    # returns array of Attributes
+    # - if tf == true, returns all inherited attributes
+    # - if tf == false, returns only those attributes defined in the current object/class
+    def attributes(tf = true)
+      results = handle_inherited_hash(tf, :local_attributes)
+      # if an instance, include the singleton_class attributes
+      #p [:attributes, @this, @this.singleton_class, @this.singleton_class.methods(false), results]
+      if !@this.kind_of?(Class) && @this.singleton_class.doodle.respond_to?(:attributes)
+        results = results.merge(@this.singleton_class.doodle.attributes)
+      end
+      results
+    end
+
+    # return class level attributes
+    def class_attributes
+      attrs = Doodle::OrderedHash.new
+      if @this.kind_of?(Class)
+        attrs = collect_inherited(:class_attributes).inject(Doodle::OrderedHash.new){ |hash, item|
+          hash.merge(Doodle::OrderedHash[*item])
+        }.merge(@this.singleton_class.doodle.respond_to?(:attributes) ? @this.singleton_class.doodle.attributes : { })
+        attrs
+      else
+        @this.class.doodle.class_attributes
+      end
+    end
+
+    # access list of validations
+    #
+    # note: validations are handled differently to attributes and
+    # conversions because ~all~ validations apply (so are stored as an
+    # array), whereas attributes and conversions are keyed by name and
+    # kind respectively, so only the most recent applies
+    #
+    def validations(tf = true)
+      if tf
+        local_validations + collect_inherited(:local_validations)
+      else
+        local_validations
+      end
+    end
+
+    # find an attribute
+    def lookup_attribute(name)
+      # (look at singleton attributes first)
+      # fixme[this smells like a hack to me]
+      if @this.class == Class
+        class_attributes[name]
+      else
+        attributes[name]
+      end
+    end
+
+    # returns hash of conversions
+    # - if tf == true, returns all inherited conversions
+    # - if tf == false, returns only those conversions defined in the current object/class
+    def conversions(tf = true)
+      handle_inherited_hash(tf, :local_conversions)
+    end
+
+    # return hash of key => value pairs of initial values (where defined)
+    # - if tf == true, returns all inherited initial values
+    # - if tf == false, returns only those initial values defined in current object/class
+    def initial_values(tf = true)
+      attributes(tf).select{|n, a| a.init_defined? }.inject({}) {|hash, (n, a)|
+        #p [:initial_values, a.name]
+        hash[n] = case a.init
+                  when NilClass, TrueClass, FalseClass, Fixnum, Float, Bignum, Symbol
+                    # uncloneable values
+                    #p [:initial_values, :special, a.name, a.init]
+                    a.init
+                  when DeferredBlock
+                    #p [:initial_values, self, DeferredBlock, a.name]
+                    begin
+                      @this.instance_eval(&a.init.block)
+                    rescue Object => e
+                      #p [:exception_in_deferred_block, e]
+                      raise
+                    end
+                  else
+                    if a.init.kind_of?(Class)
+                      #p [:initial_values, :class]
+                      a.init.new
+                    else
+                      #p [:initial_values, :clone, a.name]
+                      begin
+                        a.init.clone
+                      rescue Exception => e
+                        warn "tried to clone #{a.init.class} in :init option (#{e})"
+                        #p [:initial_values, :exception, a.name, e]
+                        a.init
+                      end
+                    end
+                  end
+        hash
+      }
+    end
+
+    # turn off validation, execute block, then set validation to same
+    # state as it was before +defer_validation+ was called - can be nested
+    def defer_validation(&block)
+      #p [:defer_validation, self.validation_on, @this]
+      old_validation = self.validation_on
+      self.validation_on = false
+      v = nil
+      begin
+        v = @this.instance_eval(&block)
+      ensure
+        self.validation_on = old_validation
+      end
+      @this.validate!(false)
+      v
+    end
+
+    # helper function to initialize from hash - this is safe to use
+    # after initialization (validate! is called if this method is
+    # called after initialization)
+    def update(*args, &block)
+      # p [:doodle_initialize_from_hash, :args, *args]
+      defer_validation do
+        # hash initializer
+        # separate into array of hashes of form [{:k1 => v1}, {:k2 => v2}] and positional args
+        key_values, args = args.partition{ |x| x.kind_of?(Hash)}
+        #DBG: Doodle::Debug.d { [self.class, :doodle_initialize_from_hash, :key_values, key_values, :args, args] }
+        #!p [self.class, :doodle_initialize_from_hash, :key_values, key_values, :args, args]
+
+        # set up initial values with ~clones~ of specified values (so not shared between instances)
+        #init_values = initial_values
+        #!p [:init_values, init_values]
+
+        # match up positional args with attribute names (from arg_order) using idiom to create hash from array of assocs
+        #arg_keywords = init_values.merge(Hash[*(Utils.flatten_first_level(self.class.arg_order[0...args.size].zip(args)))])
+        arg_keywords = Hash[*(Utils.flatten_first_level(self.class.arg_order[0...args.size].zip(args)))]
+        #!p [self.class, :doodle_initialize_from_hash, :arg_keywords, arg_keywords]
+
+        # merge all hash args into one
+        key_values = key_values.inject(arg_keywords) { |hash, item|
+          #!p [self.class, :doodle_initialize_from_hash, :merge, hash, item]
+          hash.merge(item)
+        }
+        #!p [self.class, :doodle_initialize_from_hash, :key_values2, key_values]
+
+        # convert keys to symbols (note not recursively - only first level == doodle keywords)
+        Doodle::Utils.symbolize_keys!(key_values)
+        #DBG: Doodle::Debug.d { [self.class, :doodle_initialize_from_hash, :key_values2, key_values, :args2, args] }
+        #!p [self.class, :doodle_initialize_from_hash, :key_values3, key_values]
+
+        # create attributes
+        key_values.keys.each do |key|
+          #DBG: Doodle::Debug.d { [self.class, :doodle_initialize_from_hash, :setting, key, key_values[key]] }
+          #p [self.class, :doodle_initialize_from_hash, :setting, key, key_values[key]]
+          #p [:update, :setting, key, key_values[key], __doodle__.validation_on]
+          if respond_to?(key)
+            __send__(key, key_values[key])
+          else
+            # raise error if not defined
+            __doodle__.handle_error key, Doodle::UnknownAttributeError, "unknown attribute '#{key}' => #{key_values[key].inspect} for #{self} #{doodle.attributes.map{ |k,v| k.inspect}.join(', ')}", Doodle::Utils.doodle_caller
+          end
+        end
+        # do init_values after user supplied values so init blocks can
+        # depend on user supplied values
+        # - don't reset values which are supplied in args
+        #p [:getting_init_values, instance_variables]
+        __doodle__.initial_values.each do |key, value|
+          if !key_values.key?(key) && respond_to?(key)
+            #p [:initial_values, key, value]
+            __send__(key, value)
+          end
+        end
+        if block_given?
+          #p [:update, block, __doodle__.validation_on]
+          #p [:this, self]
+          instance_eval(&block)
+        end
+      end
+      @this
+    end
+
+    # returns array of values (including defaults)
+    # - if tf == true, returns all inherited values (default)
+    # - if tf == false, returns only those values defined in current object
+    def values(tf = true)
+      attributes(tf).map{ |k, a| @this.send(k)}
+    end
+
+    # returns array of attribute names
+    # - if tf == true, returns all inherited attribute names (default)
+    # - if tf == false, returns only those attribute names defined in current object
+    def keys(tf = true)
+      attributes(tf).keys
+    end
+
+    # returns array of [key, value] pairs including default values
+    # - if tf == true, returns all inherited [key, value] pairs (default)
+    # - if tf == false, returns only those [key, value] pairs defined in current object
+    def key_values(tf = true)
+      keys(tf).zip(values(tf))
+    end
+
+    # returns array of [key, value] pairs excluding default values
+    # - if tf == true, returns all inherited [key, value] pairs (default)
+    # - if tf == false, returns only those [key, value] pairs defined in current object
+    def key_values_without_defaults(tf = true)
+      keys(tf).reject{|k| @this.default?(k) }.map{ |k, a| [k, @this.send(k)]}
+    end
+  end
+end

data/lib/doodle/inherit.rb

@@ -0,0 +1,40 @@
+class Doodle
+  # = inherit
+  # the intent of inherit is to provide a way to create directives
+  # that affect all members of a class 'family' without having to
+  # modify Module, Class or Object - in some ways, it's similar to Ara
+  # Howard's mixable[http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/197296]
+  # though not as tidy :S
+  #
+  # this works down to third level <tt>class << self</tt> - in practice, this is
+  # perfectly good - it would be great to have a completely general
+  # solution but I doubt whether the payoff is worth the effort
+
+  module Inherited
+    def self.included(other)
+      other.extend(Inherited)
+      other.send(:include, Factory)
+    end
+
+    # fake module inheritance chain
+    def inherit(other, &block)
+      # include in instance method chain
+      include other
+      include Inherited
+
+      sc = class << self; self; end
+      sc.module_eval {
+        # class method chain
+        include other
+        # singleton method chain
+        extend other
+        # ensure that subclasses also inherit this module
+        define_method :inherited do |klass|
+          #p [:inherit, :inherited, klass]
+          klass.__send__(:inherit, other)       # n.b. closure
+        end
+      }
+    end
+  end
+
+end

data/lib/doodle/json.rb

@@ -0,0 +1,38 @@
+require 'json'
+require 'pp'
+
+class Doodle
+  module JSON
+    module InstanceMethods
+      def to_json(*a)
+        # don't include default values
+        values = doodle.key_values_without_defaults
+        value_hash = Hash[*Doodle::Utils.flatten_first_level(values)]
+        {
+          'json_class'   => self.class.name,
+          'data' => value_hash,
+        }.to_json(*a)
+      end
+    end
+    module ClassMethods
+      def json_create(o)
+        #pp [:json_create, o]
+        const = Doodle::Utils.const_resolve(o['json_class'])
+        const.new(o['data'])
+      end
+      def from_json(src)
+        v = ::JSON::parse(src)
+        if v.kind_of?(Hash)
+          new(v)
+        else
+          v
+        end
+      end
+    end
+    def self.included(other)
+      other.module_eval { include InstanceMethods }
+      other.extend(ClassMethods)
+    end
+  end
+  include Doodle::JSON
+end

data/lib/doodle/marshal.rb

@@ -0,0 +1,16 @@
+class Doodle
+  module ModMarshal
+    # helper for Marshal.dump
+    def marshal_dump
+      # note: perhaps should also dump singleton attribute definitions?
+      instance_variables.map{|x| [x, instance_variable_get(x)] }
+    end
+    # helper for Marshal.load
+    def marshal_load(data)
+      data.each do |name, value|
+        instance_variable_set(name, value)
+      end
+    end
+  end
+end
+

data/lib/doodle/normalized_array.rb

@@ -0,0 +1,512 @@
+require 'enumerator'
+
+module ArraySentence
+  def join_with(sep = ', ', last = ' and ')
+    if self.size > 1
+      self[0..-2].join(sep) + last + self[-1].to_s
+    else
+      self[0].to_s
+    end
+  end
+end
+
+module NormalizedArrayMethods
+  module InstanceMethods
+    include ArraySentence
+
+    #   def &(other)
+    #     super
+    #   end
+
+    #   def *(other)
+    #     super
+    #   end
+
+    #   def +(other)
+    #     super
+    #   end
+
+    #   def -(other)
+    #     super
+    #   end
+
+    def initialize(*args, &block)
+      #p [:init, 1, args, block]
+      if block_given?
+        #p [:init, 2]
+        original_block = block
+        block = proc { |index|
+          #p [:init, 3, index]
+          normalize_value(original_block[normalize_index(index)])
+        }
+        #p [:init, 4, block]
+      end
+      replace(super(*args, &block))
+    end
+
+#     def initialize(*args, &block)
+#       replace(super)
+#     end
+
+    def normalize_index(index)
+      index
+    end
+
+    def normalize_value(value)
+      p [self.class, :normalize_value, value]
+      value
+    end
+
+    # convenience method to check indices
+    def normalize_indices(*indices)
+      indices.map{ |index| normalize_index(index) }
+    end
+
+    # convenience method to check values
+    def normalize_values(*values)
+      if values.empty?
+        values = self
+      end
+      values.map{ |value| normalize_value(value) }
+    end
+
+    def <<(value)
+      super(normalize_value(value))
+    end
+
+#     def <=>(other)
+#       super(normalize_values(*other))
+#     end
+
+#     def ==(other)
+#       super(normalize_values(*other))
+#     end
+
+    def [](index)
+      super(normalize_index(index))
+    end
+
+    def []=(index, value)
+      super(normalize_index(index), normalize_value(value))
+    end
+
+    #   def assoc(key)
+    #     super
+    #   end
+
+    def at(index)
+      super(normalize_index(index))
+    end
+
+    #   def clear()
+    #     super
+    #   end
+
+    #   def collect(&block)
+    #     #FIXME
+    #   end
+
+    def collect!(&block)
+      super() {|x| normalize_value(block.call(x))}
+    end
+
+    #   def compact()
+    #     super
+    #   end
+
+    #   def compact!()
+    #     super
+    #   end
+
+    def concat(other)
+      super(normalize_values(*other))
+    end
+
+    def delete(value)
+      super(normalize_value(value))
+    end
+
+    def delete_at(index)
+      super(normalize_index(index))
+    end
+
+    #   def delete_if(&block)
+    #     super
+    #   end
+
+    #   def each(&block)
+    #     super
+    #   end
+
+    #   def each_index(&block)
+    #     super
+    #   end
+
+    #   def empty?()
+    #     super
+    #   end
+
+#     def eql?(other)
+#       super(normalize_values(*other))
+#     end
+
+    def fetch(index)
+      super(normalize_index(index))
+    end
+
+    # array.fill(obj)                                -> array
+    # array.fill(obj, start [, length])              -> array
+    # array.fill(obj, range )                        -> array
+    # array.fill {|index| block }                    -> array
+    # array.fill(start [, length] ) {|index| block } -> array
+    # array.fill(range) {|index| block }             -> array
+    def fill(*args, &block)
+      # TODO: check value
+      # check start, length
+      replace(super)
+    end
+
+    def first(count = 1)
+      # TODO: check count
+      super
+    end
+
+    #   def flatten()
+    #     super
+    #   end
+
+    #   def flatten!()
+    #     super
+    #   end
+
+    #   def frozen?()
+    #     super
+    #   end
+
+    #   def hash()
+    #     super
+    #   end
+
+    def include?(value)
+      super(normalize_value(value))
+    end
+
+    def index(value)
+      super(normalize_value(value))
+    end
+
+    def insert(index, *values)
+      super(normalize_index(index), normalize_values(*values))
+    end
+
+    #   def inspect()
+    #     super
+    #   end
+
+    #   def join(sep = $,)
+    #     super
+    #   end
+
+    def last(count = 1)
+      # TODO: check count
+      super
+    end
+
+    #   def length()
+    #     super
+    #   end
+
+    #   def map(&block)
+    #     super
+    #   end
+
+    def map!(&block)
+      collect!(&block)
+    end
+
+    #   def nitems()
+    #     super
+    #   end
+
+    #   def pack()
+    #     super
+    #   end
+
+    #   def pop()
+    #     super
+    #   end
+
+    def push(*values)
+      super(normalize_values(*values))
+    end
+
+    #   def rassoc(key)
+    #     super
+    #   end
+
+    #   def reject(&block)
+    #     super
+    #   end
+
+    def reject!(&block)
+      super() {|x| normalize_value(block.call(x))}
+    end
+
+    def replace(other)
+      #p [:replace, other]
+      super(other.to_enum(:each_with_index).map{ |v, i|
+              #p [:replace_norm, i, v]
+              normalize_index(i);
+              normalize_value(v)
+            })
+    end
+
+    #   def reverse()
+    #     super
+    #   end
+
+    #   def reverse!()
+    #     super
+    #   end
+
+    #   def reverse_each(&block)
+    #     super
+    #   end
+
+    def rindex(value)
+      super(normalize_value(value))
+    end
+
+    #   def select(&block)
+    #     super
+    #   end
+
+    #   def shift()
+    #     super
+    #   end
+
+    #     alias :size :length
+
+    # array[index]                -> obj      or nil
+    # array[start, length]        -> an_array or nil
+    # array[range]                -> an_array or nil
+    # array.slice(index)          -> obj      or nil
+    # array.slice(start, length)  -> an_array or nil
+    # array.slice(range)          -> an_array or nil
+    def slice(*args)
+      # TODO: check indices
+      super
+    end
+
+    def slice!(*args)
+      # TODO: check indices
+      super
+    end
+
+    #   def sort(&block)
+    #     super
+    #   end
+
+    #   def sort!(&block)
+    #     super
+    #   end
+
+    #   def to_a()
+    #     super
+    #   end
+
+    #   def to_ary()
+    #     super
+    #   end
+
+    #   def to_s()
+    #     super
+    #   end
+
+    #   def transpose()
+    #     super
+    #   end
+
+    #   def uniq()
+    #     super
+    #   end
+
+    #   def uniq!()
+    #     super
+    #   end
+
+    def unshift(*values)
+      super(normalize_values(*values))
+    end
+
+    def values_at(*indices)
+      super(normalize_indices(*indices))
+    end
+    # deprecated - use values_at
+    alias :indexes :values_at
+    alias :indices :values_at
+
+    # should this be normalized?
+    def zip(other)
+      super(normalize_values(*other))
+    end
+
+    #     def |(other)
+    #       super(other.map{ |x| normalize_value(x)})
+    #     end
+
+  end
+
+  module ClassMethods
+    def [](*args)
+      super.normalize_values
+    end
+  end
+end
+
+class NormalizedArray < Array
+  include NormalizedArrayMethods::InstanceMethods
+  extend NormalizedArrayMethods::ClassMethods
+end
+
+if __FILE__ == $0
+  require 'rubygems'
+  require 'assertion'
+
+  class StringArray < NormalizedArray
+    def normalize_value(v)
+      p [self.class, :normalize_value, v]
+      v.to_s
+    end
+  end
+
+  def BoundedArray(upper_bound)
+    typed_class = Class.new(NormalizedArray) do
+      define_method :normalize_index do |index|
+        raise IndexError, "index #{index} out of range" if !(0..upper_bound).include?(index)
+        index
+      end
+    end
+    typed_class
+  end
+
+  def TypedArray(*klasses)
+    typed_class = Class.new(NormalizedArray) do
+      define_method :normalize_value do |v|
+        if !klasses.any?{ |klass| v.kind_of?(klass) }
+          raise TypeError, "#{self.class}: #{v.class}(#{v.inspect}) is not a kind of #{klasses.map{ |c| c.to_s }.join(', ')}", [caller[-1]]
+        end
+        v
+      end
+    end
+    typed_class
+  end
+  TypedStringArray = TypedArray(String)
+
+#   na = Array.new(4) { |i|
+#     p [:in_block, i]
+#     42
+#   }
+#   p na[1]
+#   p na[1] == 42
+
+  sa = StringArray.new(3) { |i|
+    p [:in_block, i]
+    42
+  }
+  assert { sa[1] == "42" }
+  assert_error { sa[1] == 42 }
+  assert_error { sa.values == ["42"] * 3 }
+  assert_error { sa.values == [42] }
+
+  sa = nil
+  assert_ok {  sa = StringArray.new([1,2,3]) }
+  assert { sa == ["1", "2", "3"] }
+  assert { (sa | ["4", "5", "6"]) == ["1", "2", "3", "4", "5", "6"] }
+  assert { (sa | [4, 5, 6]) == ["1", "2", "3", 4, 5, 6] }
+  assert { (sa | [4, 5, 6]).class == Array }
+
+  # equality
+  assert { sa == ["1", "2", "3"] }
+
+  ## -FIXME: not sure about this coercion-
+  assert_error { sa.eql?( [1, 2, 3] )}
+
+  ## -FIXME: equality should not be non-commutative-
+  assert_error { sa == [1, 2, 3] }
+  assert_error { [1, 2, 3] == sa }
+
+  BoundedArray4 = BoundedArray(4)
+  ca = BoundedArray4.new([1,2,3])
+  assert { ca == [1, 2, 3] }
+  assert { ca[4] = 42 }
+  expect_error(IndexError) { ca[5] = 42 }
+  expect_error('out of range') { ca[5] = 42 }
+  expect_error { ca[5] = 42 }
+  #expect_ok { false }
+  #expect_error { true }
+  #assert_ok { true }
+
+  assert_ok { ca = BoundedArray4.new([1,2,3,4,5]) }
+  assert_error { ca = BoundedArray4.new([1,2,3,4,5,6]) }
+
+  assert_error { sa = TypedStringArray.new([1,2,3]) }
+  assert_ok { sa = TypedStringArray.new(["1","2","3"]) }
+
+  #   ca = BoundedArray.new([1,2,3,4,5])
+  #   pp ca
+
+  TypedIntegerArray = TypedArray(Integer)
+  ia = TypedIntegerArray.new([1,2,3])
+  expect_error { ia[1] = "hello" }
+
+  StringOrIntegerArray = TypedArray(Integer, String)
+  ma = nil
+  expect_ok { ma = StringOrIntegerArray.new([1,"2",3]) }
+  expect_ok { ma[0] = "hello" }
+  expect_error { ma[1] = Date.new }
+
+  assert {
+    ma = [].extend(ArraySentence)
+    ma.join_with(', ', ' and ') == ""
+  }
+
+  assert {
+    ma = [nil].extend(ArraySentence)
+    ma.join_with(', ', ' and ') == ""
+  }
+
+  assert {
+    ma = [nil, nil].extend(ArraySentence)
+    ma.join_with(', ', ' and ') == " and "
+  }
+
+  assert {
+    ma = [nil, nil, nil].extend(ArraySentence)
+    ma.join_with(', ', ' and ') == ",  and "
+  }
+
+  assert {
+    ma = [1].extend(ArraySentence)
+    ma.join_with(', ', ' and ') == "1"
+  }
+
+  assert {
+    ma = [1, 2].extend(ArraySentence)
+    ma.join_with(', ', ' and ') == "1 and 2"
+  }
+
+  assert {
+    ma = [1, 2, 3].extend(ArraySentence)
+    ma.join_with(', ', ' or ') == "1, 2 or 3"
+  }
+
+  assert {
+    ma = [1, 2, 3].extend(ArraySentence)
+    ma.join_with(', ', ' and ') == "1, 2 and 3"
+  }
+
+  expect_error("Fixnum(1) is not a kind of String") { TypedStringArray[1,2,3] }
+  expect_error(TypeError) { TypedStringArray[1,2,3] }
+
+end