barbershop_contestants 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4b0fba353b50e988a9b343dccc67139af2197fbc
+  data.tar.gz: ad01c1da9472974c40ded8ce4bcf96a511bbd020
+SHA512:
+  metadata.gz: 7504de419f48b6d9ed65657a8a140d10f40eba760868b6e34dba509f43a4cc9c00f3f85fefb5f3d6ce224d41f6d99508a2d1ded85c3aac547913aa9c97e46c28
+  data.tar.gz: d6a4654f69a851a8e186553db4cd80b5a71b7986828cd1706d967565b0196b2bafd3be1402f54989a470a6b813e809f916f494829183ff588525703db282ea5c

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/CHANGELOG.md

@@ -0,0 +1 @@
+0.0.1

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in barbershop_contestants.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,91 @@
+PATH
+  remote: .
+  specs:
+    barbershop_contestants (0.2.0)
+      nokogiri (~> 1.8.5)
+      require_all (~> 2.0.0)
+      tty-table (~> 0.10.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (5.2.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    addressable (2.5.2)
+      public_suffix (>= 2.0.2, < 4.0)
+    coderay (1.1.2)
+    concurrent-ruby (1.1.4)
+    equatable (0.5.0)
+    faraday (0.15.4)
+      multipart-post (>= 1.2, < 3)
+    faraday-http-cache (2.0.0)
+      faraday (~> 0.8)
+    github_changelog_generator (1.14.3)
+      activesupport
+      faraday-http-cache
+      multi_json
+      octokit (~> 4.6)
+      rainbow (>= 2.1)
+      rake (>= 10.0)
+      retriable (~> 2.1)
+    i18n (1.3.0)
+      concurrent-ruby (~> 1.0)
+    method_source (0.9.2)
+    mini_portile2 (2.3.0)
+    minitest (5.11.3)
+    multi_json (1.13.1)
+    multipart-post (2.0.0)
+    necromancer (0.4.0)
+    nokogiri (1.8.5-x64-mingw32)
+      mini_portile2 (~> 2.3.0)
+    octokit (4.13.0)
+      sawyer (~> 0.8.0, >= 0.5.3)
+    pastel (0.7.2)
+      equatable (~> 0.5.0)
+      tty-color (~> 0.4.0)
+    pry (0.12.2)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+    public_suffix (3.0.3)
+    rainbow (3.0.0)
+    rake (10.5.0)
+    require_all (2.0.0)
+    retriable (2.1.0)
+    sawyer (0.8.1)
+      addressable (>= 2.3.5, < 2.6)
+      faraday (~> 0.8, < 1.0)
+    strings (0.1.4)
+      strings-ansi (~> 0.1.0)
+      unicode-display_width (~> 1.4.0)
+      unicode_utils (~> 1.4.0)
+    strings-ansi (0.1.0)
+    thread_safe (0.3.6)
+    tty-color (0.4.3)
+    tty-screen (0.6.5)
+    tty-table (0.10.0)
+      equatable (~> 0.5.0)
+      necromancer (~> 0.4.0)
+      pastel (~> 0.7.2)
+      strings (~> 0.1.0)
+      tty-screen (~> 0.6.4)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+    unicode-display_width (1.4.1)
+    unicode_utils (1.4.0)
+
+PLATFORMS
+  ruby
+  x64-mingw32
+
+DEPENDENCIES
+  barbershop_contestants!
+  bundler (~> 1.17)
+  github_changelog_generator (~> 1.14.3)
+  pry (~> 0.12.2)
+  rake (~> 10.0)
+
+BUNDLED WITH
+   1.17.2

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 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,37 @@
+# BarbershopContestants
+
+A ruby gem that scrapes [the Barbershop Harmony wiki](https://www.barbershopwiki.com/wiki/Barbershop_Wiki_Project) and provides info on contestants in the Barbershop Harmony Society International Competition. This gem is my Ruby CLI project for the [Learn.co](https://learn.co) web development track section one. Shout out to the other members of the "A Bug's Life" cohort!
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'barbershop_contestants'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install barbershop_contestants
+
+## Usage
+
+Follow the prompts to drill down into the various participants in the BHS International Competition
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. 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).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/artrexdenthur/barbershop_contestants.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/barbershop_contestants.gemspec

@@ -0,0 +1,49 @@
+
+lib = File.expand_path("lib", __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "barbershop_contestants/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "barbershop_contestants"
+  spec.version       = BarbershopContestants::VERSION
+  spec.authors       = ["Paul Ashour"]
+  spec.email         = ["paul.ashour@gmail.com"]
+
+  spec.summary       = "A quick Ruby Gem that scrapes barbershopwiki.com for the Learn.co Ruby CLI project."
+  spec.description   = "This Gem scrapes barbershopwiki.com and organizes the data for perusal via a simple CLI. Created for the Ruby CLI project in section one of Learn.co's Full Stack Web Development program."
+  spec.homepage      = "https://github.com/artrexdenthur/Ruby-Gem-Project-Barbershop-Contestants"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+  #
+  #   spec.metadata["homepage_uri"] = spec.homepage
+  #   spec.metadata["source_code_uri"] = "https://github.com/artrexdenthur/oo-student-scraper-online-web-pt-102218.git"
+  #   spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against " \
+  #     "public gem pushes."
+  # end
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "bin"
+  spec.executables   = ["barbershop_contestants"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "github_changelog_generator", "~> 1.14.3"
+  spec.add_development_dependency "pry", "~> 0.12.2"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_runtime_dependency "nokogiri", "~> 1.8.5"
+  spec.add_runtime_dependency "require_all", "~> 2.0.0"
+  spec.add_runtime_dependency "tty-table", "~> 0.10.0"
+
+
+end

data/bin/barbershop_contestants

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "nokogiri"
+require "open-uri"
+require "require_all"
+require "tty-table"
+
+require "pry"
+require "irb"
+
+require "barbershop_contestants"
+
+# hello from Sue
+# and hello from Dozuki

data/bin/console

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "nokogiri"
+require "open-uri"
+require "require_all"
+# 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"
+
+require "barbershop_contestants"

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/lib/barbershop_contestants/cli.rb

@@ -0,0 +1,214 @@
+# command line interface
+# responsible for starting the scraping/org process
+# and providing the user with an interface
+class CLI
+  # Contest::Quartets.scrape_contests
+
+  @welcome_message = "Welcome to the Barbershop Contestants CLI!"
+
+  @command_verb_hash = {
+    "quar" => [:display, "quartet"],
+    "chor" => [:display, "chorus"],
+    "help" => [:help, ""],
+    "quit" => [:quit, ""],
+    "load" => [:load, ""]
+  }
+
+  @type_years_hash = {
+    "quartet" => (1939..2018),
+    "chorus" => (1953..2018)
+  }
+
+  def self.start
+    # welcome the user and show command list
+    # have the bin file call this method
+    # scrape data from here, logic primarily in scraper
+    system "clear" or system "cls"
+    puts @welcome_message
+    @source = choose_source
+    Scraper.scrape_and_create_quartet_champs(@source)
+    Scraper.scrape_and_create_chorus_champs(@source)
+    Scraper.scrape_and_create_year(@source, 2018, "quartet") # remove in final
+    Scraper.scrape_and_create_year(@source, 2018, "chorus") # remove in final
+    request_command
+    input_loop
+  end
+
+  def self.choose_source
+    return :web
+    # loop do
+      # puts "Enter web or local:"
+      # entry = gets.chomp
+      # return entry.to_sym if %w[web local].include?(entry)
+    # end
+    ### Reverse the comments in this method to be offered a choice at launch
+    ### between web scraping and local scraping.
+  end
+
+  def self.input_loop
+    # binding.pry
+    loop do
+      puts "\nEnter a command:"
+      process_command(gets.chomp.downcase)
+    end
+  end
+
+  def self.request_command
+    puts "Please enter a command."
+    puts "To see all entries in a contest, enter the type of contest " \
+          "(quartet or chorus) and the year (1939-2018 for quartets, " \
+          "1953-2018 for choruses)"
+    puts "To see all performances currently in cache by a particular group, " \
+          "enter the name of the group"
+    puts "To see a list of all champions for a contest type, enter " \
+        "'quartet champions' or 'chorus champions'"
+    puts "To load all contests, or all contests of one type, " \
+        "enter 'load all', 'load quartets', or 'load choruses'"
+    puts "To quit, enter 'quit'"
+    puts "To see this info again, enter 'help'"
+  end
+
+  def self.process_command(command)
+    # parses the given input between command types.
+    # full "quartet" and "chorus" parsing is in other methods.
+    system "clear" or system "cls"
+    command_arr = command.split
+    if command_arr[0] # the user typed something
+      parse_command_verb(command_arr) || show_competitor(command) || no_command
+    else
+      no_command
+    end
+  end
+
+  def self.parse_command_verb(commands)
+    verb = @command_verb_hash.find { |k, _| commands[0].start_with?(k) }
+    # binding.pry
+    verb ? send(verb[1][0], verb[1][1], commands.drop(1)) : false
+  end
+
+  def self.display(type, commands)
+    # type contains competitor type string (chorus or quartet)
+    # commands contains remainder of user input as string array
+    if commands.any? { |c| c.start_with?("cham") } # check for champs command
+      display_champs(type)
+      true
+    elsif (year = commands.find { |c| @type_years_hash[type].include? c.to_i })
+      display_year(year.to_i, type)
+      true
+    else
+      false
+    end
+  end
+
+  def self.display_champs(type)
+    champs_arr = Performance.filter_all(place: 1, type: type)
+    title = "BHS International #{type.capitalize} Champions"
+    headers = ["Year", type.capitalize, "District", "Score"]
+    rows = champs_arr.map do |p|
+      disp_arr = []
+      disp_arr.push(p.year, p.competitor.name, p.competitor.district, p.score)
+    end
+    print_tty_table(title: title, headers: headers, rows: rows)
+    true
+  end
+
+  def self.display_year(year, type)
+    Scraper.scrape_and_create_year(@source, year, type)
+    year_arr = Performance.filter_all(year: year, type: type)
+    title = "BHS International #{type.capitalize} Competition #{year}"
+    headers = ["Place", type.capitalize, "District", "Score"]
+    rows = year_arr.map do |p|
+      disp_arr = []
+      disp_arr.push(p.place, p.competitor.name, p.competitor.district, p.score)
+    end
+    print_tty_table(title: title, headers: headers, rows: rows)
+  end
+
+  def self.load(_, commands)
+    case commands
+    when commands.any? { |c| c.start_with?("quar") }
+      type = "quartet"
+    when commands.any? { |c| c.start_with?("chor") }
+      type = "chorus"
+    else
+      type = nil
+    end
+    load_all(type)
+    true
+  end
+
+  def self.load_all(type)
+    if type
+      @type_years_hash[type].each do |y|
+        Scraper.scrape_and_create_year(@source, y, type)
+      end
+    else
+      @type_years_hash.each do |type, year_range|
+        year_range.each do |year|
+          Scraper.scrape_and_create_year(@source, year, type)
+        end
+      end
+    end
+  end
+
+  def self.help(*_)
+    request_command
+  end
+
+  def self.quit(*_)
+    puts "Goodbye!"
+    IRB.start(__FILE__)
+    exit
+  end
+
+  def self.show_competitor(name)
+    comp = Competitor.all.find{ |c| c.name.downcase == name }
+    # binding.pry
+    if comp
+      puts comp.name, comp.type.capitalize, "District: #{comp.district}"
+      if comp.type == "quartet"
+        comp.comments && (puts "Comments: #{comp.comments}")
+        comp.members && (puts "Members: #{comp.members}")
+      else
+        comp.director && (puts "Director: #{comp.director}")
+        comp.hometown && (puts "Hometown: #{comp.hometown}")
+      end
+      show_competitor_performances(comp)
+    else
+      false
+    end
+    true
+  end
+
+  def self.show_competitor_performances(com)
+    title = "Performances"
+    headers = ["Year", "Place", "Score"]
+    headers << "# On Stage" if com.type == "chorus"
+    perf_arr = com.performances.sort_by { |p| p.year }.reverse
+    # binding.pry
+    rows = perf_arr.map do |p|
+      disp_arr = []
+      disp_arr.push(p.number_on_stage) if com.type == "chorus"
+      disp_arr.unshift(p.year, p.place, p.score)
+    end
+    # binding.pry
+    print_tty_table(title: title, headers: headers, rows: rows)
+  end
+
+  def self.print_tty_table(title: nil, headers: nil, rows:)
+    puts title if title
+    # binding.pry
+    if headers
+      table = TTY::Table.new headers, rows
+    else
+      table = TTY::Table.new rows
+    end
+    puts table.render(:ascii, padding: [0,1,0,1])
+  end
+
+  def self.no_command
+    puts "Sorry, that command was not recognized\n"
+    request_command
+  end
+
+end

data/lib/barbershop_contestants/competitor.rb

@@ -0,0 +1,90 @@
+# comprises two types: quartet and chorus
+# each has an m-to-m relationship with Contest::Quartet
+# and Contest::Chorus, respectively
+class Competitor
+  attr_accessor :performances, :district, :name, :type
+
+  @@all = []
+
+  def save
+    Competitor.all << self
+  end
+
+  def self.find_or_create(arg_hash)
+    self.all.find { |x| x.name == arg_hash[:name] } || self.create(arg_hash)
+  end
+
+  def self.fill_find_or_create(arg_hash)
+    if self.all.find { |c| c.name == arg_hash[:name] }
+      self.fill(arg_hash)
+    else
+      self.create(arg_hash)
+    end
+  end
+
+  def self.create(arg_hash)
+    competitor = self.new(arg_hash)
+    competitor.save
+    competitor
+  end
+
+  def self.all
+    @@all
+  end
+
+end
+
+class Quartet < Competitor
+
+  attr_accessor :tenor, :lead, :baritone, :bass, :comments, :members
+
+  def initialize(arg_hash)
+    self.name = arg_hash[:name]
+    self.type = 'quartet'
+    self.district = arg_hash[:district]
+    self.performances = (arg_hash[:performances] || [])
+    self.comments = arg_hash[:comments]
+    self.members  = self.format_members(arg_hash[:members])
+  end
+
+  def format_members(member_string)
+    self.members = member_string
+    # TODO: modify to pull out the members and put them in their own hashes
+  end
+
+  def self.all
+    @@all.find_all { |c| c.type == "quartet" }
+  end
+end
+
+class Chorus < Competitor
+
+  attr_accessor :hometown, :director
+
+  def initialize(arg_hash)
+    self.name = arg_hash[:name]
+    self.type = 'chorus'
+    self.district = arg_hash[:district]
+    format_hometown_and_district(arg_hash[:hometown_and_district])
+    self.performances = (arg_hash[:performances] || [])
+    self.director = arg_hash[:director]
+  end
+
+  def current_director
+    performances.max { |p| p.year.to_i }.director
+  end
+
+  def format_hometown_and_district(hometown_and_district)
+    # TODO: plug this logic in
+    if hometown_and_district
+      h_d_match = /(?<h>.*) \((?<d>.*)\)/.match(hometown_and_district)
+      self.hometown = h_d_match[:h]
+      self.district = h_d_match[:d]
+    end
+  end
+
+  def self.all
+    @@all.find_all { |c| c.type == "chorus" }
+  end
+
+end

data/lib/barbershop_contestants/contest.rb

@@ -0,0 +1,33 @@
+# holds the data specific to each contest
+class Contest
+  # now there's text again
+  attr_accessor :performances, :year, :city, :type
+
+  @@all = []
+
+  def initialize(arg_hash)
+    self.performances = (arg_hash[:performances] || [])
+    self.year = arg_hash[:year]
+    self.city = arg_hash[:city]
+    self.type = arg_hash[:type]
+  end
+
+  def save
+    Contest.all << self
+  end
+
+  def self.find_or_create(arg_hash)
+    self.all.find { |x| x.year == arg_hash[:year] && x.type == arg_hash[:type] } || self.create(arg_hash)
+  end
+
+  def self.create(arg_hash)
+    contest = self.new(arg_hash)
+    contest.save
+    contest
+  end
+
+  def self.all
+    @@all
+  end
+
+end

data/lib/barbershop_contestants/performance.rb

@@ -0,0 +1,83 @@
+# competitors have many contests through performances and vice versa
+class Performance
+  attr_accessor :contest, :competitor, :score, :place, :year, :number_on_stage, :director
+
+  @@all = []
+
+  def initialize(arg_hash)
+    self.year = arg_hash[:year]
+    self.score = arg_hash[:score]
+    self.place = arg_hash[:place]
+    # the following will generally be nil at this point
+    self.contest = arg_hash[:contest]
+    self.competitor = arg_hash[:competitor]
+    self.number_on_stage = arg_hash[:number_on_stage]
+    self.director = arg_hash[:director]
+  end
+
+  def save
+    @@all << self
+  end
+
+  def self.create(arg_hash)
+    performance = new(arg_hash)
+    performance.save
+    performance
+  end
+
+  def self.create_q_performance(q_champs_hash)
+    performance = create(q_champs_hash)
+    performance.competitor = Quartet.find_or_create(q_champs_hash)
+    performance.competitor.performances << performance
+    performance.contest = Contest.find_or_create(q_champs_hash)
+    performance.contest.performances << performance
+    performance
+  end
+
+  def self.create_c_performance(c_champs_hash)
+    performance = create(c_champs_hash)
+    performance.competitor = Chorus.find_or_create(c_champs_hash)
+    performance.competitor.performances << performance
+    performance.contest = Contest.find_or_create(c_champs_hash)
+    performance.contest.performances << performance
+    performance
+  end
+
+  def self.create_performance(arg_hash, type)
+    performance = create(arg_hash)
+    performance.competitor = \
+      (type == "chorus" ? Chorus : Quartet).send :find_or_create, arg_hash
+    performance.competitor.performances << performance
+    performance.contest = Contest.find_or_create(arg_hash)
+    performance.contest.performances << performance
+    performance
+  end
+
+  def self.find_or_create(arg_hash, type)
+    found = self.all.find do |p|
+      p.year == arg_hash[:year] && p.competitor.name == arg_hash[:name]
+    end
+    found || create_performance(arg_hash, type)
+  end
+
+  def self.champs_type_by_year(type)
+    all.select { |p| p.place == 1 && p.contest.type = type }.sort_by { |p| p.year }
+  end
+
+  def self.filter_all(place: nil, year: nil, type: nil, comp_name: nil)
+    filter = self.all
+    place && filter = filter.select { |p| p.place == place }.sort_by { |p| p.year.to_i }
+    year && filter = filter.select { |p| p.year == year }.sort_by { |p| p.place.to_i }
+    type && filter = filter.select { |p| p.competitor.type == type }
+    comp_name && filter = filter.select { |p| p.competitor.name == name }
+    filter
+  end
+
+  def self.all
+    @@all
+  end
+
+  def self.clear
+    @@all.clear
+  end
+end