in_columns 0.1.0 → 0.2.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OWE2ZjQ5NjNmMTBlYjU1NzVkYzAxZjE2MGY2NTY4NGVlOGY3MWUzNw==
+    YjFjYjY4YWJmYzAzYmQ3NWU0YTI3ZTEzYzBkZDAxMTBiMmE2OGE4NQ==
   data.tar.gz: !binary |-
-    ZGI3Nzg2ZjQxNzA2ZGVkZjczYjRhY2ZmNzhkZWUxNGQ5N2IwZTkyNQ==
+    ZTdhMzJhNDg3YzM0NWU3YWNhYTJmYjU4ZmJhMzc2ZDBmMTllZWFiMQ==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    YzQ1MTg0Yzk0OWUzNDcxNGMzODAyMjBmYzNmODRlMTg4MzJkODJlODE4NDJk
-    MzNmNTJlZGUwY2Q3Y2E4NjNkY2I3YmU5YzMzOGEwNWMxMmZmN2U3NzczM2Q1
-    YTNkOTgzN2QwMjViNmZiMDNhZmIxM2MyZjNiNjhmN2JkODQ1MzY=
+    MzQ3Y2I1ZjhlYmQ5MjFhN2FmYzMyMWY2NWNjMmQ2N2YwMjQ4OTNlMWMwMzVk
+    NWNkNDYzMWY1NmRhNTgyY2Q0ZWZlMzcyMWUwZmU4ZThhMTVkNzY0NTFlZTFm
+    ZmQwNTc4YzlmYTk2NmUzZjY4NjNiMTYxYjFhZjA0ODZhNmM4MGI=
   data.tar.gz: !binary |-
-    NWU1ZDgxZDAzMjZhMTFjN2MzZTQxYzc0NDVmNDI3OTk3MGFkZmU5YzU4MmUw
-    MDY0OGY0NWNkNGUyOTI0NjRjNmIwZjViODhmOTcxNDg5OWUxMDE3ZGY3YmM0
-    NWIxMDUxMjg0ODkyNDc2NjVjZDg2ZWExN2U0NTdiNDhiOTUyZDI=
+    YjExNzY4YWU0ODRiNzY0NDMxZTA4Y2JmODVlOGU4ZTk3NmI5OTdlMjY5N2Uz
+    ZmY0Nzg2NTRlYTI4MzIzNDVlMzYxM2EwNThlYTA2OGY5YzkyODU2YjQzMDky
+    ZWVjNDNmZmZiMTdiYmE5MjYzZjFkZjAwNzdjY2UyODI2MmRmZWY=

data/README.md

@@ -10,11 +10,11 @@ columns - say for displaying it to an end user.
 ## Usage example
 
     list = ['a', 'b', 'c', 'd', 'e']
-    InColumns.columnize(list, 2)
-    #=> [['a', 'c', 'e'], ['b', 'd']]
-    
     InColumns.columnize(list, 3)
-    #=> [['a', 'd'], ['b', 'e'], ['c']]
+    #=> [['a', 'c', 'e'], ['b', 'd', nil]]
+    
+    InColumns.columnize(list, 2)
+    #=> [['a', 'd'], ['b', 'e'], ['c', nil]]
 
 ## Extension to Array
 
@@ -26,7 +26,7 @@ wherever you need columnizability (yes, that's totally a word):
     end
     
     ['a', 'b', 'c'].in_columns(2)
-    #=> [['a', 'c'], ['b']]
+    #=> [['a', 'c'], ['b', nil]]
 
 ## Installation
 

data/lib/in_columns.rb

@@ -5,6 +5,6 @@ require "in_columns/columnizer"
 
 module InColumns
   def self.columnize(elements, number_of_columns)
-    Columnizer.new(elements).columns(number_of_columns)
+    Columnizer.new(elements).distribute(number_of_columns)
   end
 end

data/lib/in_columns/array_ext.rb

@@ -3,7 +3,7 @@ require_relative './columnizer'
 module InColumns
   module ArrayExt
     def in_columns(number_of_columns)
-      InColumns::Columnizer.new(self).columns(number_of_columns)
+      InColumns::Columnizer.new(self).distribute(number_of_columns)
     end
   end
 end

data/lib/in_columns/columnizer.rb

@@ -4,25 +4,57 @@ module InColumns
       @elements = elements
     end
 
-    def columns(number_of_columns)
-      columns = create_columns(number_of_columns)
-      distribute_elements(columns)
+    # Returns the necessary rows to distribute elements into the desired number
+    # of columns
+    #
+    # The result is a multidimensional array, so that:
+    #
+    #   Columnizer.new(['a', 'b', 'c']).distribute(2)
+    #   #=> [['a', 'c'], ['b', nil]]
+    def distribute(number_of_columns)
+      return [] if elements.empty?
+      distribute_elements(number_of_columns)
     end
 
     private
 
     attr_reader :elements
 
-    def create_columns(number_of_columns)
-      (1..number_of_columns).collect { [] }
+    def distribute_elements(number_of_columns)
+      number_of_rows = (number_of_elements.to_f / number_of_columns).ceil
+      counts = row_counts(number_of_columns)
+
+      columns = []
+      elements_to_distribute = elements.dup
+
+      while !elements_to_distribute.empty?
+        size_of_column = counts[columns.size]
+        elements_for_column = elements_to_distribute.shift(size_of_column)
+        columns << elements_for_column
+      end
+
+      # Convert the columns to rows
+      first_column = columns.first
+      rest_columns = columns[1..-1]
+      columns = first_column.zip(*rest_columns)
     end
 
-    def distribute_elements(columns)
-      elements.each_with_index { |element, index|
-        column_number = index % columns.size
-        columns[column_number] << element
+    def number_of_elements
+      elements.size
+    end
+
+    # Returns an array with an element for each column containing the number of
+    # rows for that column
+    def row_counts(number_of_columns)
+      per_column = (number_of_elements / number_of_columns).floor
+      counts = [per_column] * number_of_columns
+
+      left_overs = number_of_elements % number_of_columns
+      left_overs.times { |n|
+        counts[n] = counts[n] + 1
       }
-      columns
+
+      counts
     end
   end
 end

data/lib/in_columns/version.rb

@@ -1,3 +1,3 @@
 module InColumns
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/test/in_columns/array_ext_test.rb

@@ -6,10 +6,13 @@ class ArrayExtensionTest < MiniTest::Unit::TestCase
   end
 
   def test_distributes_array_into_columns
-    assert_equal [['a', 'c', 'e'], ['b', 'd']], ['a', 'b', 'c', 'd', 'e'].in_columns(2)
+    assert_equal [
+      ['a', 'c', 'e'],
+      ['b', 'd', nil]
+    ], ['a', 'b', 'c', 'd', 'e'].in_columns(3)
   end
 
   def test_works_for_empty_array
-    assert_equal [[], [], []], [].in_columns(3)
+    assert_equal [], [].in_columns(3)
   end
 end

data/test/in_columns/columnizer_test.rb

@@ -2,35 +2,119 @@ require 'test_helper'
 
 class ColumnizerTest < MiniTest::Unit::TestCase
 
-  def test_returns_empty_array
-    assert_equal [[],[],[]], InColumns::Columnizer.new([]).columns(3)
+  def test_distribute_1_into_3
+    input = ['a']
+    output = InColumns::Columnizer.new(input).distribute(3)
+    assert_equal [
+      ['a']
+    ], output
+  end
+
+  def test_distribute_2_into_3
+    input = ['a', 'b']
+    output = InColumns::Columnizer.new(input).distribute(3)
+    assert_equal [
+      ['a', 'b']
+    ], output
+  end
+
+  def test_distribute_4_into_3
+    input = ['a', 'b', 'c', 'd']
+    output = InColumns::Columnizer.new(input).distribute(3)
+    assert_equal [
+      ['a', 'c', 'd'],
+      ['b', nil, nil]
+    ], output
+  end
+
+  def test_distribute_5_into_3
+    input = ['a', 'b', 'c', 'd', 'e']
+    output = InColumns::Columnizer.new(input).distribute(3)
+    assert_equal [
+      ['a', 'c', 'e'],
+      ['b', 'd', nil]
+    ], output
+  end
+
+  def test_distribute_6_into_3
+    input = ['a', 'b', 'c', 'd', 'e', 'f']
+    output = InColumns::Columnizer.new(input).distribute(3)
+    assert_equal [
+      ['a', 'c', 'e'],
+      ['b', 'd', 'f']
+    ], output
+  end
+
+  def test_distribute_10_into_3
+    input = ('a'..'j').to_a
+    output = InColumns::Columnizer.new(input).distribute(3)
+    assert_equal [
+      ['a', 'e', 'h'],
+      ['b', 'f', 'i'],
+      ['c', 'g', 'j'],
+      ['d', nil, nil]
+    ], output
+  end
+
+  def test_distribute_nil_values
+    input = ['a', nil]
+    output = InColumns::Columnizer.new(input).distribute(3)
+    assert_equal [
+      ['a', nil]
+    ], output
   end
 
   def test_does_not_modify_input
     input = ['a', 'b', 'c']
-    InColumns::Columnizer.new(input).columns(2)
+    InColumns::Columnizer.new(input).distribute(2)
     assert_equal ['a', 'b', 'c'], input
   end
 
+  def test_returns_empty_array
+    assert_equal [], InColumns::Columnizer.new([]).distribute(3)
+  end
+
   def test_distribute_exact_elements
     input = ['a', 'b']
-    output = InColumns::Columnizer.new(input).columns(2)
-    assert_equal [['a'], ['b']], output
+    output = InColumns::Columnizer.new(input).distribute(2)
+    assert_equal [
+      ['a', 'b']
+    ], output
+  end
+
+  def test_distribute_into_one_column
+    input = ['a', 'b']
+    output = InColumns::Columnizer.new(input).distribute(1)
+    assert_equal [
+      ['a'],
+      ['b']
+    ], output
   end
 
   def test_distribute_too_many_elements
     input = ['a', 'b', 'c', 'd', 'e']
-    output = InColumns::Columnizer.new(input).columns(2)
-    assert_equal [['a', 'c', 'e'], ['b', 'd']], output
+    output = InColumns::Columnizer.new(input).distribute(2)
+    assert_equal [
+      ['a', 'd'],
+      ['b', 'e'],
+      ['c', nil]
+    ], output
+  end
 
-    output = InColumns::Columnizer.new(input).columns(3)
-    assert_equal [['a', 'd'], ['b', 'e'], ['c']], output
+  def test_columns_should_be_of_equalish_height
+    input = ('a'..'j').to_a
+    output = InColumns::Columnizer.new(input).distribute(3)
+    assert_equal [
+      ['a', 'e', 'h'],
+      ['b', 'f', 'i'],
+      ['c', 'g', 'j'],
+      ['d', nil, nil]
+    ], output
   end
 
-  def test_distribute_too_few_elements
+  def test_can_be_run_multiple_times
     input = ['a', 'b']
-    output = InColumns::Columnizer.new(input).columns(3)
-    assert_equal [['a'], ['b'], []], output
+    columnizer = InColumns::Columnizer.new(input)
+    assert_equal columnizer.distribute(3), columnizer.distribute(3)
   end
-
 end

data/test/in_columns_test.rb

@@ -2,6 +2,9 @@ require 'test_helper'
 
 class InColumnsTest < MiniTest::Unit::TestCase
   def test_distributes_arrays_into_columns
-    assert_equal [['a', 'c', 'e'], ['b', 'd']], InColumns.columnize(['a', 'b', 'c', 'd', 'e'], 2)
+    assert_equal [
+      ['a', 'c', 'e'],
+      ['b', 'd', nil]
+    ], InColumns.columnize(['a', 'b', 'c', 'd', 'e'], 3)
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: in_columns
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Jakob Skjerning
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-15 00:00:00.000000000 Z
+date: 2013-08-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -81,7 +81,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.0.3
+rubygems_version: 2.0.6
 signing_key: 
 specification_version: 4
 summary: Distributes array elements into columns.
@@ -90,4 +90,3 @@ test_files:
 - test/in_columns/columnizer_test.rb
 - test/in_columns_test.rb
 - test/test_helper.rb
-has_rdoc: