flex_array 0.2.0

data/lib/flex_array/spec_component.rb

@@ -0,0 +1,71 @@
+#This helper class encapsulates a single component of the flex array spec.
+class SpecComponent
+  #The range of acceptable values for this limit.
+  attr_reader :range
+  
+  #The stride of this array dimension. That is, for each step in this
+  #dimension, how many steps are required in the low level array?
+  attr_reader :stride
+  
+  #Create a limits component from its constituent data.
+  #<br>Parameters
+  #* range - the range of values for this index limit.
+  #* stride - the number of cells separating data with adjacent indexes.
+  def initialize(range, stride)
+    @range, @stride = range, stride
+  end
+  
+  #Forward '=== value' to the range.
+  def ===(value)
+    @range === value
+  end
+  
+  #Limits are equal if their ranges are equal.
+  #<br>Returns
+  #* true if the spec components have equal ranges.
+  def ==(other)
+    @range == other.range
+  end
+  
+  #Forward 'min' to the range.
+  def min
+    @range.min
+  end
+  
+  #Forward 'max' to the range.
+  def max 
+    @range.max
+  end
+  
+  #Forward 'each' and the block to the range.
+  def each(&block)
+    @range.each(&block)
+  end
+  
+  #Compute the span of indexes in this limit component.
+  #<br>Returns
+  #* The span of the range or zero if there is none.
+  def span
+    if @range.none?
+      0
+    else
+      @range.max - @range.min + 1
+    end
+  end
+  
+  #Enlarge the range of this spec by the growth term.
+  def enlarge(growth)
+    if @range.none?
+      @range = 0...growth
+    else
+      @range = (@range.min)..(@range.max + growth)
+    end
+  end
+  
+  #Compute the step required for the index value.
+  #<br>Returns
+  #* The number of array cells to be skipped for this index.
+  def index_step(index)
+    (index - @range.min) * @stride
+  end
+end

data/lib/flex_array.rb

@@ -0,0 +1,89 @@
+require 'in_array'
+require_relative 'flex_array/spec_component'
+require_relative 'flex_array/object'
+require_relative 'flex_array/integer'
+require_relative 'flex_array/range'
+require_relative 'flex_array/array'
+
+require_relative 'flex_array/flex_array_new'
+require_relative 'flex_array/flex_array_index'
+require_relative 'flex_array/flex_array_append'
+require_relative 'flex_array/flex_array_reshape'
+require_relative 'flex_array/flex_array_transpose'
+require_relative 'flex_array/flex_array_each'
+require_relative 'flex_array/flex_array_validate'
+require_relative 'flex_array/flex_array_process'
+
+#\FlexArray - A flexible array class.
+#* flex_array.rb - The root file that gathers up all the flex array parts.
+class FlexArray
+  include Enumerable
+  include InArrayAlready
+
+  #The version of this class.
+  #<br>Returns
+  #* A version string; <major>.<minor>.<step>
+  def self.version
+    '0.2.0'
+  end
+
+  #The version of the class of this instance.
+  #<br>Returns
+  #* A version string; <major>.<minor>.<step>
+  def version
+    self.class.version
+  end
+
+  #The array specifications. An array of spec components.
+  attr_accessor :array_specs
+
+  #The underlying array data used by the flex array.
+  attr_accessor :array_data
+
+  #The total number of elements in this array.
+  attr_reader :count
+
+  #The number of dimensions in this array.
+  attr_reader :dimensions
+
+  #Get the limits of the subscripts of the flex array.
+  #<br>Returns
+  #* An array of dimension limits ranges.
+  def limits
+    Array.new(@dimensions) {|dimension| @array_specs[dimension].range}
+  end
+
+  #Return this flex array as a flex array!
+  #<br>Returns
+  #* A flex array -- self
+  def to_flex_array
+    self
+  end
+
+  #Are these FlexArrays equal?
+  #<br>Parameters
+  #* other - The object being tested for equality.
+  #<br>Returns
+  #* true if the flex arrays are equal shape and data.
+  def ==(other)
+    self.compatible?(other) && @array_data == other.array_data
+  end
+
+  #Make FlexArrays comparable.
+  #<br>Parameters
+  #* other - The object being tested for compariositality.
+  #<br>Returns
+  #* 1 if self > other
+  #* 0 if self = other
+  #* -1 if self < other
+  def <=>(other)
+    @array_data <=> other.array_data
+  end
+  
+  #Update the count and dimensions variables
+  def update_count_and_dimensions
+    @dimensions = @array_specs.length
+    @count      = @array_data.length
+    self
+  end
+end

data/license.txt

@@ -0,0 +1,21 @@
+=== The MIT License (MIT).
+
+Copyright (c) 2014 Peter Camilleri
+
+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/rakefile.rb

@@ -0,0 +1,44 @@
+#!/usr/bin/env rake
+require 'rake/testtask'
+require 'rdoc/task'
+
+RDoc::Task.new do |rdoc|
+  rdoc.rdoc_dir = "rdoc"
+  rdoc.rdoc_files = ["lib/flex_array.rb", 
+                     "lib/flex_array/flex_array_new.rb",
+                     "lib/flex_array/flex_array_index.rb",
+                     "lib/flex_array/flex_array_each.rb",
+                     "lib/flex_array/flex_array_reshape.rb",
+                     "lib/flex_array/flex_array_append.rb",
+                     "lib/flex_array/flex_array_transpose.rb",
+                     "lib/flex_array/flex_array_process.rb",
+                     "lib/flex_array/flex_array_validate.rb",
+                     "lib/flex_array/object.rb",
+                     "lib/flex_array/integer.rb",
+                     "lib/flex_array/range.rb",
+                     "lib/flex_array/array.rb",
+                     "lib/flex_array/spec_component.rb",
+                     "license.txt", "README.txt"]
+  rdoc.options << '--visibility' << 'private'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = ["tests/spec_component_test.rb",
+                  "tests/object_test.rb",
+                  "tests/integer_test.rb",
+                  "tests/range_test.rb",
+                  "tests/array_test.rb",
+                  "tests/flex_array_new_test.rb",
+                  "tests/flex_array_index_test.rb",
+                  "tests/flex_array_each_test.rb",
+                  "tests/flex_array_reshape_test.rb",
+                  "tests/flex_array_append_test.rb",
+                  "tests/flex_array_transpose_test.rb",
+                  "tests/flex_array_validate_test.rb",
+                  "tests/flex_array_test.rb"]
+  t.verbose = false
+end
+
+task :reek do |t|
+  `reek lib > reek.txt`
+end

data/readme.txt

@@ -0,0 +1,2 @@
+This project contains the Ruby FlexArray gem. A gem used to facilitate the
+creation and processing of multi-dimensional arrays in a flexible manner.

data/reek.txt

@@ -0,0 +1,29 @@
+lib/flex_array.rb -- 0 warnings
+lib/flex_array/array.rb -- 0 warnings
+lib/flex_array/flex_array_append.rb -- 0 warnings
+lib/flex_array/flex_array_each.rb -- 11 warnings:
+  [91, 94]:FlexArray#_each_raw calls process_indexes(indexes) twice (DuplicateMethodCall)
+  [94]:FlexArray#_each_raw contains iterators nested 2 deep (NestedIterators)
+  [41, 44]:FlexArray#cycle calls @array_data[posn] twice (DuplicateMethodCall)
+  [41, 44]:FlexArray#cycle calls process_indexes(indexes) twice (DuplicateMethodCall)
+  [44]:FlexArray#cycle contains iterators nested 3 deep (NestedIterators)
+  [18, 21]:FlexArray#each calls @array_data[posn] twice (DuplicateMethodCall)
+  [18, 21]:FlexArray#each calls process_indexes(indexes) twice (DuplicateMethodCall)
+  [21]:FlexArray#each contains iterators nested 2 deep (NestedIterators)
+  [65, 68]:FlexArray#each_with_index calls @array_data[posn] twice (DuplicateMethodCall)
+  [65, 68]:FlexArray#each_with_index calls process_indexes(indexes) twice (DuplicateMethodCall)
+  [68]:FlexArray#each_with_index contains iterators nested 2 deep (NestedIterators)
+lib/flex_array/flex_array_index.rb -- 0 warnings
+lib/flex_array/flex_array_new.rb -- 0 warnings
+lib/flex_array/flex_array_process.rb -- 3 warnings:
+  [89]:FlexArray#process_all_worker has approx 7 statements (TooManyStatements)
+  [47]:FlexArray#process_indexes_worker has 4 parameters (LongParameterList)
+  [47]:FlexArray#process_indexes_worker has approx 9 statements (TooManyStatements)
+lib/flex_array/flex_array_reshape.rb -- 0 warnings
+lib/flex_array/flex_array_transpose.rb -- 0 warnings
+lib/flex_array/flex_array_validate.rb -- 0 warnings
+lib/flex_array/integer.rb -- 0 warnings
+lib/flex_array/object.rb -- 0 warnings
+lib/flex_array/range.rb -- 0 warnings
+lib/flex_array/spec_component.rb -- 0 warnings
+14 total warnings

data/tests/array_test.rb

@@ -0,0 +1,62 @@
+require_relative '../lib/flex_array/array'
+require          'minitest/autorun'
+
+class ArrayTester < MiniTest::Unit::TestCase
+  $do_this_only_one_time = "" unless defined? $do_this_only_one_time
+  
+  def initialize(*all)
+    if $do_this_only_one_time != __FILE__
+      puts
+      puts "Running test file: #{File.split(__FILE__)[1]}" 
+      $do_this_only_one_time = __FILE__
+    end
+    
+    super(*all)
+  end
+
+  def test_the_limits_method
+    test = [1,2,3,4,5,6]
+    assert_equal([0...6], test.limits)   
+  end
+  
+  def test_the_array_specs_method
+    test = [1,2,3,4,5,6].array_specs
+    assert_equal(1, test.length)
+    assert_equal(SpecComponent, test[0].class)
+    assert_equal(0...6, test[0].range)
+    assert_equal(1, test[0].stride)
+  end
+  
+  def test_the_array_data_method
+    test = [1,2,3,4,5,6]
+    assert_equal(test, test.array_data)
+    assert_equal(test.object_id, test.array_data.object_id)
+  end
+  
+  def test_the_count_method
+    test = [1,2,3,4,5,6]
+    assert_equal(test.count, 6)
+    assert_equal(test.count, test.length)
+  end
+  
+  def test_the_to_index_range_method
+    spec = SpecComponent.new(0...10, 1)
+    
+    assert_equal(0..0, [0,0].to_index_range(spec))
+    assert_equal(9..9, [9,9].to_index_range(spec))
+    assert_equal(0..9, [0,9].to_index_range(spec))
+    
+    assert_equal(0..9, [0,-1].to_index_range(spec))
+    assert_equal(1..8, [1,-2].to_index_range(spec))
+    assert_equal(8..9, [-2,-1].to_index_range(spec))
+    
+    assert_raises(IndexError) { [0,9,0].to_index_range(spec) }
+    assert_raises(IndexError) { [9,0].to_index_range(spec) }
+    assert_raises(IndexError) { [-1,-2].to_index_range(spec) }
+    assert_raises(IndexError) { [0,10].to_index_range(spec) }
+    
+    assert_raises(TypeError) { [].to_index_range(spec) }
+    assert_raises(TypeError) { [0].to_index_range(spec) }
+    assert_raises(TypeError) { [:one, :two].to_index_range(spec) }
+  end
+end

data/tests/flex_array_append_test.rb

@@ -0,0 +1,82 @@
+require_relative '../lib/flex_array'
+require          'minitest/autorun'
+
+class FlexArrayAppendTester < MiniTest::Unit::TestCase
+  $do_this_only_one_time = "" unless defined? $do_this_only_one_time
+  
+  def initialize(*all)
+    if $do_this_only_one_time != __FILE__
+      puts
+      puts "Running test file: #{File.split(__FILE__)[1]}" 
+      $do_this_only_one_time = __FILE__
+    end
+    
+    super(*all)
+  end
+
+  def test_append_onto_an_existing_array
+    f = FlexArray.new([1,3], "Title")
+    assert_equal(2, f.dimensions)
+    assert_equal([0...1, 0...3], f.limits)
+    
+    f << [1,2,3]
+    assert_equal(2, f.dimensions)
+    assert_equal([0..1, 0...3], f.limits)
+    a = ["Title","Title","Title",1,2,3]
+    assert_equal(a, f.array_data)
+    
+    g = FlexArray.new_from_array([4,5,6])
+    f << g
+    assert_equal(2, f.dimensions)
+    assert_equal([0..2, 0...3], f.limits)
+    a << 4 << 5 << 6
+    assert_equal(a, f.array_data)
+  end
+
+  def test_append_onto_an_empty_array
+    f = FlexArray.new([0,3])
+    assert_equal(2, f.dimensions)
+    assert_equal([0...0, 0...3], f.limits)
+    
+    f << [1,2,3]
+    assert_equal(2, f.dimensions)
+    assert_equal([0...1, 0...3], f.limits)
+    a = [1,2,3]
+    assert_equal(a, f.array_data)
+
+    f << [4,5,6]
+    assert_equal(2, f.dimensions)
+    assert_equal([0..1, 0...3], f.limits)
+    a = [1,2,3,4,5,6]
+    assert_equal(a, f.array_data)
+  end
+
+  def test_append_failures
+    f = FlexArray.new([1,3], "Title")
+    assert_raises(ArgumentError) { f << [3,4] }
+    assert_raises(ArgumentError) { f << [1,2,3,4] }
+    
+    g = FlexArray.new([1,2], "Title")
+    assert_raises(ArgumentError) { f << g }
+  end
+  
+  def test_the_copy_data_method
+    f = FlexArray.new([2,3], "Title")
+    g = FlexArray.new([2,3], "Fight")
+    f.copy_data(g)
+    assert_equal(f.array_data, g.array_data)
+    assert(f.array_data.object_id != g.array_data.object_id)
+  end
+  
+  def test_copy_data_method_failures
+    f = FlexArray.new([2,3], "Title")
+    g = FlexArray.new([2,4], "Fight")
+    assert_raises(ArgumentError) { f.copy_data(g) }
+    
+    g = FlexArray.new([1,3], "Fight")
+    assert_raises(ArgumentError) { f.copy_data(g) }
+
+    g = FlexArray.new([2,2], "Fight")
+    assert_raises(ArgumentError) { f.copy_data(g) }
+  end
+end

data/tests/flex_array_each_test.rb

@@ -0,0 +1,120 @@
+require_relative '../lib/flex_array'
+require          'minitest/autorun'
+
+class FlexArrayEachTester < MiniTest::Unit::TestCase
+  $do_this_only_one_time = "" unless defined? $do_this_only_one_time
+  
+  def initialize(*all)
+    if $do_this_only_one_time != __FILE__
+      puts
+      puts "Running test file: #{File.split(__FILE__)[1]}" 
+      $do_this_only_one_time = __FILE__
+    end
+    
+    super(*all)
+  end
+
+  def test_that_the_each_verbs_work
+    idx = []
+    q = FlexArray.new([3, 3]) {|i| idx << i.clone; i[0]*i[1]}
+    it = q.array_data.each
+    
+    q.each do |v|
+      assert_equal(it.next, v)
+    end
+    
+    it = q.each
+    q.array_data.each do |v|
+      assert_equal(it.next, v)
+    end
+
+    it = q.array_data.each
+    it2 = idx.each
+    q.each_with_index do |v, i|
+      assert_equal(it.next, v)
+      assert_equal(it2.next, i)
+    end
+    
+    it = q.each_with_index
+    it2 = idx.each
+    q.array_data.each do |v|
+      value, index = it.next
+      assert_equal(value, v)
+      assert_equal(it2.next, index)
+    end
+    
+    it = (0...9).each
+    it2 = idx.each
+    q._each_raw do |d, index, p|
+      assert_equal(d.object_id, q.array_data.object_id)
+      assert_equal(it2.next, index)
+      assert_equal(it.next, p)
+    end
+    
+    it = q._each_raw
+    it2 = idx.each
+    (0...9).each do |i|
+      d, index, p = it.next
+      assert_equal(d.object_id, q.array_data.object_id)
+      assert_equal(it2.next, index)
+      assert_equal(i, p)
+    end
+  end
+
+  def test_that_the_indexed_each_verbs_work
+    q = FlexArray.new([3, 3]) {|i| i[0]*i[1]}
+    a = [0, 1, 2]
+    b = [[1,0], [1,1], [1,2]]
+    it = a.each
+    
+    q.each([1, :all]) do |v|
+      assert_equal(it.next, v)
+    end
+    
+    it = q.each([1, :all])
+    a.each do |v|
+      assert_equal(it.next, v)
+    end
+    
+    it = a.each
+    it2 = b.each
+    q.each_with_index([1, :all]) do |v, i|
+      assert_equal(it.next, v)
+      assert_equal(it2.next, i)
+    end
+
+    it = q.each_with_index([1, :all])
+    it2 = b.each
+    a.each do |v|
+      value, index = it.next
+      assert_equal(value, v)
+      assert_equal(it2.next, index)
+    end
+    
+    c = [3, 4, 5]
+    it = c.each
+    it2 = b.each
+    q._each_raw([1, :all]) do |d, index, p|
+      assert_equal(d.object_id, q.array_data.object_id)
+      assert_equal(it2.next, index)
+      assert_equal(it.next, p)
+    end
+    
+    it = q._each_raw([1, :all])
+    it2 = b.each
+    c.each do |i|
+      d, index, p = it.next
+      assert_equal(d.object_id, q.array_data.object_id)
+      assert_equal(it2.next, index)
+      assert_equal(i, p)
+    end
+  end
+  
+  def test_that_flex_array_cycle_works
+    a = FlexArray.new_from(3, [1,2,3])
+    r = []
+    it = a.cycle
+    10.times {r << it.next}
+    assert_equal([1,2,3,1,2,3,1,2,3,1], r)    
+  end
+end