arrayfu 0.2.4 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 258313bbff4e2d26f92f282bdfa88a4dbbc86c75
-  data.tar.gz: fb1abedd526aa8c20d8bb6f2430a438317076879
+  metadata.gz: 25afe24f24b068f40630cbfaeac49fb1de9c21d7
+  data.tar.gz: 87b6a78fb88a4fe163e4e3d18d98d879ddfa67a2
 SHA512:
-  metadata.gz: dde4ff14df434de2ea0369a9504d5a90ee36708fae4b8d39a3f46bff7d443f6ef13de082e918a7889e4c378fc1f08d7dcb4e49f6f4248f314f2fab7ddecd1376
-  data.tar.gz: 7d754406871a05ae68efde79f8f63d5ffb5754b7cd61571ba013a2657cf7e8e8a544feb0e7ad63af4e0249f99d5b2c02ba29c77c20abce37921da60f81df8f2c
+  metadata.gz: c3dfab3890ef09fa8db15fc4a93b27231d3c022e50fd02f1db3931852380441a4beb28a8996b3b322e42c11defcf35484a9f6b011d8ced698ab7f74fd1e2309f
+  data.tar.gz: 4519bc52d05189b69813c72c50e5823998e44f9b2868a5a02131d9d20da77acfcf9834bf791d6cb46c71e9ba95e1468716f9b75bff0ae66cdd29a7553b02ac21

data/.gitignore

@@ -4,3 +4,5 @@ Gemfile.lock
 .rvmrc
 .ruby-version
 .ruby-gemset
+.yardoc
+doc

data/README.md

@@ -0,0 +1,423 @@
+#ArrayFu
+
+One of the first ruby projects I. It is a simple dsl for declaritive arrays. Hopefully the examples below show how it can be used!
+
+##Examples
+
+```ruby
+example "Basic" do
+  class Example1
+    include ArrayFu
+
+    array :names
+  end
+end
+
+example 'Allow the array to have a read accessor' do
+  class Example2
+    include ArrayFu
+
+    array(:names) { readable }
+  end
+  Example2.new.names.should_not be_nil
+end
+
+example 'Allow the array to have a write accessor' do
+  class Example3
+    include ArrayFu
+
+    array(:names) { writeable }
+  end
+  instance = Example3.new
+  new_names = []
+  instance.names = new_names
+  instance.instance_eval do
+    @names.should == new_names
+  end
+end
+
+example 'Allow the array to have a read and write accessor' do
+  class Example4
+    include ArrayFu
+
+    array(:names) { read_and_write }
+  end
+  Example4.new.names.should_not be_nil
+end
+
+example 'Add a mutator method to the class that stores the array' do
+  class Example5
+    include ArrayFu
+
+    array(:names) { mutator :add_item }
+  end
+
+  instance = Example5.new
+  instance.add_item("JP")
+  instance.instance_eval do
+    @names.count.should == 1
+  end
+end
+
+example 'Add multiple mutators to the class that stores the array' do
+  class Example6
+    include ArrayFu
+
+    array :names do
+      mutator :add_item, :add_it, :push_it
+    end
+  end
+
+  instance = Example6.new
+  instance.add_item("JP")
+  instance.add_it("JP")
+  instance.push_it("JP")
+  instance.instance_eval do
+    @names.count.should == 3
+  end
+end
+
+example 'Add a mutator that ignores addition' do
+  class Example7
+    include ArrayFu
+
+    array :names do
+      mutator :add_item do|item|
+      end
+    end
+  end
+
+  instance = Example7.new
+  instance.add_item("JP")
+  instance.instance_eval do
+    @names.count.should == 0
+  end
+end
+
+example 'Add a mutator that does other custom logic as well as addition' do
+  class Example8
+    include ArrayFu
+
+    array(:secondary) { readable }
+
+    array :names do
+      readable
+      mutator :add_item do|item|
+        @secondary.push item
+        @names.push item
+      end
+    end
+  end
+
+  instance = Example8.new
+  instance.add_item("JP")
+  instance.names.count.should == 1
+  instance.secondary.count.should == 1
+end
+
+example 'Add a singular constraint and failure condition to each of the mutators' do
+  module NotBeJP
+    extend self
+
+    def matches?(item)
+      return item != "JP"
+    end
+
+    def name
+      return "The value should not be JP"
+    end
+  end
+
+  module CriteriaViolation
+    extend self
+
+    def run(description,value)
+
+    end
+  end
+
+  class Example9
+    include ArrayFu
+
+    array :names do
+      readable
+      mutator :add_item,:add_it
+      new_item_must NotBeJP, CriteriaViolation
+    end
+  end
+
+  instance = Example9.new
+  instance.add_item("JP")
+  instance.add_it("JP")
+  instance.names.count.should == 0
+end
+
+example 'Add multiple constraints and a failure condition to each of the mutators' do
+  module NotBeJP
+    extend self
+
+    def matches?(item)
+      return item != "JP"
+    end
+
+    def name
+      return "The value should not be JP"
+    end
+  end
+
+  module NotBeNil
+    extend self
+
+    def matches?(item)
+      return item != nil
+    end
+
+    def name
+      return "The value should not be nil"
+    end
+  end
+
+  module CriteriaViolation
+    extend self
+
+    def run(description,value)
+      # puts "Criteria violated - #{description} - #{value}"
+    end
+  end
+
+  class Example10
+    include ArrayFu
+
+    array :names do
+      readable
+      mutator :add_item,:add_it
+      addition_constraint NotBeJP
+      addition_constraint NotBeNil, CriteriaViolation
+    end
+  end
+
+  instance = Example10.new
+  instance.add_item("JP")
+  instance.add_it("JP")
+  instance.add_item(nil)
+  instance.names.count.should == 0
+end
+
+example 'Add an explicit processing visitor to the array' do
+  class DisplayItem
+    @@number_of_items_displayed = 0
+    class << self
+      def run_using(item)
+        @@number_of_items_displayed += 1
+      end
+      def item_count
+        return @@number_of_items_displayed
+      end
+    end
+  end
+
+  class Example11
+    include ArrayFu
+
+    array :names do
+      mutator :add_item
+      process_using :display_all,DisplayItem
+    end
+  end
+
+  instance = Example11.new
+  (1..10).each{|item| instance.add_item(item)}
+  instance.display_all
+  DisplayItem.item_count.should == 10
+end
+
+example 'Add an method based processing visitor to the array based on a method that exists on the items in the array' do
+  class Item
+    def process
+      Example12.increment
+    end
+  end
+
+  class Example12
+    @@items_visited = 0
+    include ArrayFu
+
+    array :names do
+      mutator :add_item
+      process_using :display_all, :process #the second symbol is the name of a method on an element in the array
+    end
+
+
+    #the process method of the Item class invokes this method (a little bit roundabout, but it hopefully demonstrates the capability
+    def self.increment
+      @@items_visited += 1
+    end
+    def self.number_of_items_visited
+      @@items_visited
+    end
+  end
+
+  instance = Example12.new
+  (1..10).each{|item| instance.add_item(Item.new)}
+  instance.display_all
+  Example12.number_of_items_visited.should == 10
+end
+
+example 'Augment configuration using configuration block' do
+  class ArrayConfigs
+    def self.add_another_mutator
+      return lambda{|item| item.mutator :another_push}
+    end
+  end
+
+  class Example13
+    include ArrayFu
+
+    array :names do
+      readable
+      mutator :add_item
+      configure_using ArrayConfigs.add_another_mutator
+    end
+  end
+
+  instance = Example13.new
+  instance.add_item("Yo")
+  instance.another_push("Yo")
+  instance.names.count.should == 2
+end
+
+example 'Augment configuration using inline configuration block' do
+  class Example14
+    include ArrayFu
+
+    array :names do
+      readable
+      mutator :add_item
+      configure_using -> (item) do
+        item.mutator :another_pushes
+      end
+    end
+  end
+
+  instance = Example14.new
+  instance.add_item("Yo")
+  instance.another_pushes("Yo")
+  instance.names.count.should == 2
+end
+
+example 'Augment configuration using configuration instance (anything that responds to configure with the array definition as the argument)' do
+
+  module ArrayConfiguration
+    extend self
+
+    def configure(item)
+      item.mutator :once_more
+    end
+  end
+
+  class Example15
+    include ArrayFu
+
+    array :names do
+      readable
+      mutator :add_item
+      configure_using ArrayConfiguration
+    end
+  end
+
+  instance = Example15.new
+  instance.add_item("Yo")
+  instance.once_more("Yo")
+  instance.names.count.should == 2
+end
+
+example 'Augment configuration using configuration block' do
+
+  module ArrayConfiguration
+    extend self
+
+    def configuration_block
+      Proc.new do|array|
+        array.mutator :once_more
+      end
+    end
+  end
+
+  class Example16
+    include ArrayFu
+
+    array :names do
+      readable
+      mutator :add_item
+      configure_using ArrayConfiguration.configuration_block
+    end
+  end
+
+  instance = Example16.new
+  instance.add_item("Yo")
+  instance.once_more("Yo")
+  instance.names.count.should == 2
+end
+
+example 'Augment configuration of an existing array' do
+
+  module ExampleConfig1
+    extend self
+
+    def configuration_block
+      -> (array) { array.mutator :once_more }
+    end
+  end
+
+  class Example17
+    include ArrayFu
+
+    array :names do
+      readable
+      mutator :add_item
+    end
+
+    def initialize
+      array :names do
+        configure_using ExampleConfig1.configuration_block
+      end
+      super
+    end
+  end
+
+  instance = Example17.new
+  instance.add_item("Yo")
+  instance.once_more("Yo")
+  instance.names.count.should == 2
+end
+
+example 'Alternate way to augment configuration of an existing array' do
+
+  module ExampleConfig3
+    extend self
+
+    def configure(array_definition)
+      array_definition.mutator :once_more
+    end
+  end
+
+  class Example18
+    include ArrayFu
+
+    array :names do
+      readable
+      mutator :add_item
+    end
+
+    def initialize(config)
+      config.configure(array(:names))
+      super
+    end
+  end
+
+  instance = Example18.new(ExampleConfig3)
+  instance.add_item("Yo")
+  instance.once_more("Yo")
+  instance.names.count.should == 2
+end
+```

data/arrayfu.gemspec

@@ -20,6 +20,7 @@ Gem::Specification.new do |s|
 
   # specify any dependencies here; for example:
   s.add_development_dependency("rake", "~> 0.9.0")
+  s.add_development_dependency("yard", "~> 0.8.7.4")
   s.add_development_dependency("guard", "~> 2.6.1")
   s.add_development_dependency("guard-rspec", "~> 4.2.9")
   s.add_development_dependency("fakes-rspec", "~> 2.0.0")

data/lib/arrayfu/array_definition.rb

@@ -1,41 +1,121 @@
 module ArrayFu
+  # A builder for specifying behaviours exposed by a class that defines arrays
   class ArrayDefinition
     include Initializer
 
-    attr_accessor :name
-    attr_accessor :writable
+    # The name that will be given to this array definition, it will also become a variable named @[name] on the class that defined this array
+    attr_reader :name
+    # Flag for writeability
+    attr_accessor :writeable
+    # Flag for readability
     attr_accessor :readable
+    # List of mutator definitions for this array
     attr_accessor :mutators
+    # List of processing visitors
     attr_accessor :visitors 
+
+    # The list of constraints specified for this array definition
     attr_accessor :constraints
 
+    # Create an array definition with the specified name
+    #
+    # == Parameters:
+    # @name:: 
+    #   Name given to the array definition. This name will also be used to generate a variable on the target class named: @[name]
     def initialize(name)
       @name = name
       initialize_arrays :mutators, :visitors, :constraints
-      initialize_false :writable, :readable
+      initialize_false :writeable, :readable
     end
 
+    # Flag that the class that is defining this array will expose both a reader and writer for the array variable
+    #
+    # Example:
+    #
+    #   class SomeClass
+    #     include ArrayFu
+    #
+    #     array :names { read_and_write }
+    #   end
+    #
+    # The above is the same as the following
+    #   
+    #   class SomeClass
+    #     attr_accessor :names
+    #
+    #     def initialize
+    #       @names = []
+    #     end
+    #   end
     def read_and_write
-      writable
+      writeable
       readable
     end
 
-    def writable
-      @writable = true
+
+    # Flag that the class that is defining this array will expose a writer for the array variable
+    def writeable
+      @writeable = true
     end
 
+    # Flag that the class that is defining this array will expose a writer for the array variable
     def readable
       @readable = true
     end
 
-    def writable?
-      @writable ||= false
+    # Used by internal infrastructure to determine if this arraydefinition should expose a writer for the array variable
+    def writeable?
+      @writeable ||= false
     end
 
+    # Used by internal infrastructure to determine if this arraydefinition should expose a reader for the array variable
     def readable?
       @readable ||= false
     end
 
+    # This method allows for external configurators to customize the behaviour of this array definition
+    # == Parameters:
+    # configurators::
+    #   One or many objects/blocks (can be a mix). If a configurator is an object, it must respond to the following method:
+    #     def configure(definition) 
+    #   Where definition is an {ArrayDefinition}.
+    #   
+    #   If a configurator is a block, it will be a block that takes a singular parameter which is the {ArrayDefinition}
+    # Examples:
+    #
+    # * Configuring using an object
+    #
+    #     class SomeConfigurator
+    #       def self.configure(array_definition)
+    #         array_definition.mutator :add_it
+    #       end
+    #     end
+    #
+    #     class SomeClass
+    #       include ArrayFu
+    #
+    #       array :names do
+    #         configure_using SomeConfigurator
+    #       end
+    #     end
+    #
+    #     instance = SomeClass.new
+    #     instance.add_it('JP')
+    #
+    # * Configuring using a lambda
+    #
+    #     class SomeClass
+    #       include ArrayFu
+    #
+    #       array :names do
+    #         configure_using -> (item) do
+    #           item.mutator :add_it
+    #         end
+    #       end
+    #     end
+    #
+    #     instance = SomeClass.new
+    #     instance.add_it('JP')
     def configure_using(*configurators)
       configurators.each do|configurator|
         method = configurator.respond_to?(:configure) ? :configure : 'call'.to_sym
@@ -43,12 +123,70 @@ module ArrayFu
       end
     end
 
+    # Method used to specify a list of methods that will be exposed on the class that is defining this array. The methods are write methods that will push data back to the underlying array
+    #
+    # == Parameters:
+    # names::
+    #   Method names that will be used to expose push methods to this array
+    # &block::
+    #   If provided, this block will be run anytime the mutator method is invoked. It's single parameter is the new item that is attempting to be added to the underlying array
+    #   if you provide this block, and dont push the item parameter back to the original array, no changes will happen to the underlying array
+    #
+    # Examples:
+    #
+    #     class SomeClass
+    #       include ArrayFu
+    #
+    #       array :names { mutator :add_item }
+    #     end
+    #
+    # The above will generate an instance method named :add_item on the SomeClass class. When you call this method, the names array will have an item pushed to it:
+    #
+    #     instance = SomeClass.new
+    #     instance.add_item('Hello') #the @names array variable will now contain ['Hello']
+    #
+    # You can specify multiple mutators at once:
+    #
+    #     class SomeClass
+    #       include ArrayFu
+    #
+    #       array :names do
+    #         mutator :add_item, 
+    #                 :add_another, 
+    #                 :add_one_more 
+    #       end
+    #     end
+    #
+    #     instance = SomeClass.new
+    #     instance.add_item('JP')
+    #     instance.add_another('Yeah')
+    #     instance.add_one_more('Yep')
+    # 
+    # Example:
+    #
+    # * A mutator with custom logic in a block
+    #
+    #     class SomeClass
+    #       include ArrayFu
+    #
+    #       array :names do
+    #         mutator :add_one do |item|
+    #           puts 'About to add one new item #{item}'
+    #           @names.push(item) #if this does not happen, no changes will occur to the underlying array
+    #         end
+    #       end
+    #     end
+    #
+    #     instance = SomeClass.new
+    #     instance.add_one('JP') # at this point we will see a console out
+    #       
     def mutator(*names, &block)
       names.each do |mutator_name| 
         self.mutators.push(MutatorDefinition.new(mutator_name, block))
       end
     end
 
+    # Null object implementation for a constraint failure (No-op)
     module NoFailure
       extend self
 
@@ -56,18 +194,31 @@ module ArrayFu
       end
     end
 
+    # Run each of its {ArrayFu::MutatorDefinition} against the provided block
     def each_mutator(&block)
       mutators.each &block 
     end
 
+    # Run each of its {ArrayFu::ItemConstraint} against the provided block
     def each_constraint(&block)
       constraints.each &block
     end
 
+    # Run each of its {ArrayFu::VisitorDefinition} against the provided block
     def each_visitor(&block)
       visitors.each &block
     end
 
+    # Adds a constraint that must be met for any new item being passed to a mutator method
+    # == Parameters:
+    # constraint::
+    #   An object that responds to the following 2 methods:
+    #     name: - Should return a descriptive name for the constraint
+    #     matches?(item) - The constraint method, it will be called with any new item about to be added
+    # fail_option (defaults to {ArrayFu::ArrayDefinition::NoFailure})::
+    #   An object that responds to the following methods:
+    #     run(description, value) - Behaviour to run when the constraint is not met. It is given the description of the failed constraint, and the value
+    #     that did not meet the constraint
     def addition_constraint(constraint, fail_option = NoFailure)
       self.constraints.push(ItemConstraint.new(constraint, fail_option))
     end
@@ -77,6 +228,7 @@ module ArrayFu
       self.visitors.push(VisitorDefinition.new(name, visitor))
     end
 
+    # Method used by internal builder mechanism. Specifies the name that will be used for the backing array variable for this array definition
     def variable_name
       "@#{@name}"
     end

data/lib/arrayfu/arrayfu.rb

@@ -1,3 +1,5 @@
+# Main module that can be mixed in to allow for declaritive array definitions
+#
 module ArrayFu
   include Initializer
 
@@ -5,6 +7,27 @@ module ArrayFu
     base.extend ClassMethods 
   end
 
+  # This method is here to ensure that all of the array definitions are expanded and a variable instance is assigned to the variable name specified by the array
+  # If you are mixing in this module and the class has its own constructor definition, make sure you call super to ensure that array initialization occurs correctly as shown:
+  #
+  #   class SomeClass
+  #     include ArrayFu
+  #
+  #     array :names
+  #
+  #     def initialize(some_value)
+  #       super
+  #     end
+  #   end
+  #
+  # If your class does not contain custom constructor logic, no extra code is needed:
+  #
+  #
+  #   class SomeClass
+  #     include ArrayFu
+  #
+  #     array :names
+  #   end
   def initialize(*args)
     self.class.each_array_definition do |array_definition|
       initialize_arrays(array_definition.name)
@@ -12,6 +35,49 @@ module ArrayFu
     end
   end
 
+  # Array definition dsl entry point
+  #
+  # == Parameters:
+  # name::
+  #   A name that will be used to initialize a variable on the class that is including this module.
+  #   It will serve as the backing array for the array definition
+  #
+  # &block::
+  #   A configuration block that will serve to configure an {ArrayFu::ArrayDefinition}
+  #
+  # Examples:
+  #
+  # * Define a basic array
+  #     
+  #     class SomeClass
+  #       include ArrayFu
+  #         
+  #       array :names
+  #     end
+  #
+  # * Define a basic array that supports a read accessor
+  #     
+  #     class SomeClass
+  #       include ArrayFu
+  #         
+  #       array :names { readable }
+  #     end
+  #
+  # * Define a basic array that supports a write accessor
+  #     
+  #     class SomeClass
+  #       include ArrayFu
+  #         
+  #       array :names { writeable }
+  #     end
+  #
+  # * Define a basic array that supports both read and write accessors
+  #     
+  #     class SomeClass
+  #       include ArrayFu
+  #         
+  #       array :names { read_and_write }
+  #     end
   def array(name, &block)
     self.class.array(name, &block)
   end

data/lib/arrayfu/generate_writers.rb

@@ -4,7 +4,7 @@ module ArrayFu
 
     def create_using(builder)
       Module.new do
-        if (builder.writable?)
+        if (builder.writeable?)
           define_method("#{builder.name}=") do|value|
             instance_variable_set(builder.variable_name, value)
           end

data/lib/arrayfu/version.rb

@@ -1,3 +1,3 @@
 module ArrayFu
-  VERSION = "0.2.4"
+  VERSION = "1.0.0"
 end

data/spec/examples/usage_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 example "Basic" do
-  class SomeClass
+  class Example1
     include ArrayFu
 
     array :names
@@ -9,46 +9,53 @@ example "Basic" do
 end
 
 example 'Allow the array to have a read accessor' do
-  class SomeClass
+  class Example2
     include ArrayFu
 
     array(:names) { readable }
   end
-  SomeClass.new.names.should_not be_nil
+  Example2.new.names.should_not be_nil
 end
 
 example 'Allow the array to have a write accessor' do
-  class SomeClass
+  class Example3
     include ArrayFu
 
-    array(:names) { writable }
+    array(:names) { writeable }
+  end
+  instance = Example3.new
+  new_names = []
+  instance.names = new_names
+  instance.instance_eval do
+    @names.should == new_names
   end
-  SomeClass.new.names.should_not be_nil
 end
 
 example 'Allow the array to have a read and write accessor' do
-  class SomeClass
+  class Example4
     include ArrayFu
 
     array(:names) { read_and_write }
   end
-  SomeClass.new.names.should_not be_nil
+  Example4.new.names.should_not be_nil
 end
 
 example 'Add a mutator method to the class that stores the array' do
-  class SomeClass
+  class Example5
     include ArrayFu
 
     array(:names) { mutator :add_item }
   end
 
-  items = SomeClass.new
-  items.add_item("JP")
-  items.names.count.should == 1
+  instance = Example5.new
+  instance.add_item("JP")
+  instance.instance_eval do
+    @names.count.should == 1
+  end
 end
 
 example 'Add multiple mutators to the class that stores the array' do
-  class SomeClass
+  class Example6
     include ArrayFu
 
     array :names do
@@ -56,15 +63,17 @@ example 'Add multiple mutators to the class that stores the array' do
     end
   end
 
-  items = SomeClass.new
-  items.add_item("JP")
-  items.add_it("JP")
-  items.push_it("JP")
-  items.names.count.should == 3
+  instance = Example6.new
+  instance.add_item("JP")
+  instance.add_it("JP")
+  instance.push_it("JP")
+  instance.instance_eval do
+    @names.count.should == 3
+  end
 end
 
 example 'Add a mutator that ignores addition' do
-  class SomeClass
+  class Example7
     include ArrayFu
 
     array :names do
@@ -73,13 +82,15 @@ example 'Add a mutator that ignores addition' do
     end
   end
 
-  items = SomeClass.new
-  items.add_item("JP")
-  items.names.count.should == 0
+  instance = Example7.new
+  instance.add_item("JP")
+  instance.instance_eval do
+    @names.count.should == 0
+  end
 end
 
 example 'Add a mutator that does other custom logic as well as addition' do
-  class SomeClass
+  class Example8
     include ArrayFu
 
     array(:secondary) { readable }
@@ -93,10 +104,10 @@ example 'Add a mutator that does other custom logic as well as addition' do
     end
   end
 
-  items = SomeClass.new
-  items.add_item("JP")
-  items.names.count.should == 1
-  items.secondary.count.should == 1
+  instance = Example8.new
+  instance.add_item("JP")
+  instance.names.count.should == 1
+  instance.secondary.count.should == 1
 end
 
 example 'Add a singular constraint and failure condition to each of the mutators' do
@@ -120,19 +131,20 @@ example 'Add a singular constraint and failure condition to each of the mutators
     end
   end
 
-  class SomeClass
+  class Example9
     include ArrayFu
 
     array :names do
+      readable
       mutator :add_item,:add_it
       new_item_must NotBeJP, CriteriaViolation
     end
   end
 
-  items = SomeClass.new
-  items.add_item("JP")
-  items.add_it("JP")
-  items.names.count.should == 0
+  instance = Example9.new
+  instance.add_item("JP")
+  instance.add_it("JP")
+  instance.names.count.should == 0
 end
 
 example 'Add multiple constraints and a failure condition to each of the mutators' do
@@ -168,21 +180,22 @@ example 'Add multiple constraints and a failure condition to each of the mutator
     end
   end
 
-  class SomeClass
+  class Example10
     include ArrayFu
 
     array :names do
+      readable
       mutator :add_item,:add_it
       addition_constraint NotBeJP
       addition_constraint NotBeNil, CriteriaViolation
     end
   end
 
-  items = SomeClass.new
-  items.add_item("JP")
-  items.add_it("JP")
-  items.add_item(nil)
-  items.names.count.should == 0
+  instance = Example10.new
+  instance.add_item("JP")
+  instance.add_it("JP")
+  instance.add_item(nil)
+  instance.names.count.should == 0
 end
 
 example 'Add an explicit processing visitor to the array' do
@@ -198,7 +211,7 @@ example 'Add an explicit processing visitor to the array' do
     end
   end
 
-  class SomeClass
+  class Example11
     include ArrayFu
 
     array :names do
@@ -207,20 +220,20 @@ example 'Add an explicit processing visitor to the array' do
     end
   end
 
-  items = SomeClass.new
-  (1..10).each{|item| items.add_item(item)}
-  items.display_all
+  instance = Example11.new
+  (1..10).each{|item| instance.add_item(item)}
+  instance.display_all
   DisplayItem.item_count.should == 10
 end
 
 example 'Add an method based processing visitor to the array based on a method that exists on the items in the array' do
   class Item
     def process
-      SomeClass.increment
+      Example12.increment
     end
   end
 
-  class SomeClass
+  class Example12
     @@items_visited = 0
     include ArrayFu
 
@@ -239,10 +252,10 @@ example 'Add an method based processing visitor to the array based on a method t
     end
   end
 
-  items = SomeClass.new
-  (1..10).each{|item| items.add_item(Item.new)}
-  items.display_all
-  SomeClass.number_of_items_visited.should == 10
+  instance = Example12.new
+  (1..10).each{|item| instance.add_item(Item.new)}
+  instance.display_all
+  Example12.number_of_items_visited.should == 10
 end
 
 example 'Augment configuration using configuration block' do
@@ -252,19 +265,39 @@ example 'Augment configuration using configuration block' do
     end
   end
 
-  class SomeClass
+  class Example13
     include ArrayFu
 
     array :names do
+      readable
       mutator :add_item
       configure_using ArrayConfigs.add_another_mutator
     end
   end
 
-  items = SomeClass.new
-  items.add_item("Yo")
-  items.another_push("Yo")
-  items.names.count.should == 2
+  instance = Example13.new
+  instance.add_item("Yo")
+  instance.another_push("Yo")
+  instance.names.count.should == 2
+end
+
+example 'Augment configuration using inline configuration block' do
+  class Example14
+    include ArrayFu
+
+    array :names do
+      readable
+      mutator :add_item
+      configure_using -> (item) do
+        item.mutator :another_pushes
+      end
+    end
+  end
+
+  instance = Example14.new
+  instance.add_item("Yo")
+  instance.another_pushes("Yo")
+  instance.names.count.should == 2
 end
 
 example 'Augment configuration using configuration instance (anything that responds to configure with the array definition as the argument)' do
@@ -277,19 +310,20 @@ example 'Augment configuration using configuration instance (anything that respo
     end
   end
 
-  class SomeClass
+  class Example15
     include ArrayFu
 
     array :names do
+      readable
       mutator :add_item
       configure_using ArrayConfiguration
     end
   end
 
-  items = SomeClass.new
-  items.add_item("Yo")
-  items.once_more("Yo")
-  items.names.count.should == 2
+  instance = Example15.new
+  instance.add_item("Yo")
+  instance.once_more("Yo")
+  instance.names.count.should == 2
 end
 
 example 'Augment configuration using configuration block' do
@@ -304,50 +338,80 @@ example 'Augment configuration using configuration block' do
     end
   end
 
-  class SomeClass
+  class Example16
     include ArrayFu
 
     array :names do
+      readable
       mutator :add_item
       configure_using ArrayConfiguration.configuration_block
     end
   end
 
-  items = SomeClass.new
-  items.add_item("Yo")
-  items.once_more("Yo")
-  items.names.count.should == 2
+  instance = Example16.new
+  instance.add_item("Yo")
+  instance.once_more("Yo")
+  instance.names.count.should == 2
 end
 
 example 'Augment configuration of an existing array' do
 
-  module ArrayConfiguration
+  module ExampleConfig1
     extend self
 
     def configuration_block
-      Proc.new do|array|
-        array.mutator :once_more
-      end
+      -> (array) { array.mutator :once_more }
     end
   end
 
-  class SomeClass
+  class Example17
     include ArrayFu
 
     array :names do
+      readable
       mutator :add_item
     end
 
     def initialize
-      super
       array :names do
-        configure_using ArrayConfiguration.configuration_block
+        configure_using ExampleConfig1.configuration_block
       end
+      super
+    end
+  end
+
+  instance = Example17.new
+  instance.add_item("Yo")
+  instance.once_more("Yo")
+  instance.names.count.should == 2
+end
+
+example 'Alternate way to augment configuration of an existing array' do
+
+  module ExampleConfig3
+    extend self
+
+    def configure(array_definition)
+      array_definition.mutator :once_more
+    end
+  end
+
+  class Example18
+    include ArrayFu
+
+    array :names do
+      readable
+      mutator :add_item
+    end
+
+    def initialize(config)
+      config.configure(array(:names))
+      super
     end
   end
 
-  items = SomeClass.new
-  items.add_item("Yo")
-  items.once_more("Yo")
-  items.names.count.should == 2
+  instance = Example18.new(ExampleConfig3)
+  instance.add_item("Yo")
+  instance.once_more("Yo")
+  instance.names.count.should == 2
 end

data/spec/specs/generate_writers_step_spec.rb

@@ -9,7 +9,7 @@ module ArrayFu
         let(:sut){GenerateWriters}
         let(:builder){ArrayDefinition.new(:numbers)}
         before (:each) do
-          builder.writable
+          builder.writeable
         end
         before (:each) do
           target.extend(sut.create_using(builder))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: arrayfu
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 1.0.0
 platform: ruby
 authors:
 - Develop With Passion®
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-26 00:00:00.000000000 Z
+date: 2014-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.7.4
 - !ruby/object:Gem::Dependency
   name: guard
   requirement: !ruby/object:Gem::Requirement
@@ -77,6 +91,7 @@ files:
 - Gemfile
 - Guardfile
 - LICENSE
+- README.md
 - Rakefile
 - arrayfu.gemspec
 - lib/arrayfu.rb
@@ -137,3 +152,4 @@ test_files:
 - spec/specs/generate_writers_step_spec.rb
 - spec/specs/initializer_spec.rb
 - spec/specs/item_constraint_spec.rb
+has_rdoc: