garoupa 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f05bd1da55dd8ace5e6f7417b7892bc250e062ac
+  data.tar.gz: 2944585ad2dee367cdc5ffbd258f0b1ef12a37d8
+SHA512:
+  metadata.gz: 260e13489af06ad5f8044f2a4cc01d74390276f990199ca780fb1f300aa12b4924e37430a0628109ffd2567a155ad751af3c36d281fda1ff8dc975566f0e5aee
+  data.tar.gz: c7676caf8c9e86175017aa916b369ad1916e9e58677614836d212752e291ef2c54f3deff52c96e459b59acb3a1210dd77ab431931f16e85300c26c90f72c6ad6

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in garoupa.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Torey Hickman
+
+MIT License
+
+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.md

@@ -0,0 +1,179 @@
+# Garoupa
+
+![Travis CI Build Status](https://api.travis-ci.org/toreyhickman/garoupa.svg?branch=master)
+
+Garoupa was written to facilitate the assignment of groups at Dev Bootcamp where students are assigned to weekly groups.  It should be generalizable to other contexts, taking an item list and returning a new Garoupa object with the assigned groups.  Options allow for specifying a target group size, a maximum difference in group sizes if the number of list items is not evenly divisible by the target group size, and providing past groups so that list items can be grouped with new groupmates.
+
+[Garoupa is apparently a Portugese name, from which the name of the grouper fish is believed to be derived](http://en.wikipedia.org/wiki/Grouper#Name_origin).  The things you learn when the desired name for your  gem is taken ...
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'garoupa'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install garoupa
+
+## Usage
+
+The Garoupa library consists of one class:  `Garoupa`.  The class has two publicly defined class methods:
+
+- `.make_groups`
+- `.past_groupmates`
+
+### `.make_groups`
+
+```ruby
+groups = Garoupa.make_groups [:a, :b, :c, :d, :e, :f, :g, :h]
+
+=> #<Garoupa:0x007fb523552938 
+     @groups=[[:a, :h, :b, :g], [:f, :d, :c, :e]], 
+     @list=[:a, :b, :c, :d, :e, :f, :g, :h], 
+     @past_groupmates={:a=>[], :b=>[], :c=>[], 
+                       :d=>[], :e=>[], :f=>[], 
+                       :g=>[], :h=>[]}
+   >
+```
+*Figure 1*.  Making groups from a list.
+
+`.make_groups` takes a list of arguments (i.e., an array) and returns the groups within an instance of the `Garoupa` class (see Figure 1).
+
+The `.make_groups` methods also accepts an options hash where you can specify 
+
+- target group size
+- a max difference in group sizes
+- past groups
+
+#### :target_size
+
+```ruby
+list = [:a, :b, :c, :d, :e, :f, :g, :h]
+
+groups = Garoupa.make_groups list, { target_size: 3 }
+  => #<Garoupa:0x007fb523572f80 
+       @groups=[[:c, :d, :h], [:f, :a, :e], [:b, :g]], 
+       @list=[:a, :b, :c, :d, :e, :f, :g, :h], 
+       @past_groupmates={:a=>[], ... }>
+```
+*Figure 2*.  Making groups with a target size.
+
+The `Garoupa` class has a constant, `DEFAULT_GROUP_SIZE`, that is used to determine the size of each group.  This can be overwritten by providing a target size when calling `.make_groups` (see Figure 2).  As many groups as possible will be make with the target group size.  If the number of list items is not evenly divisible by the target size, the last group will have less members than the target size.  This is evident in Figure 2 where the eight list items were divided into two groups of three, the target size, and one group of two.
+
+#### :max_difference
+
+```ruby
+list = [:a, :b, :c, :d, :e, :f, :g, :h, :i, :j]
+
+groups = Garoupa.make_groups list, { target_size: 3, max_difference: 1 }
+  => #<Garoupa:0x007fb5235900a8 
+       @groups=[[:d, :g, :c, :b], [:f, :a, :e], [:i, :j, :h]], 
+       @list=[:a, :b, :c, :d, :e, :f, :g, :h, :i, :j], 
+       @past_groupmates={:a=>[], ... }>
+```
+
+*Figure 3*.  Making groups with a target size and maximum difference in group size.
+
+If the groups will not be even, a maximum difference in group size can be specified.  In Figure 3, the target size is three, but with ten items in the list, the groups will include three groups of three and one group of one.  By specifying a maximum difference of one, the last groups will be dispersed into the three groups of three, resulting in one group of four and two groups of three.
+
+#### :past_groups
+
+```ruby
+list = [:a, :b, :c, :d]
+past_groups = [[:a, :b],[:a, :c]]
+
+groups = Garoupa.make_groups list, { target_size: 2, past_groups: past_groups }
+  => #<Garoupa:0x007f86c4273088 
+       @groups=[[:a, :d], [:b, :c]], 
+       @list=[:a, :b, :c, :d], 
+       @past_groupmates={:a=>[:b, :c], :b=>[:a], :c=>[:a], :d=>[]}>
+```
+
+*Figure 4*.  Making groups based on past groups.
+
+When we pass in the optional past groups, `.make_groups` will try to place items in groups with new groupmates.  In the `past_groups` defined in Figure 4, Item `:a` has already been grouped with Items `:b` and `:c`.  Item `:a` has not been grouped with Item `:d`; therefore, the ideal groups would be Items `:a` and `:d` together and Items `:b` and `:c` together.  In these groups, no item would have a repear groupmate.
+
+`Garoupa` attempts to make groups with no repeat pairs by calculating the past groupmates for each list item and then placing the items with the most past groupmates into groups first.  Essentially, trying to place items with more constraints before items with less constraints.
+
+Certainly, calculating all possible groupings and selecting one without any repeat pairs is possible, but it becomes impractical with larger group sizes or when repeat groupmates are inevitable.
+
+### `.past_groupmates`
+
+```ruby
+list = [:a, :b, :c, :d]
+past_groups = [[:a, :b],[:a, :c]]
+
+Garoupa.past_groupmates list, past_groups
+  => {:a=>[:b, :c], :b=>[:a], :c=>[:a], :d=>[]} 
+```
+
+*Figure 5*.  Finding the past groupmates for list items.
+
+The second class method, `.past_groupmates`, takes a list and past groups and returns a map of the list items and their past_groupmates, as seen in Figure 5.
+
+### `Garoupa` instances
+
+Instances of the `Garoupa` class are instantiated with groups, a list of items, and past groupmates.  New instances are returned from `Garoupa.make_groups`, but they can also be made by providing all three required arguments.  Each argument is saved as an instance variable and retrievable through getter methods.
+
+Additionally, there are three public instance methods:
+
+- `#repeat_pairs`
+- `#to_json`
+- `#to_s`
+
+#### `#repeat_pairs`
+
+```ruby
+list = [:a, :b, :c, :d]
+past_groups = [[:a, :b],[:a, :c], [:a, :d]]
+
+groups = Garoupa.make_groups list, target_size: 2, past_groups: past_groups
+  => #<Garoupa:0x007f86c414e4a0 
+       @groups=[[:a, :d], [:c, :b]], 
+       @list=[:a, :b, :c, :d], 
+       @past_groupmates={:a=>[:b, :c, :d], :b=>[:a], :c=>[:a], :d=>[:a]}> 
+
+groups.repeat_pairs
+  => {:a=>[:d], :b=>[], :c=>[], :d=>[:a]}
+```
+
+*Figure 6*.  Repeat pairs reported for a groups.
+
+An instance of the `Garoupa` class is able to report which list items are in groups with repeat pairs.  `#repeat_pairs` returns a hash with each list item mapped to the repeat pairs in its group (see Figure 6).
+
+#### `#to_json`
+
+The `#to_json` method returns a JSON formatted string representing the `Garoupa` instance.  It includes, the groups, list, past groupmates, and repeat pairs.
+
+#### `#to_s`
+
+```ruby
+list = [:a, :b, :c, :d]
+past_groups = [[:a, :b],[:a, :c]]
+
+groups = Garoupa.make_groups list, target_size: 2, past_groups: past_groups
+  => #<Garoupa:0x007f86c414e4a0 
+       @groups=[[:a, :d], [:b, :c]], 
+       @list=[:a, :b, :c, :d], 
+       @past_groupmates={:a=>[:b, :c], :b=>[:a], :c=>[:a], :d=>[]}> 
+
+puts groups
+1. a, d
+2. b, c
+  => nil
+```
+
+*Figure 7*.  A `Garoupa` is printed as a numbered list.
+
+
+The `#to_s` methods returns a numbered list of the groups (see Figure 7).
+
+
+## Contributing
+
+If you'd like to help improve Garoupa by adding a new feature, please fork the repository and submit a pull request for your feature branch.  Also, please report any bugs that you find.

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/garoupa.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'garoupa/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "garoupa"
+  spec.version       = Garoupa::VERSION
+  spec.authors       = ["Torey Hickman"]
+  spec.email         = ["torey@toreyhickman.com"]
+  spec.summary       = %q{Make groups from a list}
+  spec.homepage      = "https://github.com/toreyhickman/garoupa"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0"
+
+  spec.add_dependency "json"
+end

data/lib/garoupa/version.rb

@@ -0,0 +1,3 @@
+class Garoupa
+  VERSION = "1.0.0"
+end

data/lib/garoupa.rb

@@ -0,0 +1,122 @@
+require "garoupa/version"
+
+class Garoupa
+
+  DEFAULT_GROUP_SIZE = 4
+
+  def self.make_groups(list, options = {})
+    list_items_past_groupmates = past_groupmates(list, options[:past_groups])
+    group_structure            = make_empty_group_structure(list.size, options[:target_size])
+    corrected_group_structure  = correct_for_group_size_difference(group_structure, options[:max_difference])
+    sorted_list                = sort(list, list_items_past_groupmates)
+    groups                     = fill_group_structure(group_structure, sorted_list, list_items_past_groupmates)
+
+    self.new(groups, list, list_items_past_groupmates)
+  end
+
+  def self.past_groupmates(list, past_groups)
+    list.each_with_object( Hash.new ) do |list_item, previous_pairs|
+      previous_pairs[list_item] = past_groupmates_for(list_item, past_groups)
+    end
+  end
+
+
+  attr_reader :groups, :list, :past_groupmates
+
+  def initialize(groups, list, past_groupmates)
+    @groups          = groups
+    @list            = list
+    @past_groupmates = past_groupmates
+  end
+
+  def repeat_pairs
+    list.each_with_object( Hash.new ) do |list_item, repeat_pairs|
+      repeat_pairs[list_item] = group_for(list_item) & past_groupmates[list_item]
+    end
+  end
+
+  def to_json
+    { :groups          => groups,
+      :list            => list,
+      :past_groupmates => past_groupmates,
+      :repeat_pairs    => repeat_pairs }.to_json
+  end
+
+  def to_s
+    groups.map.with_index(1) { |group, index| "#{index}. " + group.join(", ") }.join("\n")
+  end
+
+  private
+  def self.divide_list(list, group_size = nil)
+    list.each_slice(group_size || DEFAULT_GROUP_SIZE).to_a
+  end
+
+  def self.correct_for_group_size_difference(groups, max_difference = nil)
+    return groups unless max_difference
+
+    if difference_in_group_sizes(groups) > max_difference
+      groups = disperse_last_group(groups)
+    end
+    groups
+  end
+
+  def self.difference_in_group_sizes(groups)
+    sizes = groups.map(&:size)
+    sizes.max - sizes.min
+  end
+
+  def self.disperse_last_group(groups)
+    last_group = groups.pop
+
+    last_group.each_with_index do |element, index|
+      groups[index] << element
+    end
+
+    groups
+  end
+
+  def self.make_empty_group_structure(list_size, target_size = nil)
+    empty_list = Array.new(list_size) { nil }
+    empty_groups = divide_list(empty_list, target_size)
+  end
+
+  def self.past_groupmates_for(element, past_groups = nil)
+    return [] unless past_groups
+
+    past_groups = past_groups.select { |group| group.include? element }
+    past_groupmates = past_groups.flatten.uniq - [element]
+  end
+
+  def self.fill_group_structure(group_structure, list, previous_pairs = {})
+    list.each do |list_item|
+      place_in_best_group(list_item, group_structure, previous_pairs)
+    end
+
+    group_structure
+  end
+
+  def self.place_in_best_group(list_item, group_structure, previous_pairs)
+    available_groups = group_structure.select { |group| group.include? nil }
+    group_with_least_repeats = available_groups.min_by { |group| group & previous_pairs[list_item] }
+
+    index_of_nil = group_with_least_repeats.index nil
+    group_with_least_repeats[index_of_nil] = list_item
+
+    return nil
+  end
+
+  def self.sort(list, past_groupmates = nil)
+    return list.shuffle unless past_groupmates
+
+    list.shuffle.sort do |item_a, item_b|
+      item_a_number_of_past_groupmates = past_groupmates.fetch(item_a, []).size
+      item_b_number_of_past_groupmates = past_groupmates.fetch(item_b, []).size
+
+      item_b_number_of_past_groupmates <=> item_a_number_of_past_groupmates
+    end
+  end
+
+  def group_for(list_item)
+    groups.find { |group| group.include? list_item }
+  end
+end

data/spec/garoupa_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+describe Garoupa do
+
+  let(:long_list) { [:a, :b, :c, :d, :e, :f, :g, :h, :i, :j, :k, :l] }
+  let(:garoupa_no_options) { Garoupa.make_groups(long_list) }
+
+  let(:garoupa) { Garoupa.new(groups, list, past_groupmates) }
+  let(:groups) { [[:a, :b], [:c, :d]] }
+  let(:list) { [:a, :b, :c, :d] }
+  let(:past_groupmates) do
+    { :a => [:b, :c, :d],
+      :b => [:a],
+      :c => [],
+      :d => [] }
+  end
+
+
+  describe ".make_groups" do
+    it "returns a Groupa object" do
+      expect(garoupa_no_options).to be_instance_of Garoupa
+    end
+
+    it "places each list item into one group" do
+      list_items_in_groups = garoupa_no_options.groups.flatten
+
+      expect(list_items_in_groups - long_list).to be_empty
+    end
+
+    describe "group_sizes" do
+      context "no target size given" do
+        it "attemtps to make groups of the default group size" do
+
+          expect(garoupa_no_options.groups.first.size).to eq Garoupa::DEFAULT_GROUP_SIZE
+        end
+      end
+
+      context "target size given" do
+        context "list size evenly divisible by target size" do
+          it "makes groups of a specified size" do
+            options = { target_size: 3 }
+            groups = Garoupa.make_groups(long_list, options)
+            groups_sizes = groups.groups.map(&:size)
+
+            expect(groups_sizes.all? { |s| s == 3 }).to be true
+          end
+        end
+
+        context "list size not evenly divisible by target size" do
+          context "no max size difference specified" do
+            it "has one group with a different size" do
+              options = { target_size: 5 }
+              groups = Garoupa.make_groups(long_list, options)
+              groups_sizes = groups.groups.map(&:size)
+
+              expect(groups_sizes).to match_array [5, 5, 2]
+            end
+          end
+
+          context "max size difference specified" do
+            context "max size difference not exceeded" do
+              it "leaves the smaller group" do
+                options = { target_size: 5, max_difference: 3 }
+                groups = Garoupa.make_groups(long_list, options)
+                groups_sizes = groups.groups.map(&:size)
+
+                expect(groups_sizes).to match_array [5, 5, 2]
+              end
+            end
+            context "max size difference exceeded" do
+              it "disperses the smaller group" do
+                options = { target_size: 5, max_difference: 2 }
+                groups = Garoupa.make_groups(long_list, options)
+                groups_sizes = groups.groups.map(&:size)
+
+                expect(groups_sizes).to match_array [6, 6]
+              end
+            end
+          end
+        end
+      end
+    end
+
+    describe "group make up" do
+      context "no past groups provided" do
+        it "divides shuffled list into groups" do
+          allow(long_list).to receive(:shuffle) do
+            [:a, :l, :c, :k, :e, :j, :g, :h, :i, :f, :d, :b]
+          end
+          expected_groups = [[:a, :l, :c, :k], [:e, :j, :g, :h], [:i, :f, :d, :b]]
+
+          expect(garoupa_no_options.groups).to match_array expected_groups
+        end
+      end
+
+      context "past groups provided" do
+        let(:past_groups) { [[:a, :b], [:a, :c], [:a, :d], [:a, :e], [:a, :f], [:a, :g], [:a, :h], [:a, :i]] }
+
+        it "attempts to make groups with minimal repeats" do
+          allow(long_list).to receive(:shuffle) do
+            [:a, :b, :c, :d, :e, :f, :g, :h, :i, :j, :k, :l]
+          end
+
+          options = { past_groups: past_groups }
+          groups = Garoupa.make_groups(long_list, options).groups
+
+          a_group = groups.find { |group| group.include? :a }
+          expect(a_group).to match_array [:a, :j, :k, :l]
+        end
+      end
+    end
+  end
+
+  describe ".past_groupmates" do
+    let(:list) { [:a, :b, :c, :d] }
+    let(:past_groups) { [[:a, :b], [:a, :b], [:a, :c]] }
+
+    it "maps list items to their unique previous groupmates" do
+      past_group_map = Garoupa.past_groupmates(list, past_groups)
+
+      expect(past_group_map[:a]).to match_array [:b, :c]
+      expect(past_group_map[:b]).to match_array [:a]
+      expect(past_group_map[:c]).to match_array [:a]
+      expect(past_group_map[:d]).to be_empty
+    end
+  end
+
+  describe "accessor methods" do
+    let(:groups) { :groups_argument }
+    let(:list) { :list_argument }
+    let(:past_groupmates) { :past_groupmates_argument }
+
+    let(:garoupa) { Garoupa.new(groups, list, past_groupmates) }
+
+    it "returns the list" do
+      expect(garoupa.list).to eq list
+    end
+
+    it "returns the groups" do
+      expect(garoupa.groups).to eq groups
+    end
+
+    it "returns the past groupmates" do
+      expect(garoupa.past_groupmates).to eq past_groupmates
+    end
+  end
+
+  describe "#repeat_pairs" do
+    it "returns the repeat pairs for each list item" do
+      expected_repeat_pairs = { :a => [:b],
+                                :b => [:a],
+                                :c => [],
+                                :d => [] }
+
+      expect(garoupa.repeat_pairs).to eq expected_repeat_pairs
+    end
+  end
+
+  describe "#to_json" do
+    it "returns a JSON formatted string" do
+      expect { JSON.parse(garoupa.to_json) }.to_not raise_error
+    end
+
+    it "includes groups, list, past groupmates, and repeat pairs" do
+      expected_json = { :groups          => garoupa.groups,
+                        :list            => garoupa.list,
+                        :past_groupmates => garoupa.past_groupmates,
+                        :repeat_pairs    => garoupa.repeat_pairs }.to_json
+
+      expect(garoupa.to_json).to eq expected_json
+    end
+  end
+
+  describe "#to_s" do
+    it "returns a numbered list of the groups" do
+      expected_string = "1. a, b\n2. c, d"
+
+      expect(garoupa.to_s).to eq expected_string
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'garoupa'
+require 'json'
+
+RSpec.configure do |c|
+  c.order = "random"
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: garoupa
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Torey Hickman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email:
+- torey@toreyhickman.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- garoupa.gemspec
+- lib/garoupa.rb
+- lib/garoupa/version.rb
+- spec/garoupa_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/toreyhickman/garoupa
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Make groups from a list
+test_files:
+- spec/garoupa_spec.rb
+- spec/spec_helper.rb