valid_array 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7f027291bafabc6977571d06cae40b0a19a00ed6
+  data.tar.gz: 8c62dab2888b7419ecc7466243ad6b08bfdc67d7
+SHA512:
+  metadata.gz: 76bfde39f3b266ad440d05b035f2d91d93d63cd8e0c527f467d33d3d3614fde44f60f4194507d45bd06273a4d5bf51821c14eeb8ed6a0f553618887ea3bbd7dd
+  data.tar.gz: 4b9c64dbd30920a626d8844b92d8b5ec0af9ac9ebcd3ed75374074599d411efc8a3fe98ce6694a16dd4c89b901bf2e1511428431f96c2862c96bc4b21210b737

data/LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2011 Ryan Biesemeyer
+Copyright (c) 2013 Kevin Cox
+
+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/README.rdoc

@@ -0,0 +1,91 @@
+= valid_array
+
+The valid_array gem provides to create an Array that enforces certian
+properties.  Each element added to the array is passed to a validator function
+written by you.  This function can raise errors, drop items or change them.
+
+vaild_array also provides compatibility with the typed-array gem.  There is both
+'valid_array/typed_array' which imports to `ValidArray::TypedArray` and a fully
+compatible 'valid-array' which passes 'valid-array's own test suite.
+
+Copyright (c) 2011 Ryan Biesemeyer <mailto:ruby-dev@yaauie.com> (Original typed-array work)
+Copyright (c) 2013 Kevin Cox <mailto:kevincox@kevincox.ca>
+See LICENSE for details.
+
+== Examples
+
+=== ValidArray
+
+Valid Array provides a hook to change and validate every element added to the
+array.
+
+ require 'valid_array'
+ 
+ # An Array that converts all added elements into strings.
+ class StringArray < Array
+  extend ValidArray
+  
+  def self.validate(element)
+    element.to_s
+  end
+ end
+ 
+ # An array that enforces Numeric types and silently drops odd numbers.
+ class EvenArray < Array
+   extend ValidArray
+   
+   class NotEvenException < Exception
+   end
+  
+   def self.validate(element)
+      if not element.is_a? Numeric
+         raise TypeError, "Got #{element.class}, expected Numeric!"
+      end
+      
+      if element % 2 == 1
+         # This exception is handled by ValidArray, it causes the element to be
+         # dropped.  All other exceptions are propagated to the caller.
+         raise ValidArray::DontInsertException
+      end
+   end
+ end
+
+=== TypedArray
+
+TypedArray is fully compatible with https://github.com/yaauie/typed-array/.
+For compatibility mode require 'typed-array', otherwise require
+'valid_array/typed_array' and access it from `ValidArray::TypedArray`.
+
+=== Create Standard Class
+
+ require 'typed-array'
+ class Things < Array
+   extend TypedArray
+   restrict_types Thing1,Thing2
+ end
+ 
+ # or new style
+ 
+ require 'valid_array/typed_array'
+ class Things < Array
+   extend ValidArray::TypedArray
+   restrict_types Thing1,Thing2
+ end
+ 
+=== Generate Class using Factory
+ 
+ require 'typed-array'
+ things = TypedArray(Thing1,Thing2)
+ a = things.new
+ 
+ # or new style
+ 
+ require 'valid_array/typed_array'
+ things = ValidArray::TypedArray(Thing1, Thing2)
+ a = things.new
+ 
+= Adding items to the Array
+ 
+All standard Array interfaces are implemented, including block-processing
+and variable-number of arguments. For methods that would usually return an
+Array, they instead return an instance of the current class (except to_a).

data/lib/typed-array.rb

@@ -0,0 +1,14 @@
+# Provides compatibility with https://github.com/yaauie/typed-array
+
+require 'valid_array/typed_array'
+
+# Alias for compatibility.
+# see {ValidArray::TypedArray}
+TypedArray = ValidArray::TypedArray
+
+
+# Alias for compatibility.
+# see {ValidArray::TypedArray}
+def TypedArray(*args)
+	ValidArray::TypedArray *args
+end

data/lib/valid_array/functions.rb

@@ -0,0 +1,111 @@
+# Provides the validation functions that get included into a ValidArray
+
+# Namespace ValidArray
+module ValidArray
+
+  # The functions that get included into ValidArray
+  module Functions
+    # Validates outcome. See Array#initialize
+    def initialize(*args, &block)
+      ary = Array.new *args, &block
+      self.replace ary
+    end
+
+    # Validates outcome. See Array#replace
+    def replace(other_ary)
+      other_ary = _ensure_array_is_valid other_ary
+      super
+    end
+
+    # Validates outcome. See Array#&
+    def &(ary)
+      self.class.new super
+    end
+
+    # Validates outcome. See Array#*
+    def *(int)
+      self.class.new super
+    end
+
+    # Validates outcome. See Array#+
+    def +(ary)
+      self.class.new super
+    end
+
+    # Validates outcome. See Array#<<
+    def <<(item)
+      begin
+        item = self.class.validate item
+        super
+      rescue DontInsertException; end
+    end
+
+    # Validates outcome. See Array#[]
+    def [](idx)
+      self.class.new super
+    end
+
+    # Validates outcome. See Array#slice
+    def slice(*args)
+      self.class.new super
+    end
+
+    # Validates outcome. See Array#[]=
+    def []=(idx, item)
+      begin
+        item = self.class.validate item
+        super
+      rescue DontInsertException; end
+    end
+
+    # Validates outcome. See Array#concat
+    def concat(other_ary)
+      _ensure_array_is_valid other_ary
+      super
+    end
+
+    # Validates outcome. See Array#eql?
+    #def eql?(other_ary)
+    #  _ensure_all_items_in_array_are_allowed other_ary
+    #  super
+    #end
+
+    # Validates outcome. See Array#fill
+    def fill(*args, &block)
+      ary = self.to_a
+      ary.fill *args, &block
+      self.replace ary
+    end
+
+    # Validates outcome. See Array#push
+    def push(*items)
+      items = _ensure_array_is_valid items
+      super
+    end
+
+    # Validates outcome. See Array#unshift
+    def unshift(*items)
+      items = _ensure_array_is_valid items
+      super
+    end
+
+    # Validates outcome. See Array#map!
+    def map!(&block)
+      self.replace(self.map &block)
+    end
+
+    protected
+
+    # Ensure that all items in the passed Array are allowed
+    def _ensure_array_is_valid(ary)
+      toins = []
+      ary.each do |e|
+        begin
+          toins << self.class.validate(e)
+        rescue DontInsertException; end
+      end
+      
+      toins
+    end
+  end
+end

data/lib/valid_array/typed_array.rb

@@ -0,0 +1,74 @@
+# :include: ../README.rdoc
+
+require 'set'
+require 'valid_array'
+
+# Provides ValidArray functionality to a subclass of Array
+# when extended in the class's definiton
+module ValidArray::TypedArray
+  # when a class inherits from this one, make sure that it also inherits
+  # the types that are being enforced
+  def inherited(subclass)
+    self._subclasses << subclass
+    subclass.restricted_types *self.restricted_types
+  end
+  
+  # A getter/setter for types to add. If no arguments are passed, it simply
+  # returns the current array of accepted types.
+  def restricted_types(*types)
+    @_restricted_types ||= []
+    types.each do |type|
+      raise UnexpectedTypeException.new([Class],type.class) unless type.is_a? Class
+      @_restricted_types << type unless @_restricted_types.include? type
+      _subclasses.each do |subclass|
+        subclass.restricted_types type
+      end
+    end
+    @_restricted_types
+  end; alias :restricted_type :restricted_types
+  
+  
+  # The exception that is raised when an Unexpected Type is reached during validation
+  class UnexpectedTypeException < Exception
+    # Provide access to the types of objects expected and the class of the object received
+    attr_reader :expected, :received
+
+    def initialize(expected_one_of, received)
+      @expected = expected_one_of
+      @received = received
+    end
+
+    def to_s
+      %{Expected one of #{@expected.inspect} but received a(n) #{@received}}
+    end
+  end
+
+  def validate(item)
+    if item.nil? or restricted_types.any? { |allowed| item.class <= allowed }
+      return item
+    else
+      raise TypedArray::UnexpectedTypeException.new(restricted_types, item.class)
+    end
+  end
+  
+  protected
+
+  # a store of subclasses
+  def _subclasses
+    @_subclasses ||= []
+  end
+
+end
+
+# Provide a factory method. Takes any number of types to accept as arguments
+# and returns a class that behaves as a type-enforced array.
+def ValidArray::TypedArray(*types_allowed)
+  klass = Class.new( Array )
+  klass.class_exec(types_allowed) do |types_allowed|
+    extend ValidArray
+    extend TypedArray
+    
+    restricted_types *types_allowed
+  end
+  klass
+end

data/lib/valid_array.rb

@@ -0,0 +1,34 @@
+# :include: ../README.rdoc
+
+require 'valid_array/functions'
+
+# Provides ValidArray functionality to a subclass of Array
+# when extended in the class's definiton
+module ValidArray
+  # Hook the extension process in order to include the necessary functions
+  # and do some basic sanity checks.
+  def self.extended(mod)
+    mod.module_exec(self::Functions) do |functions_module|
+      include functions_module
+    end
+  end
+  
+  # Exception to raise to silently skip insertion.
+  #
+  # Raising this from validate will prevent the item from being inserted.  Use
+  # with caution as it may break assumptions that coders are making about how
+  # your array works.
+  class DontInsertException < Exception; end
+
+  # Default validator.  Override this.
+  #
+  # Translates the provided item to insert to the new item.  Raise an exception
+  # to prevent insertion.  DontInsertException will be handled and ignored,
+  # other exceptions will be propergated.
+  #
+  # @param element [Object] The element being added to the array.
+  # @return [Object] The element to actualy insert into the array.
+  def validate(element)
+    raise NotImplementedError, "You must implement validate."
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rspec'
+
+RSpec.configure do |config|
+  
+end

data/spec/typed-array_spec.rb

@@ -0,0 +1,278 @@
+require_relative 'spec_helper'
+require 'typed-array'
+
+# We need to test in several different contexts, so provide the base info here.
+inputs = {
+  [Symbol]=>{
+    :base => [:foo,:bar],
+    :match => [:baz,:bingo],
+    :fail => {
+      :one => [:zip,0],
+      :all => ['string',Class]
+    }
+  },
+  [Fixnum] => {
+    :base => [ 1,2,3 ],
+    :match => [ 17,18,19 ],
+    :fail => {
+      :one => [22,:symbol,43],
+      :all => ['string',:symbol]
+    }
+  },
+  [String,Symbol] => {
+    :base => ['Foo',:foo],
+    :match => [:bar,'Bar'],
+    :fail => {
+      :one => [:yippee,'a string',17],
+      :all => [12,Class,Array]
+    }
+  }
+}
+
+describe TypedArray do
+  describe '#new' do
+    inputs.each_pair do |accepted_types, config|
+      context "when only accepting <#{accepted_types.inspect}>" do
+        subject { TypedArray( *accepted_types ) }
+
+        context 'Form 1: typed_ary.new()' do
+          it "should have zero-length" do
+            subject.new().length.should == 0
+          end
+
+          it "should be empty" do
+            subject.new().to_a.should be_empty
+          end
+        end
+
+        context 'Form 1: typed_ary.new(size)' do
+          it "should have the proper length" do
+            subject.new(5).length.should == 5
+          end
+
+          it "should conatin all nil values" do
+            subject.new(5).to_a.should == [nil,nil,nil,nil,nil]
+          end
+        end
+
+        context 'Form 2: typed_ary.new(size,object)' do
+          it "should have the proper length" do
+            subject.new(3,config[:match].first).length.should == 3
+          end
+
+          it "should conatin the value specified" do
+            subject.new(3,config[:match].first).to_a.should == [config[:match].first]*3
+          end
+
+          it "should raise when obj is the wrong type" do
+            expect{ subject.new( 3, config[:fail][:all].first ) }.to raise_error TypedArray::UnexpectedTypeException
+          end
+        end
+
+        context 'Form 3: typed_ary.new( ary )' do
+          it "should accept when all items match" do
+            subject.new(config[:match]).to_a.should == config[:match]
+          end
+
+          it "should raise when one object is the wrong type" do
+            expect{ subject.new(config[:fail][:one])}.to raise_error TypedArray::UnexpectedTypeException
+          end
+
+          it "should raise when more than one object is the wrong type" do
+            expect{ subject.new(config[:fail][:all])}.to raise_error TypedArray::UnexpectedTypeException
+          end
+        end
+
+        context 'Form 4: typed_ary.new(size){|index|block}' do
+          it "should populate when block returns the right type" do
+            subject.new(config[:match].length){|i| config[:match][i]}.to_a.should == config[:match]
+          end
+
+          it "should raise when block returns wrong type once" do
+            expect{ subject.new(config[:fail][:one].length){|i| config[:fail][:one][i]} }.to raise_error TypedArray::UnexpectedTypeException
+          end
+
+          it "should raise when block returns wrong type more than once" do
+            expect{ subject.new(config[:fail][:all].length){|i| config[:fail][:all][i]} }.to raise_error TypedArray::UnexpectedTypeException
+          end
+        end
+      end
+    end
+  end
+
+  [:<<,:unshift,:push].each do |method|
+    context %Q{typed_ary#{('a'..'z').include?(method.to_s[0]) ? '.' : ' '}#{method.to_s} other_ary} do
+      inputs.each_pair do |accepted_types,config|
+        context "when only accepting <#{accepted_types.inspect}>" do
+          before :each do
+            @typed_ary = TypedArray( *accepted_types).new(config[:base])
+            @ary = config[:base].to_a
+          end
+
+          context "when the item being pushed matches (#{config[:match].first})" do
+            before :each do
+              @item = config[:match].first
+            end
+
+            it "should return as Array would return" do
+              @typed_ary.send(method,@item).to_a.should == @ary.send(method,@item)
+            end
+
+            it "should modify the TypedArray as Array would be modified" do
+              @typed_ary.send(method,@item)
+              @ary.send(method,@item)
+              @typed_ary.to_a.should == @ary
+            end
+          end
+
+          context "when the item being pushed does not match (#{config[:fail][:all].first})" do
+            before :each do
+              @item = config[:fail][:all].first
+            end
+
+            it "should raise an exception" do
+              expect{ @typed_ary.send(method,@item) }.to raise_error TypedArray::UnexpectedTypeException
+            end
+
+            it "should not modify typed_ary" do
+              begin
+                backup = @typed_ary.to_a
+                @typed_ary.send(method,@item)
+              rescue TypedArray::UnexpectedTypeException
+              ensure
+                @typed_ary.to_a.should == backup
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  [:[]=].each do |method|
+    context %Q{typed_ary[idx]= other_ary} do
+      inputs.each_pair do |accepted_types,config|
+        context "when only accepting <#{accepted_types.inspect}>" do
+          before :each do
+            @typed_ary = TypedArray( *accepted_types).new(config[:base])
+            @ary = config[:base].to_a
+          end
+
+          context "when the item being pushed matches (#{config[:match].first})" do
+            before :each do
+              @item = config[:match].first
+            end
+
+            it "should return as Array would return" do
+              @typed_ary.send(method,4,@item).should == @ary.send(method,4,@item)
+            end
+
+            it "should modify the TypedArray as Array would be modified" do
+              @typed_ary.send(method,4,@item)
+              @ary.send(method,4,@item)
+              @typed_ary.to_a.should == @ary
+            end
+          end
+
+          context "when the item being pushed does not match (#{config[:fail][:all].first})" do
+            before :each do
+              @item = config[:fail][:all].first
+            end
+
+            it "should raise an exception" do
+
+              expect{ @typed_ary.send(method,4,@item) }.to raise_error TypedArray::UnexpectedTypeException
+            end
+
+            it "should not modify typed_ary" do
+              begin
+                backup = @typed_ary.to_a
+                @typed_ary.send(method,4,@item)
+              rescue TypedArray::UnexpectedTypeException
+              ensure
+                @typed_ary.to_a.should == backup
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  [:+,:&,:concat,:replace].each do |method|
+    context %Q{typed_ary#{('a'..'z').include?(method.to_s[0]) ? '.' : ' '}#{method.to_s} other_ary} do
+      inputs.each_pair do |accepted_types,config|
+        context "when only accepting <#{accepted_types.inspect}>" do
+          before :each do
+            @typed_ary = TypedArray( *accepted_types).new(config[:base])
+            @ary = config[:base].to_a
+          end
+
+          context "when all items match (#{config[:match].inspect})" do
+            before :each do
+              @other_ary = config[:match].to_a
+            end
+
+            it "should return as Array would return" do
+              @typed_ary.send(method,@other_ary).to_a.should == @ary.send(method,@other_ary)
+            end
+
+            it "should modify the TypedArray as Array would be modified" do
+              @typed_ary.send(method,@other_ary)
+              @ary.send(method,@other_ary)
+              @typed_ary.to_a.should == @ary
+            end
+          end
+
+          config[:fail].each_key do |fail_type|
+            context "when #{fail_type} item fails to match (#{config[:fail][fail_type].inspect})" do
+              before :each do
+                @other_ary = config[:fail][fail_type].to_a
+              end
+              unless method == :& # `and` opperator cannot produce elements that are not in both arrays already; since one is assuredly filtered, we can skip this.
+                it "should raise an exception" do
+                  expect{ @typed_ary.send(method,@other_ary) }.to raise_error TypedArray::UnexpectedTypeException
+                end
+              end
+
+              it "should not modify the TypedArray" do
+                begin
+                  backup = @typed_ary.to_a
+                  @typed_ary.send(method,@other_ary)
+                rescue TypedArray::UnexpectedTypeException
+                ensure
+                  @typed_ary.to_a.should == backup
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context 'when extending classes' do
+    before :each do
+      @base = TypedArray(Symbol)
+      @extension = Class.new( @base )
+    end
+
+    it 'should inherit default restrictions' do
+      @base.restricted_types.should == @extension.restricted_types
+    end
+
+    context 'when adding restricted_type to the parent' do
+      it 'should propogate to the child' do
+        @base.restricted_type Fixnum
+        @extension.restricted_types.should include(Fixnum)
+      end
+    end
+
+    context 'when adding restricted_type to the child' do
+      it 'should not propogate to the parent' do
+        @extension.restricted_type Fixnum
+        @base.restricted_types.should_not include(Fixnum)
+      end
+    end
+  end
+end

data/spec/typed_array_spec.rb

@@ -0,0 +1,278 @@
+require_relative 'spec_helper'
+require 'valid_array/typed_array'
+
+# We need to test in several different contexts, so provide the base info here.
+inputs = {
+  [Symbol]=>{
+    :base => [:foo,:bar],
+    :match => [:baz,:bingo],
+    :fail => {
+      :one => [:zip,0],
+      :all => ['string',Class]
+    }
+  },
+  [Fixnum] => {
+    :base => [ 1,2,3 ],
+    :match => [ 17,18,19 ],
+    :fail => {
+      :one => [22,:symbol,43],
+      :all => ['string',:symbol]
+    }
+  },
+  [String,Symbol] => {
+    :base => ['Foo',:foo],
+    :match => [:bar,'Bar'],
+    :fail => {
+      :one => [:yippee,'a string',17],
+      :all => [12,Class,Array]
+    }
+  }
+}
+
+describe ValidArray::TypedArray do
+  describe '#new' do
+    inputs.each_pair do |accepted_types, config|
+      context "when only accepting <#{accepted_types.inspect}>" do
+        subject { ValidArray::TypedArray( *accepted_types ) }
+
+        context 'Form 1: typed_ary.new()' do
+          it "should have zero-length" do
+            subject.new().length.should == 0
+          end
+
+          it "should be empty" do
+            subject.new().to_a.should be_empty
+          end
+        end
+
+        context 'Form 1: typed_ary.new(size)' do
+          it "should have the proper length" do
+            subject.new(5).length.should == 5
+          end
+
+          it "should conatin all nil values" do
+            subject.new(5).to_a.should == [nil,nil,nil,nil,nil]
+          end
+        end
+
+        context 'Form 2: typed_ary.new(size,object)' do
+          it "should have the proper length" do
+            subject.new(3,config[:match].first).length.should == 3
+          end
+
+          it "should conatin the value specified" do
+            subject.new(3,config[:match].first).to_a.should == [config[:match].first]*3
+          end
+
+          it "should raise when obj is the wrong type" do
+            expect{ subject.new( 3, config[:fail][:all].first ) }.to raise_error ValidArray::TypedArray::UnexpectedTypeException
+          end
+        end
+
+        context 'Form 3: typed_ary.new( ary )' do
+          it "should accept when all items match" do
+            subject.new(config[:match]).to_a.should == config[:match]
+          end
+
+          it "should raise when one object is the wrong type" do
+            expect{ subject.new(config[:fail][:one])}.to raise_error ValidArray::TypedArray::UnexpectedTypeException
+          end
+
+          it "should raise when more than one object is the wrong type" do
+            expect{ subject.new(config[:fail][:all])}.to raise_error ValidArray::TypedArray::UnexpectedTypeException
+          end
+        end
+
+        context 'Form 4: typed_ary.new(size){|index|block}' do
+          it "should populate when block returns the right type" do
+            subject.new(config[:match].length){|i| config[:match][i]}.to_a.should == config[:match]
+          end
+
+          it "should raise when block returns wrong type once" do
+            expect{ subject.new(config[:fail][:one].length){|i| config[:fail][:one][i]} }.to raise_error ValidArray::TypedArray::UnexpectedTypeException
+          end
+
+          it "should raise when block returns wrong type more than once" do
+            expect{ subject.new(config[:fail][:all].length){|i| config[:fail][:all][i]} }.to raise_error ValidArray::TypedArray::UnexpectedTypeException
+          end
+        end
+      end
+    end
+  end
+
+  [:<<,:unshift,:push].each do |method|
+    context %Q{typed_ary#{('a'..'z').include?(method.to_s[0]) ? '.' : ' '}#{method.to_s} other_ary} do
+      inputs.each_pair do |accepted_types,config|
+        context "when only accepting <#{accepted_types.inspect}>" do
+          before :each do
+            @typed_ary = ValidArray::TypedArray( *accepted_types).new(config[:base])
+            @ary = config[:base].to_a
+          end
+
+          context "when the item being pushed matches (#{config[:match].first})" do
+            before :each do
+              @item = config[:match].first
+            end
+
+            it "should return as Array would return" do
+              @typed_ary.send(method,@item).to_a.should == @ary.send(method,@item)
+            end
+
+            it "should modify the TypedArray as Array would be modified" do
+              @typed_ary.send(method,@item)
+              @ary.send(method,@item)
+              @typed_ary.to_a.should == @ary
+            end
+          end
+
+          context "when the item being pushed does not match (#{config[:fail][:all].first})" do
+            before :each do
+              @item = config[:fail][:all].first
+            end
+
+            it "should raise an exception" do
+              expect{ @typed_ary.send(method,@item) }.to raise_error ValidArray::TypedArray::UnexpectedTypeException
+            end
+
+            it "should not modify typed_ary" do
+              begin
+                backup = @typed_ary.to_a
+                @typed_ary.send(method,@item)
+              rescue ValidArray::TypedArray::UnexpectedTypeException
+              ensure
+                @typed_ary.to_a.should == backup
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  [:[]=].each do |method|
+    context %Q{typed_ary[idx]= other_ary} do
+      inputs.each_pair do |accepted_types,config|
+        context "when only accepting <#{accepted_types.inspect}>" do
+          before :each do
+            @typed_ary = ValidArray::TypedArray( *accepted_types).new(config[:base])
+            @ary = config[:base].to_a
+          end
+
+          context "when the item being pushed matches (#{config[:match].first})" do
+            before :each do
+              @item = config[:match].first
+            end
+
+            it "should return as Array would return" do
+              @typed_ary.send(method,4,@item).should == @ary.send(method,4,@item)
+            end
+
+            it "should modify the TypedArray as Array would be modified" do
+              @typed_ary.send(method,4,@item)
+              @ary.send(method,4,@item)
+              @typed_ary.to_a.should == @ary
+            end
+          end
+
+          context "when the item being pushed does not match (#{config[:fail][:all].first})" do
+            before :each do
+              @item = config[:fail][:all].first
+            end
+
+            it "should raise an exception" do
+
+              expect{ @typed_ary.send(method,4,@item) }.to raise_error ValidArray::TypedArray::UnexpectedTypeException
+            end
+
+            it "should not modify typed_ary" do
+              begin
+                backup = @typed_ary.to_a
+                @typed_ary.send(method,4,@item)
+              rescue ValidArray::TypedArray::UnexpectedTypeException
+              ensure
+                @typed_ary.to_a.should == backup
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  [:+,:&,:concat,:replace].each do |method|
+    context %Q{typed_ary#{('a'..'z').include?(method.to_s[0]) ? '.' : ' '}#{method.to_s} other_ary} do
+      inputs.each_pair do |accepted_types,config|
+        context "when only accepting <#{accepted_types.inspect}>" do
+          before :each do
+            @typed_ary = ValidArray::TypedArray( *accepted_types).new(config[:base])
+            @ary = config[:base].to_a
+          end
+
+          context "when all items match (#{config[:match].inspect})" do
+            before :each do
+              @other_ary = config[:match].to_a
+            end
+
+            it "should return as Array would return" do
+              @typed_ary.send(method,@other_ary).to_a.should == @ary.send(method,@other_ary)
+            end
+
+            it "should modify the TypedArray as Array would be modified" do
+              @typed_ary.send(method,@other_ary)
+              @ary.send(method,@other_ary)
+              @typed_ary.to_a.should == @ary
+            end
+          end
+
+          config[:fail].each_key do |fail_type|
+            context "when #{fail_type} item fails to match (#{config[:fail][fail_type].inspect})" do
+              before :each do
+                @other_ary = config[:fail][fail_type].to_a
+              end
+              unless method == :& # `and` opperator cannot produce elements that are not in both arrays already; since one is assuredly filtered, we can skip this.
+                it "should raise an exception" do
+                  expect{ @typed_ary.send(method,@other_ary) }.to raise_error ValidArray::TypedArray::UnexpectedTypeException
+                end
+              end
+
+              it "should not modify the TypedArray" do
+                begin
+                  backup = @typed_ary.to_a
+                  @typed_ary.send(method,@other_ary)
+                rescue ValidArray::TypedArray::UnexpectedTypeException
+                ensure
+                  @typed_ary.to_a.should == backup
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  context 'when extending classes' do
+    before :each do
+      @base = ValidArray::TypedArray(Symbol)
+      @extension = Class.new( @base )
+    end
+
+    it 'should inherit default restrictions' do
+      @base.restricted_types.should == @extension.restricted_types
+    end
+
+    context 'when adding restricted_type to the parent' do
+      it 'should propogate to the child' do
+        @base.restricted_type Fixnum
+        @extension.restricted_types.should include(Fixnum)
+      end
+    end
+
+    context 'when adding restricted_type to the child' do
+      it 'should not propogate to the parent' do
+        @extension.restricted_type Fixnum
+        @base.restricted_types.should_not include(Fixnum)
+      end
+    end
+  end
+end

data/spec/valid_array_spec.rb

@@ -0,0 +1,45 @@
+require_relative 'spec_helper'
+require 'valid_array'
+
+describe ValidArray do
+  context 'when custom validator is used' do
+    before :each do
+      class MyArray < Array
+        extend ValidArray
+        
+        def self.validate(e)
+          e.to_s
+        end
+      end
+      @typed_ary = MyArray.new(5) {|i| i}
+    end
+    
+    it 'should convert all values to strings' do
+      @typed_ary.each do |e|
+        e.should be_an_instance_of(String)
+      end
+    end
+  end
+   
+  context 'when custom validator is used' do
+    before :each do
+      class MyArray < Array
+        extend ValidArray
+        
+        def self.validate(e)
+          if e%2 == 0
+            e
+          else
+            raise ValidArray::DontInsertException
+          end
+        end
+      end
+      
+      @typed_ary = MyArray.new(10) {|i| i}
+    end
+    
+    it 'should drop when DontInsertException is raised' do
+      @typed_ary.should eql([0,2,4,6,8])
+    end
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: valid_array
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kevin Cox
+- Ryan Biesemeyer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.9'
+description: "\t\tAll methods that alter the contents of an array that implements
+  this\n\t\tGem are first checked to ensure that the added items are of the types\n\t\tallowed.
+  All methods behave exactly as their Array counterparts,\n\t\tincluding additional
+  forms, block processing, etc.\n"
+email: kevincox@kevincox.ca
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE
+- README.rdoc
+files:
+- lib/valid_array.rb
+- lib/valid_array/typed_array.rb
+- lib/valid_array/functions.rb
+- lib/typed-array.rb
+- spec/spec_helper.rb
+- spec/valid_array_spec.rb
+- spec/typed-array_spec.rb
+- spec/typed_array_spec.rb
+- LICENSE
+- README.rdoc
+homepage: http://github.com/kevincox/valid-array
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 1
+summary: Provides methods for creating type-enforced Arrays
+test_files: []
+has_rdoc: