learn_party 0.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bc08d3ba51b12c37a9042cda89c818ce2e6704b9
+  data.tar.gz: bfb2f2d2cd7c53cf71c6116ffb34622834cbf46c
+SHA512:
+  metadata.gz: 0c3cebe7aa157d14c698fe60ffabd20f06fe1f591b852e3994209677048559626c4e190d15831a609e2be8338b5a2e4d8e0ef3ec6b8b0e9f1f8f2bfe5e270292
+  data.tar.gz: db39bdcdc8ce7befd398858a6887173fc940f41cc11909c4a8deae73010020ad4eb5dfd5be73e57b466ef92eb9838ab8bd5f533fc50f06cdbac4117ed58a019b

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.1
+before_install: gem install bundler -v 1.11.2

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 TODO: Write your name
+
+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,253 @@
+# LearnTogether
+
+This gem is meant to be used to group Learn student batches into groups for tables, labs and projects. 
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'learn_together'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install learn_together
+
+## Usage
+
+The Learn Together gem is meant to be used from within another project, like a Rails app. The gem can take in any collection of student-like objects, along with a few specifications, and generate groups of students accordingly. 
+
+#### What's a 'student-like object?'
+
+The Learn Together gem can take in a collection of objects that respond to a `#completed_lesson_count_for_active_track` method *or* a collection of hashes, each of which has a key of `:completed_lesson_count_for_active_track`.
+
+This is because the gem can generate groups based on similar progress. The gem uses the total number of completed lessons for a given student's active track as a metric with which to measure progress and thereby sort students. 
+
+#### These student-like objects sound great! Where can I get some?
+
+You can hit this Learn API endpoint for your batch to retrieve a JSON payload describing Learn students. 
+
+```bash
+GET http://leanr.co.api/batches/:batch_id/users
+```
+
+The payload for each student will include an attribute, `"completed_lesson_count_for_active_track"`. You can either use this data to instantiate `Student` objects of your own, OR, you can simply `JSON.parse` the payload, and pass student-like hashes to the gem.
+
+*Important:* If you give the gem a collection of student objects, instantiated from student class you yourself defined, then the gem will return to you groups of these student objects. If you give the gem a collection of hashes, each of which describe a student, the gem will return to you groups of these student hashes, sorted/grouped accordingly.
+
+#### Using the Gem
+
+Once you have your student collection, you can call the gem with a number of different arguments. 
+
+**Student groups with n number of students, based on progress**
+
+```ruby
+LearnTogether::GroupMaker.new.run(collection: <collection of student-like objects>, groups_of: some_number, sort_type: "progress")
+```
+
+For example:
+
+```ruby
+students = Student.all # assuming you have a database full of students with the necessary .completed_lesson_for_active_track attribute
+
+LearnTogether::GroupMaker.new.run(collection: students, groups_of: 2, sort_type: "progress")
+```
+
+returns:
+
+```ruby
+[[#<Student:0x007fc0a1344450
+   @completed_lesson_count_for_active_track=1,
+   @first_name=nil,
+   @github_username="destany-wintheiser",
+   @last_name=nil>,
+  #<Student:0x007fc0a1344810
+   @completed_lesson_count_for_active_track=1,
+   @first_name=nil,
+   @github_username="rowena-larson",
+   @last_name=nil>],
+ [#<Student:0x007fc0a1344608
+   @completed_lesson_count_for_active_track=2, 
+   @first_name=nil, @github_username="nakia", @last_name=nil>,
+  #<Student:0x007fc0a1344798
+   @completed_lesson_count_for_active_track=3,
+   @first_name=nil,
+   @github_username="fletcher-fisher",
+   @last_name=nil>],
+ [#<Student:0x007fc0a13446f8
+   @completed_lesson_count_for_active_track=3,
+   @first_name=nil,
+   @github_username="francesca-bashirian",
+   @last_name=nil>,
+  #<Student:0x007fc0a13448b0 
+   @completed_lesson_count_for_active_track=3,  
+   @first_name=nil, 
+   @github_username="meaghan", @last_name=nil>],
+ [#<Student:0x007fc0a1344c20 
+   @completed_lesson_count_for_active_track=4, 
+   @first_name=nil, @github_username="keeley", 
+   @last_name=nil>,
+  #<Student:0x007fc0a1344478 
+   @completed_lesson_count_for_active_track=4, 
+   @first_name=nil, 
+   @github_username="german", @last_name=nil>],
+ [#<Student:0x007fc0a13447e8
+   @completed_lesson_count_for_active_track=4,
+   @first_name=nil,
+   @github_username="eleazar-beatty",
+   @last_name=nil>,
+  #<Student:0x007fc0a1344950 
+   @completed_lesson_count_for_active_track=4, 
+   @first_name=nil, @github_username="ivy", @last_name=nil>],
+ [#<Student:0x007fc0a13449f0 
+   @completed_lesson_count_for_active_track=4, 
+   @first_name=nil, @github_username="ernestina", 
+   @last_name=nil>,
+  #<Student:0x007fc0a1344bf8 
+   @completed_lesson_count_for_active_track=5, 
+   @first_name=nil, @github_username="erling", 
+   @last_name=nil>],
+ [#<Student:0x007fc0a1344a40 
+   @completed_lesson_count_for_active_track=5, 
+   @first_name=nil, @github_username="heloise-toy", 
+   @last_name=nil>,
+  #<Student:0x007fc0a13449a0
+   @completed_lesson_count_for_active_track=5,
+   @first_name=nil,
+   @github_username="quinten-botsford",
+   @last_name=nil>],
+ [#<Student:0x007fc0a13444c8
+   @completed_lesson_count_for_active_track=6,
+   @first_name=nil,
+   @github_username="janick-feeney",
+   @last_name=nil>,
+  #<Student:0x007fc0a13446d0
+   @completed_lesson_count_for_active_track=6,
+   @first_name=nil,
+   @github_username="trevor-mcclure",
+   @last_name=nil>],
+ [#<Student:0x007fc0a1344748 
+   @completed_lesson_count_for_active_track=7, 
+   @first_name=nil, @github_username="maxie-price", 
+   @last_name=nil>,
+  #<Student:0x007fc0a1344b30
+   @completed_lesson_count_for_active_track=7,
+   @first_name=nil,
+   @github_username="mable-luettgen",
+   @last_name=nil>],
+ [#<Student:0x007fc0a13449c8
+   @completed_lesson_count_for_active_track=7,
+   @first_name=nil,
+   @github_username="jailyn-okeefe",
+   @last_name=nil>,
+  #<Student:0x007fc0a1344978 
+   @completed_lesson_count_for_active_track=7, 
+   @first_name=nil, @github_username="yvonne", 
+   @last_name=nil>],
+ [#<Student:0x007fc0a1344888 
+   @completed_lesson_count_for_active_track=7, 
+   @first_name=nil, @github_username="bobby",
+   @last_name=nil>,
+  #<Student:0x007fc0a13444f0 
+   @completed_lesson_count_for_active_track=7, 
+   @first_name=nil, @github_username="jerrold", 
+   @last_name=nil>],
+ [#<Student:0x007fc0a1344590 
+   @completed_lesson_count_for_active_track=7, 
+   @first_name=nil, @github_username="vivianne", 
+   @last_name=nil>,
+  #<Student:0x007fc0a1344428
+   @completed_lesson_count_for_active_track=8,
+   @first_name=nil,
+   @github_username="jaden-wintheiser",
+   @last_name=nil>],
+ [#<Student:0x007fc0a1344b80 
+   @completed_lesson_count_for_active_track=8, 
+   @first_name=nil, @github_username="obie", @last_name=nil>,
+  #<Student:0x007fc0a1344860 
+   @completed_lesson_count_for_active_track=8, 
+   @first_name=nil, @github_username="sydnie", 
+   @last_name=nil>],
+ [#<Student:0x007fc0a1344770
+   @completed_lesson_count_for_active_track=8,
+   @first_name=nil,
+   @github_username="evelyn-corkery",
+   @last_name=nil>,
+  #<Student:0x007fc0a1344518 
+   @completed_lesson_count_for_active_track=8, 
+   @first_name=nil, @github_username="ashley", 
+   @last_name=nil>],
+ [#<Student:0x007fc0a1344900 
+   @completed_lesson_count_for_active_track=9, 
+   @first_name=nil, @github_username="carey", @last_name=nil>,
+  #<Student:0x007fc0a1344838
+   @completed_lesson_count_for_active_track=9,
+   @first_name=nil,
+   @github_username="rosina-carter",
+   @last_name=nil>],
+ [#<Student:0x007fc0a1344a18
+   @completed_lesson_count_for_active_track=9,
+   @first_name=nil,
+   @github_username="mose-nikolaus",
+   @last_name=nil>,
+  #<Student:0x007fc0a1344720
+   @completed_lesson_count_for_active_track=10,
+   @first_name=nil,
+   @github_username="aurore-feeney",
+   @last_name=nil>],
+ [#<Student:0x007fc0a1344928
+   @completed_lesson_count_for_active_track=10,
+   @first_name=nil,
+   @github_username="maurice-collier",
+   @last_name=nil>,
+  #<Student:0x007fc0a1344b58
+   @completed_lesson_count_for_active_track=10,
+   @first_name=nil,
+   @github_username="valentin-langworth",
+   @last_name=nil>,
+  #<Student:0x007fc0a13445b8 
+   @completed_lesson_count_for_active_track=10, 
+   @first_name=nil, @github_username="andreanne", 
+   @last_name=nil>]
+]
+```
+
+We can see that the return of the `#run` method is an array of arrays, in which each child array represents one group of students and contains the list of the students in that group. In this case, we assume the original student collection contained 35 students. So, `#run` returned an array of 17 arrays, each of which contains two students, except for the last one, which contains 3 students. 
+
+**Student groups with n number of students, sorted randomly**
+
+```ruby
+LearnTogether::GroupMaker.new.run(collection: <collection of student-like objects>, groups_of: some_number, sort_type: "random")
+```
+
+For example:
+
+```ruby
+students = Student.all # assuming you have a database full of students with the necessary .completed_lesson_for_active_track attribute
+
+LearnTogether::GroupMaker.new.run(collection: students, groups_of: 3, sort_type: "random")
+```
+
+**Students into n number of groups**
+
+```ruby
+LearnTogether::GroupMaker.new.run(collection: <collection of student-like objects>, number_of_groups: 3)
+```
+
+This will return an array of three smaller arrays, each of which contains the appropriate number of students. 
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

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

data/bin/console

@@ -0,0 +1,18 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "learn_party"
+# require_relative "./seeds.rb"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+
+
+
+require "irb"
+IRB.start

data/bin/seeds.rb

@@ -0,0 +1,20 @@
+require 'faker'
+class TestStudent
+  attr_accessor :first_name, :last_name, :github_username, :completed_lesson_count_for_active_track
+
+  def initialize(options)
+    @first_name = options["first_name"]
+    @last_name = options["last_name"]
+    @github_username = options["github_username"]
+    @completed_lesson_count_for_active_track = options["completed_lesson_count_for_active_track"]
+  end
+
+  def self.fetch_students(num)
+    student_array = []
+    num.times do
+      obj = {"first_name" => Faker::Name.first_name, "last_name" => Faker::Name.last_name, "github_username" => Faker::Name.last_name.downcase, "completed_lesson_count_for_active_track" => rand(1..10)}
+      student_array.push(TestStudent.new(obj))
+    end
+    student_array
+  end
+end

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/learn_party.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'learn_party/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "learn_party"
+  spec.version       = LearnParty::VERSION
+  spec.authors       = ["johann kerr", "sophie debenedetto"]
+  spec.email         = ["johannkerr@gmail.com"]
+
+  spec.summary       = %q{tool for Flatiron School instructors to group students for projects}
+  spec.homepage      = "https://github.com/flatiron-school/learn-together-gem"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org/"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_dependency 'activesupport', '~> 5.0'
+end

data/lib/learn_party.rb

@@ -0,0 +1,81 @@
+require 'ostruct'
+require "learn_party/version"
+require 'learn_party/generator'
+require 'active_support/core_ext/hash'
+
+module LearnParty
+  class GroupMaker
+    VALID_ARGS = {
+      valid_keys: ["groups_of", "collection", "sort_type", "number_of_groups"],
+      sort_type: ["random", "progress"]
+      }
+
+    attr_accessor :options
+
+    def run(options)
+      @options = ActiveSupport::HashWithIndifferentAccess.new(options)
+      validate_args
+      students = Student.new(options[:collection]).generate_batch_students
+      generator = Generator.new(students: students, groups_of: options[:groups_of], number_of_groups: options[:number_of_groups], sort_type: options[:sort_type])
+      generator.make_groups
+    end
+
+    def validate_args
+      (has_valid_keys? && has_valid_values?) ? true : (raise GroupMakerArgError.new)
+    end
+
+    def has_valid_keys?
+      options.keys.all? {|key| VALID_ARGS[:valid_keys].include?(key)}
+    end
+
+    def has_valid_values?
+      if options["sort_type"]
+        if VALID_ARGS[:sort_type].include?(options["sort_type"])
+          true
+        else
+          false
+        end
+      else
+        true
+      end
+    end
+  end
+
+  class GroupMakerArgError < StandardError
+    def initialize(msg="must pass arguments of: student collection, groups_of (i.e. groups_of: 4), sort_type (i.e. sort_type: 'random') OR student collection and number of groups (i.e. number_of_groups: 3)")
+      super
+    end
+  end
+
+  class Student
+    attr_accessor :collection
+
+    def initialize(collection)
+      @collection = collection
+    end
+
+    def generate_batch_students
+      if student_hash_type
+        return collection.collect {|s| OpenStruct.new(s)}
+      elsif student_instance_object_type
+        return collection
+      else
+        raise StudentTypeError.new
+      end
+    end
+
+    def student_hash_type
+      collection.first.is_a?(Hash) && (collection.first.keys.include?("completed_lesson_count_for_active_track" || :completed_lesson_count_for_active_track))
+    end
+
+    def student_instance_object_type
+      collection.first.respond_to?(:completed_lesson_count_for_active_track)
+    end
+  end
+
+  class StudentTypeError < StandardError
+    def initialize(msg="student collection must contain student objects that respond to a #completed_lesson_count_for_active_track method or have a key of :completed_lesson_count_for_active_track_count")
+      super
+    end
+  end
+end

data/lib/learn_party/generator.rb

@@ -0,0 +1,128 @@
+require 'pry'
+class Generator
+  attr_accessor :students, :groups_of, :sort_type, :number_of_groups
+
+  def initialize(students:, groups_of: nil, sort_type:, number_of_groups: nil)
+    @students = students
+    @groups_of = groups_of
+    @number_of_groups = number_of_groups
+    @sort_type = sort_type
+  end
+
+  def make_groups
+    if groups_of_n_students?
+      GroupsOfNStudents.new(students: students, groups_of: groups_of, sort_type: sort_type).make_groups
+    elsif n_number_of_groups?
+      NNumberOfGroups.new(students: students, number_of_groups: number_of_groups).make_groups
+    end
+  end
+
+  def groups_of_n_students?
+    !!groups_of
+  end
+
+  def n_number_of_groups?
+    !!number_of_groups
+  end
+
+  class GroupsOfNStudents
+
+    attr_accessor :groups_of, :sort_type, :students, :final_groups, :number_of_groups
+
+    def initialize(students:, groups_of:, sort_type:)
+      @students = students
+      @groups_of = groups_of
+      @sort_type = sort_type
+      @final_groups = []
+    end
+
+
+    def make_groups
+      if sort_by_random?
+        form_random_groups
+      elsif sort_by_progress?
+        form_progress_based_groups
+      end
+      final_groups
+    end
+
+
+    def sort_by_random?
+      sort_type == "random"
+    end
+
+    def sort_by_progress?
+      sort_type == "progress"
+    end
+
+    def form_random_groups
+      students.shuffle.each_slice(groups_of.to_i) { |students| final_groups << students }
+       check_student_distribution
+    end
+
+    def form_progress_based_groups
+      students.sort_by {|s| s.completed_lesson_count_for_active_track}.each_slice(groups_of.to_i) { |students| final_groups << students }
+      check_student_distribution
+    end
+
+    def check_student_distribution
+      if leftover_students?
+        leftover_val = students.length % groups_of.to_i
+        if leftover_val == 1
+          student = final_groups.pop.first
+          final_groups.last << student
+        elsif leftover_val == groups_of.to_i / 2
+          final_groups.pop.each_with_index do |student, i|
+            final_groups["-#{i + 1}".to_i] << student
+          end
+        end
+      else
+      end
+    end
+
+    def leftover_students?
+      students.length % groups_of.to_i > 0
+    end
+
+    def leftover_students
+      students.length % groups_of.to_i <=  (groups_of.to_i - 2) || students.length % groups_of.to_i == 1
+    end
+  end
+
+  class NNumberOfGroups
+    attr_accessor :students, :number_of_groups, :students_per_group, :final_groups
+
+    def initialize(students:, number_of_groups:)
+      @students = students
+      @number_of_groups = number_of_groups
+      @final_groups = []
+    end
+
+    def make_groups
+      make_initial_distribution
+      adjust_distribution
+      final_groups
+    end
+
+    def students_per_group
+      @students_per_group = students.length / number_of_groups
+    end
+
+    def make_initial_distribution
+      students.each_slice(students_per_group) do |slice|
+        final_groups  << slice
+      end
+    end
+
+    def adjust_distribution
+      if final_groups.last.size < students_per_group && final_groups.length > number_of_groups
+        final_groups.pop.each_with_index do |remaining_student, i|
+          final_groups[i] << remaining_student
+        end
+      end
+    end
+  end
+
+
+
+end

data/lib/learn_party/version.rb

@@ -0,0 +1,3 @@
+module LearnParty
+  VERSION = "0.4.1"
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: learn_party
+version: !ruby/object:Gem::Version
+  version: 0.4.1
+platform: ruby
+authors:
+- johann kerr
+- sophie debenedetto
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-02-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.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: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: 
+email:
+- johannkerr@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/seeds.rb
+- bin/setup
+- learn_party.gemspec
+- lib/learn_party.rb
+- lib/learn_party/generator.rb
+- lib/learn_party/version.rb
+homepage: https://github.com/flatiron-school/learn-together-gem
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org/
+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.6.14
+signing_key: 
+specification_version: 4
+summary: tool for Flatiron School instructors to group students for projects
+test_files: []