augmented_array 0.0.1

data/README

@@ -0,0 +1,86 @@
+Author:
+====
+Niranjan Sarade
+
+About Augmented Array:
+====
+The Ruby Array class is extended with some traversing/iterating methods and you will also be able to get
+and set the individual array elements with indexes as of the indexes were attributes of an array.
+
+Example:
+====
+require 'augmented_array'
+
+[nil,1,2,nil,3].nilitems   # =>  2
+
+[1,2,3,4,5].sum     # => 15
+
+[1,2,3,4,5,6]/1      # => [[1], [2], [3], [4], [5], [6]]
+[1,2,3,4,5,6]/2      # => [[1, 2], [3, 4], [5, 6]]
+[1,2,3,4,5,6]/8      # => [[1, 2, 3, 4, 5, 6]]
+[]/2                 # => []
+
+[1,2,3,4,5].middle      # => 3
+[1,2,3,4].middle        # => [2, 3]
+[1].middle              # => 1
+
+ary = [1,2,3]
+ary.first = 20
+ary.first       # => 20
+
+[1,1.0,"test",{:key => "value"}].describe   # =>  [{1=>"Fixnum"}, {1.0=>"Float"}, {"test"=>"String"}, {{:key=>"value"}=>"Hash"}]
+
+ary = [1,2,3]
+ary.last = 20
+ary.last       # => 20
+
+[1,2,3,4,5].second_last      # => 4
+[1].second_last              # => nil
+
+ary = [1,2,3,4,5]
+ary.alternate           # => [[1, 3, 5], [2, 4]]
+ary                     # => [1,2,3,4,5]
+
+ary = [1,2,3,4,5]
+ary.alternate!           # => [[1, 3, 5], [2, 4]]
+ary                      # => [[1, 3, 5], [2, 4]]
+
+ary = [1,2,3,4,5,6,7]
+ary.second = 20
+ary.third = 30
+ary.fourth = 40
+ary.fifth = 50
+ary                   # => [1, 20, 30, 40, 50]
+ary.second            # => 20
+ary.third             # => 30
+ary._0 = 25
+ary._0                # => 25 # Similar to ary.at(0) or ary.fetch(0)
+ary._1 = 10
+ary._1                # => 10
+ary._11 = 11
+ary                   # => [25, 10, 30, 40, 50, nil, nil, nil, nil, nil, nil, 11]
+
+ary.each_index { |index|
+    eval("p ary._#{index}")
+  }
+  
+ary.each_index { |index|
+    eval("ary._#{index} = 10")  
+  }
+
+Install:
+====
+gem install augmented_array
+
+(It has been pushed to http://gemcutter.org)
+
+OR
+
+Download the gem file from http://github.com/NiranjanSarade/augmented_array.git/
+gem install augmented_array-0.0.1.gem
+
+Uninstall:
+====
+gem uninstall augmented_array
+
+

data/lib/augmented_array.rb

@@ -0,0 +1,255 @@
+# 
+# augmented_array.rb
+# 
+# The Ruby Array class is extended with some traversing methods and you will also be able to get and set the 
+# individual array elements with indexes as of the indexes were attributes of an array.
+#
+ 
+Array.class_eval do
+  
+  Map = {:second => 1, :third => 2, :fourth => 3, :fifth => 4, :sixth => 5, :seventh => 6, :eighth => 7, :ninth => 8, :tenth => 9}
+  
+  # Returns array of hashes with element as key and its class as value
+  #
+  #  [1,1.0,"test",{:key => "value"}].describe   # =>  [{1=>"Fixnum"}, {1.0=>"Float"}, {"test"=>"String"}, {{:key=>"value"}=>"Hash"}]
+  #  [1,2,3].describe     # =>  [{1=>"Fixnum"}, {2=>"Fixnum"}, {3=>"Fixnum"}]
+  #  [[1,2],1].describe   # => [{[1, 2]=>"Array"}, {1=>"Fixnum"}]
+  #  [].describe          # => []
+  #
+  def describe
+    ary = []
+    each do |element|
+      ary << {element => element.class.to_s}
+    end
+    ary
+  end  
+  
+  # Returns count of nil items in the array
+  #
+  #  [nil,1,2,nil,3].nilitems   # =>  2
+  #  [1,2,3].nilitems           # => 0
+  #  [].nilitems                # => 0
+  #
+  def nilitems
+    size - nitems
+  end
+  
+  # Returns the sum of all elements in an integer or float array
+  #
+  #  [1,2,3,4,5].sum     # => 15
+  #  [1.1,2.3,4.56].sum  # => 7.96
+  #  [1,2.5,5].sum       # => 8.5
+  #  [].sum              # => nil
+  #  [1,2,"test"].sum    # => The array should be either an integer or float array (RuntimeError)
+  #
+  def sum
+    each do |element|
+      unless element.nil? 
+        if !element.kind_of?(Fixnum) and !element.kind_of?(Float)
+          raise RuntimeError, "The array should be either an integer or float array"
+        end
+      end
+    end  
+    sum = 0
+    self.inject {|sum, n| n = 0 if n.nil?; sum + n }
+  end
+  
+  # Returns a new array by splitting the array into arrays of int divisor elements each
+  # 
+  # [1,2,3,4,5,6]/1      # => [[1], [2], [3], [4], [5], [6]]
+  # [1,2,3,4,5,6]/2      # => [[1, 2], [3, 4], [5, 6]]
+  # [1,2,3,4,5,6]/3      # => [[1, 2, 3], [4, 5, 6]]
+  # [1,2,3,4,5,6]/4      # => [[1, 2, 3, 4], [5, 6]]
+  # [1,2,3,4,5,6]/8      # => [[1, 2, 3, 4, 5, 6]]
+  # []/2                 # => []
+  # [1,2,3]/-2           # => Invalid argument -> -2 (ArgumentError)
+  # [1,2,3]/0            # => Invalid argument -> 0 (ArgumentError)
+  #
+  def /(number)
+      raise ArgumentError, "Invalid argument -> #{number.inspect}"  if !number.kind_of?(Fixnum) or number.zero? or (number < 0)
+      divisor = number.to_i
+      split, last, start, final_ary = size.div(divisor), size.modulo(divisor), 0, []
+      split.times {
+        final_ary << self[start, divisor]
+        start += divisor
+      }
+      final_ary << self[start, last] unless last.zero?
+      final_ary
+  end
+
+  # Returns middle or central element of the array
+  # 
+  # [1,2,3,4,5].middle      # => 3
+  # [1,2,3,4].middle        # => [2, 3]
+  # [1,2,3,4,5,6].middle    # => [3, 4]
+  # [1].middle              # => 1
+  # [].middle               # => nil
+  #  
+  def middle
+      len = self.size
+      return nil if len.zero?
+      div = len.div(2)
+      if len.modulo(2).zero?
+        [self[div-1],self[div]] 
+      else
+        self[div]
+      end
+  end  
+  
+  # Sets value of the first element of the array
+  # 
+  # ary = [1,2,3]
+  # ary.first = 20
+  # ary.first       # => 20
+  # ary = []
+  # ary.first = 10
+  # ary.first       # => 10
+  #  
+  def first= value
+    self[0] = value
+  end
+  
+  # Sets value of the last element of the array
+  # 
+  # ary = [1,2,3]
+  # ary.last = 20
+  # ary.last       # => 20
+  # ary = []
+  # ary.last = 10
+  # ary.last       # => 10
+  #  
+  def last= value
+    return self[size-1] = value if size > 0
+    self[0] = value if size == 0
+  end
+  
+  # Returns second last element of the array
+  # 
+  # [1,2,3,4,5].second_last      # => 4
+  # [1].second_last              # => nil
+  # [].second_last               # => nil
+  #  
+  def second_last
+    return nil if (size-2) < 0
+    self[size-2]
+  end
+  
+  # Returns array of alternate elements collected in arrays
+  # 
+  # ary = [1,2,3,4,5]
+  # ary.alternate           # => [[1, 3, 5], [2, 4]]
+  # ary                     # => [1,2,3,4,5] 
+  # [1,2,3,4].alternate     # => [[1, 3], [2, 4]]
+  # [1,2].alternate         # => [[1], [2]]
+  # [1].alternate           # => [[1]]
+  # [].alternate            # => []
+  #
+  def alternate
+    return [] if size.zero?
+    return [[self[0]]] if size == 1       
+    populate_alternate_arrays
+  end  
+  
+  # Modifies the array by returning array of alternate elements collected in arrays
+  # 
+  # ary = [1,2,3,4,5]
+  # ary.alternate!           # => [[1, 3, 5], [2, 4]]
+  # ary                      # => [[1, 3, 5], [2, 4]]
+  # [1,2,3,4].alternate!     # => [[1, 3], [2, 4]]
+  # [1,2].alternate!         # => [[1], [2]]
+  # [1].alternate!           # => [[1]]
+  # [].alternate!            # => []
+  # 
+  def alternate!
+    return self if size.zero?
+    first = self[0]
+    return self.clear << [first] if size == 1
+    ary1, ary2 =  populate_alternate_arrays
+    self.clear << ary1 << ary2
+  end
+
+  #  Returns block call once with iterating the array elements incremented by positive step, passing that array element as a parameter
+  #  
+  #  [1,2,3,4,5,6].step_by(2){|x| p x}  # => 1 3 5
+  #  [1,2,3].step_by(1){|x| p x}        # => 1 2 3
+  #  [1,2,3,4].step_by(6){|x| p x}      # => 1
+  #  [1,2].step_by(0){|x| p x}          # => Step can't be 0 or negative (ArgumentError)
+  #  [1,2].step_by(-1){|x| p x}         # => Step can't be 0 or negative (ArgumentError)
+  #  [1.2].step_by(1)                   # => no block given (LocalJumpError)
+  #  
+  def step_by(n)
+      raise ArgumentError, "Step can't be 0 or negative" if n.zero? or n < 0
+      0.step(size-1,n) {|i| yield self[i]}
+  end  
+  
+  # Sets and gets the 2nd to 10th elements with method invocations like second, third upto tenth on the array
+  # Also, sets and retrieves array value at the specified positive index as if the index was its attribute
+  #
+  # ary = [1,2,3,4,5,6,7]
+  # ary.second = 20
+  # ary.third = 30
+  # ary.fourth = 40
+  # ary.fifth = 50
+  # ary.sixth = 60
+  # ary.seventh = 70
+  # ary.eighth = 80
+  # ary.ninth = 90
+  # ary.tenth = 100
+  # ary                # => [1, 20, 30, 40, 50, 60, 70, 80, 90, 100]
+  # ary.second         # => 20
+  # ary.third          # => 30
+  # ary.tenth          # => 100
+  # ary._0 = 25
+  # ary._0             # => 25 # Similar to ary.at(0) or ary.fetch(0)
+  # ary._1 = 10
+  # ary._1             # => 10
+  # ary._15 = 15
+  # ary                # => [25, 10, 30, 40, 50, 60, 70, 80, 90, 100, nil, nil, nil, nil, nil, 15]
+  # 
+  # ary.t12            # => undefined method `t12'
+  # ary._abcd          # => undefined method `_abcd' 
+  # ary._1a            # => undefined method `_1a'
+  # 
+  # ary.each_index { |index|
+  #    eval("p ary._#{index}")
+  #  }
+  #  
+  #  ary.each_index { |index|
+  #    eval("ary._#{index} = 10")  
+  #  }
+  #
+  def method_missing(symbol, *args)
+    key = symbol.to_s
+    setter = symbol.to_s.chop.to_sym
+    if Map.include?(symbol)
+      self[Map[symbol]]
+    elsif Map.include?(setter)
+      self[Map[setter]] = args[0]
+    elsif key[0,1] == '_' and key[-1,1] == "="  # only positive index
+      self[key.chop[1..-1].to_i] = args[0]
+    elsif key[0,1] == '_' and is_numeric?(key[1..-1])  # only positive index
+      self[key[1..-1].to_i]
+    else
+      super
+    end
+  end
+  
+  private
+  
+  def populate_alternate_arrays 
+    ary1, ary2 = [],[]
+    each_index {|index| 
+      if index.modulo(2).zero?
+        ary1 << self[index]
+      else
+        ary2 << self[index]
+      end
+    }
+    [ary1, ary2]    
+  end
+  
+  def is_numeric?(s)
+    s.to_i.to_s == s || s.to_f.to_s == s
+  end
+end
+

data/spec/augmented_array_spec.rb

@@ -0,0 +1,179 @@
+require File.expand_path(File.dirname(__FILE__) + "/../lib/augmented_array")
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe Array do
+    
+  before(:each) do
+    @my_array = [1,2,3,4,5,nil,6,7,8,9,10,nil]
+  end
+
+  it "should return count of nil items in the array " do
+    @my_array.nilitems.should == 2
+    [].nilitems.should == 0
+    [1,2,3].nilitems.should == 0
+  end
+  
+  it "should return the sum of all elements in an integer or float array " do
+    @my_array.sum.should == 55
+    @my_array << 3.5
+    @my_array.sum == 58.5
+  end
+  
+  it "should throw Runtime error if any of the array elements is other than integer or float" do
+    @my_array << "test"
+    lambda {@my_array.sum}.should raise_error(RuntimeError, 'The array should be either an integer or float array')
+  end
+  
+  it "should return the middle element with odd number of elements in the array" do
+    [1,2,3,4,5].middle.should == 3
+  end
+  
+  it "should return array of the middle 2 elements with even number of elements in the array" do
+    @my_array.middle.should == [nil,6]
+    [1,2,3,4].middle.should == [2,3]
+  end
+
+  it "should return the single element as middle element with one element array" do
+    [1].middle.should == 1
+  end
+  
+  it "should return nil if middle is invoked on an empty array" do
+    [].middle.should be_nil
+  end
+  
+  it "should return array of hashes with element as key and its class as value when describe is invoked on an array" do
+    ary_desc = [1,1.0,"test",{:key => "value"}].describe
+    ary_desc.first.should == {1=>'Fixnum'}
+    ary_desc[1].should == {1.0=>'Float'}
+    ary_desc[2].should == {'test'=>'String'}
+    ary_desc[3].has_value?('Hash')
+  end
+  
+  it "should return a new array by splitting the array into arrays of int divisor elements each if number of elements are completely divisible by divisor" do
+    ary_div = @my_array / 3
+    ary_div.size.should == 4
+    ary_div.first.should == [1,2,3]
+    ary_div.last.should == [9,10,nil]
+  end
+  
+  it "should return a new array by splitting the array into arrays of int divisor elements each and remaining elements if number of elements are not completely divisible by divisor" do
+    ary_div = @my_array / 5
+    ary_div.size.should == 3
+    ary_div.first.should == [1,2,3,4,5]
+    ary_div.last.should == [10,nil]
+  end
+  
+  it "should set the value of the first element of the array when first= invoked on the array" do
+    @my_array.first = 20
+    @my_array.first.should == 20
+    ary = []
+    ary.first = 10
+    ary.first.should == 10
+  end
+  
+ it "should set the value of the last element of the array when last= invoked on the array" do
+    @my_array.last = 10
+    @my_array.last.should == 10
+    ary = []
+    ary.last = 5
+    ary.last.should == 5
+  end
+  
+  it "should set and access the 2nd to 10th elements with method invocations like second, third upto tenth on the array" do
+    @my_array.second = 2
+    @my_array.second.should == 2
+    @my_array.third = 3
+    @my_array.third.should == 3
+    @my_array.fourth = 4
+    @my_array.fourth.should == 4
+    @my_array.fifth = 5
+    @my_array.fifth.should == 5
+    @my_array.sixth = 6
+    @my_array.sixth.should == 6
+    @my_array.seventh = 7
+    @my_array.seventh.should == 7
+    @my_array.eighth = 8
+    @my_array.eighth.should == 8
+    @my_array.ninth = 9
+    @my_array.ninth.should == 9
+    @my_array.tenth = 10
+    @my_array.tenth.should == 10
+  end
+  
+  it "should collect alternate elements in different array and return array of those arrays" do
+    new_ary = @my_array.alternate
+    new_ary.size.should == 2
+    new_ary.first.size.should == 6
+    new_ary.second.size.should == 6
+    @my_array.size.should == 12
+  end
+  
+  it "should collect alternate elements in different array and modify the orignal array by adding those arrays" do
+    @my_array.alternate!.size.should == 2
+    @my_array.size.should == 2
+    @my_array.first.size.should == 6
+    @my_array.second.size.should == 6
+  end
+  
+  it "should return empty array if alternate is invoked on an empty array" do
+    [].alternate.size.should == 0
+    [].alternate!.size.should == 0
+  end
+  
+  it "should return an array with array consisting of one element if alternate is invoked on a single element array" do
+    [1].alternate.size.should == 1
+    [1].alternate!.first.first == 1
+  end
+  
+  it "should set and retrieve array value at the specified positive index as if the index was its attribute" do
+    ary = [1,2,3,4,5]
+    ary._0 = 20
+    ary._0.should == 20 
+    ary._1 = 10
+    ary._1.should == 10
+    ary._7 = 30
+    ary.size.should == 8
+    ary._7.should == 30
+    ary._6.should be_nil
+  end
+  
+  it "should throw NoMethodError while setting and getting the array value with wrong index as an attribute on the array" do
+    lambda {@my_array._abcd}.should raise_error(NoMethodError)
+    lambda {@my_array._1abc}.should raise_error(NoMethodError)
+    lambda {@my_array.t12}.should raise_error(NoMethodError)
+    lambda {@my_array.s23}.should raise_error(NoMethodError)
+  end
+  
+  
+  it "should call block once with traversing the array elements incremented by positive step, passing that array element as a parameter" do
+    ary = [1,2,3,4,5,6]
+    new_ary = []
+    ary.step_by(2){|x| new_ary << x}
+    new_ary.should == [1,3,5]
+  end
+  
+  it "should call block once with traversing all the elements similar to each method" do
+    ary = [1,2,3,4,5,6]
+    new_ary = []
+    ary.step_by(1) {|x| new_ary << x}
+    new_ary.should == [1,2,3,4,5,6]
+    new_ary.last.should == 6
+  end 
+
+  it "should return only first element if step mentioned is greater that size of the array" do
+    ary = [1,2,3,4,5,6]
+    new_ary = []
+    ary.step_by(10) {|x| new_ary << x}
+    new_ary.should == [1]
+  end     
+   
+  it "should throw ArgumentError if the step mentioned is either zero or negative" do
+    lambda{@my_array.step_by(0)}.should raise_error(ArgumentError, "Step can't be 0 or negative")
+    lambda{@my_array.step_by(-2)}.should raise_error(ArgumentError, "Step can't be 0 or negative")
+  end
+  
+  it "should throw LocalJumpError if no block is provided" do
+    lambda{@my_array.step_by(1)}.should raise_error(LocalJumpError, "no block given")
+  end
+
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: augmented_array
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Niranjan Sarade
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-07-02 00:00:00 +05:30
+default_executable: 
+dependencies: []
+
+description: |-
+  The Ruby Array class is extended with some traversing methods and you will also be able to get and set the 
+                individual array elements with indexes as of the indexes were attributes of an array.
+email: nirusuma@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- ./README
+files: 
+- lib/augmented_array.rb
+- ./README
+has_rdoc: true
+homepage: http://github.com/NiranjanSarade/augmented_array
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- An Augmented Array
+- --main
+- README
+- --line-numbers
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: An augmented array class with some useful methods
+test_files: 
+- spec/augmented_array_spec.rb