footballfiltertool 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 302154a71776df58b8e1efb6e16988828d55f55decd2f99cbe867625b83dcebe
+  data.tar.gz: 9f5edf3dc8cbf48fe067744ae8b298aec9f5c23425d97b37fb917e2c585b6a19
+SHA512:
+  metadata.gz: cce12c7ffa14e0b7840caa1902c4fa3cfaa453329cae77cd6019a04ed5fd9fc1c2faba28a3ed4b95aa217ee37923b66142e092c9e614fdf4dc099adcc3b0783c
+  data.tar.gz: fba85d3055e54330ca8c7ee502b70cc277cfdc86fea48bf2b7d2e15b4987a76154d3f41bdf493a341a86e9c14eae99a43f3d9e29ed9d509e29e9391a2ddae901

data/bin/console

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "footballfiltertool"
+
+# 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
+
+puts "HELLO WORLD"

data/bin/main

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/footballfiltertool.rb"
+RunCommandLineInteface.run

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/command_line_interface.rb

@@ -0,0 +1,311 @@
+require_relative '../lib/player.rb'
+require 'nokogiri'
+require 'pry'
+class CommandLineInterface
+    attr_accessor :user, :stats_list, :filter_list, :sort_stat, :sort_value, :player_data
+    
+    def initialize(user)
+        @user = user
+    end
+
+
+    def self.run
+        user_cli = CommandLineInterface.new("ADMIN")
+        user_cli.start
+    end
+    
+    def start
+        puts "Welcome to Football Stats Filter Tool"
+        puts "Would you like to load some football stats (y/n)"
+        input = gets.chomp
+        while(input == "y")
+            request_year
+            print_allowable_attributes
+            loop do 
+                run_query
+                puts "Would you like to query another list from this year? (y/n)"
+                input = gets.chomp
+                if(input != "y")
+                    break
+                end
+                @player_data = Player.all
+
+            end
+            puts "Would you like to load another year? (y/n)"
+            input = gets.chomp
+
+        end
+        puts "Thank you for using the Football stats filter tool, have a nice day"
+
+    end
+
+    def run_query 
+        request_stats_list
+        request_filter_list
+        request_sort
+        filter_player_data
+        sort_player_data
+        display_current_player_data
+    end
+
+    def display_current_player_data
+        puts stats_list_header
+        @player_data.each.with_index do |player, i|
+            out = "#{i+1}.\t"
+            @stats_list.each do |stat|
+                value = player.instance_variable_get("@#{stat}")
+                out+= "#{value}#{determine_table_tabs(stat, value)}"
+            end
+            puts out
+        end
+    end
+
+    def sort_player_data
+        if(@sort_value == "ASC")
+            @player_data.sort!{|player_a, player_b| player_a.instance_variable_get("@#{@sort_stat}") <=> player_b.instance_variable_get("@#{@sort_stat}")}
+        elsif(@sort_value == "DESC")
+            @player_data.sort!{|player_a, player_b| player_b.instance_variable_get("@#{@sort_stat}") <=> player_a.instance_variable_get("@#{@sort_stat}")}
+        end
+    end
+
+    def filter_player_data
+        out = []
+        @filter_list.each do |filter_entry|
+            stat = filter_entry[:stat]
+            value = filter_entry[:value]
+            compare_type = filter_entry[:compare_type]
+
+            @player_data.each do |player_entry|
+                entry_value = player_entry.instance_variable_get("@#{stat}")
+                if(entry_value!=nil)
+                    if(compare_type == ">" && entry_value>value)
+                        out.push(player_entry)
+                    end
+                    if(compare_type == "<" && entry_value<value)
+                        out.push(player_entry)
+                    end
+                    if(compare_type == "=" && entry_value==value)
+                        out.push(player_entry)
+                    end
+                end
+            end 
+            @player_data = out 
+            out = []
+        end
+    end
+    
+    def request_year
+        Player.delete_all
+        puts "Please select a year to load"
+        year = gets.chomp.to_i
+
+        begin 
+            Player.import(year) 
+            @player_data = Player.all
+        rescue OpenURI::HTTPError => error
+            if error.message == '404 Not Found'
+                puts "Invalid year selection"
+                request_year
+            else 
+                raise error
+            end
+        end
+    end
+
+    def stats_list_header
+        out ="\tname\t\t\t"
+        tab_length = 8;
+
+        @stats_list.each do |entry|
+            if(entry!=:name)
+                out += entry.to_s
+                out+="\t"
+            end
+        end 
+        out
+    end
+
+    def determine_table_tabs(stat_symbol, value)#returns the appropriate number of tabs for a given table entry
+        value_length = value.to_s.length
+        stat_symbol_length = stat_symbol.to_s.length
+        tab_length = 8;
+        name_defaults_tabs =3;
+        num_tabs = 0;
+        if(stat_symbol == :name)
+            num_tabs = name_defaults_tabs-(value_length)/tab_length
+        else 
+            num_tabs = 1 + (stat_symbol_length)/tab_length - (value_length)/tab_length
+        end 
+
+        out = ""
+
+        num_tabs.times{out += "\t"}
+        return out
+    end
+
+    def request_stats_list
+        puts "Give a list of the stats you would like display along with the player name (e.g. team, sacks, tackles)"
+        stats_input = gets.chomp
+        stats_interpreted = interpret_stat_selection(stats_input)
+        if(stats_interpreted[:invalid_data].length>0)
+            puts "The following entries were invalid and will be discarded"
+            stats_interpreted[:invalid_data].each do |entry|
+                puts entry 
+            end
+            puts "Would you like to repeat this step? (y/n)"
+            input = gets.chomp
+            if(input == "y")
+                request_stats_list
+            else 
+                @stats_list = stats_interpreted[:valid_data] 
+            end
+        else 
+            @stats_list = stats_interpreted[:valid_data]  
+        end
+    end
+
+    def request_filter_list
+        puts "Give a list of conditions that should be met with the player to be included (e.g sacks > 8, pass_touchdowns > 25, team = SEA)"
+        filters_input = gets.chomp
+        filters_interpreted = interpret_filter_selection(filters_input)
+        if(filters_interpreted[:invalid_data].length>0)
+            puts "The following entries were invalid and will be discarded"
+            filters_interpreted[:invalid_data].each do |entry|
+                puts entry[:string]
+            end
+            puts "Would you like to repeat this step? (y/n)"
+            input = gets.chomp
+            if(input == "y")
+                request_filter_list
+            else 
+                @filter_list = filters_interpreted[:valid_data] 
+            end
+        else 
+            @filter_list = filters_interpreted[:valid_data]  
+        end
+
+    end
+
+    def request_sort
+        puts "How would you like to sort the data, give a stat and ASC or DESC"
+        sort_input = gets.chomp
+        sort_interpreted = interpret_sort_selection(sort_input)
+        if(sort_interpreted[:return_type] == "invalid_data")
+            "Your entry was invlalid and will be discarded"
+            puts "Would you like to repeat this step? (y/n)"
+            if(input == "y")
+                request_sort
+            else #default to sort by name ascending
+                @sort_stat = "name"
+                @sort_value = "ASC" 
+            end
+
+        else 
+            @sort_stat = sort_interpreted[:sort_stat]
+            @sort_value = sort_interpreted[:sort_value]
+        end
+
+    end
+
+    def interpret_stat_selection(input) 
+        out =  input.strip.split(/[\s,]+/)
+        out.unshift("name")
+        valid_entries = []
+        invalid_entries = []
+
+        out.each do |attribute|
+            if(allows_atribute?(attribute))
+                valid_entries.push(attribute.to_sym)
+            else
+                invalid_entries.push(attribute)
+            end
+        end
+            
+        return {
+            :valid_data => valid_entries.uniq,
+            :invalid_data => invalid_entries.uniq
+        }
+
+    end
+
+    def interpret_filter_selection(input)
+        list = input.strip.split(/,+/)
+        out = []
+        valid_entries = []
+        invalid_entries = []
+        list.each do |entry|
+            hash = {}
+            compare_type = entry.match(/[=<>]/)
+            if(compare_type == nil)#indicates no compare operator (>, <, =) was found
+                hash[:type] = "invalid compare statement"
+                hash[:string] = entry
+            else
+                compare_type = compare_type[0]
+                entry_data = entry.gsub(/\s+/, "").split(compare_type)
+                if(entry_data.length != 2)#indicates either no stat, no value or too many compare operators
+                    hash[:type] = "invalid compare statement"
+                    hash[:string] = entry
+                elsif(!allows_atribute?(entry_data[0]))
+                    hash[:type] = "invalid compare statement"
+                    hash[:string] = entry
+                else
+                    hash[:type] = "valid compare statement"
+                    hash[:compare_type] = compare_type
+                    hash[:stat] = entry_data[0].gsub(/\s+/, "").to_sym
+                    hash[:value] = entry_data[1].gsub(/\s+/, "").to_f
+                end 
+            end 
+            if(hash[:type] == "invalid compare statement")
+                invalid_entries.push(hash)
+            elsif(hash[:type] == "valid compare statement")
+                valid_entries.push(hash)
+            end
+            out.push(hash[:type] == "invalid compare statement")
+        end 
+        return {
+            :valid_data => valid_entries,
+            :invalid_data => invalid_entries
+        } 
+    end
+
+    def interpret_sort_selection(input)
+        out =  input.strip.split(/[\s,]+/)
+        output_data = {}
+        if(out.length>2 || !allows_atribute?(out[0]))
+            output_data[:return_type] = "invalid data"
+        elsif(out.length == 2)
+            sort_priority = out[1].upcase
+            if(sort_priority != "ASC" && sort_priority != "DESC")
+                output_data[:return_type] = "invalid data"
+            else 
+                output_data[:return_type] = "valid data"
+                output_data[:sort_stat] = out[0].to_sym
+                output_data[:sort_value] = sort_priority
+            end
+        elsif(out.length == 1)
+            output_data[:sort_stat] = out[0].to_sym
+            output_data[:sort_value] = "ASC"
+        else 
+            output_data[:sort_stat] = :name
+            output_data[:sort_value] = "ASC"
+        end
+        output_data
+    end
+
+    def allows_atribute?(attribute)
+        first_data_instance = player_data[0]
+        first_data_instance.has_attribute?(attribute)
+    end
+
+    def print_allowable_attributes
+        first_data_instance = player_data[0]
+        puts "The following attributes exist in this data set"
+        puts "\n"
+        current_string = "";
+        first_data_instance.class.allowable_attributes.each_with_index do |attribute, i|
+            puts attribute
+        end
+        puts "\n"
+    end
+
+end

data/lib/data_scraper.rb

@@ -0,0 +1,49 @@
+require 'open-uri'
+
+
+class DataScraper
+
+    def self.scrape_data(url, stat_type)
+        html = Nokogiri::HTML(URI.open(url))
+        data = html.css('tr:not(.thead)')
+        out = []
+        data.each do |entry|
+            name = entry.css('td[data-stat="player"]').text
+            hash = {}
+            if(name != "")
+                hash[:name] = entry.css('td[data-stat="player"]').text.match(/.*[a-zA-Z]/)[0]#remove excess whitespace and extra characters
+                hash[:age] = entry.css('td[data-stat="age"]').text.to_i
+                hash[:position] = entry.css('td[data-stat="pos"]').text.upcase
+                hash[:team] = entry.css('td[data-stat="team"]').text
+                if(stat_type == "passing")
+                    hash[:pass_completions] = entry.css('td[data-stat="pass_cmp"]').text.to_f
+                    hash[:pass_attempts] = entry.css('td[data-stat="pass_att"]').text.to_f
+                    hash[:pass_completion_percentage] = entry.css('td[data-stat="pass_cmp_perc"]').text.to_f
+                    hash[:pass_touchdowns] = entry.css('td[data-stat="pass_td"]').text.to_f
+                    hash[:interceptions_thrown] = entry.css('td[data-stat="pass_int"]').text.to_f
+                    hash[:pass_yards] = entry.css('td[data-stat="pass_yds"]').text.to_f
+                    hash[:yards_per_pass_attempt] = entry.css('td[data-stat="pass_yds_per_att"]').text.to_f
+                elsif(stat_type == "rushing")
+                    hash[:carries] = entry.css('td[data-stat="rush_att"]').text.to_f
+                    hash[:rush_yards] = entry.css('td[data-stat="rush_yds"]').text.to_f
+                    hash[:rush_yards_per_attempt] = entry.css('td[data-stat="rush_yds_per_att"]').text.to_f
+                    hash[:rush_touchdowns] = entry.css('td[data-stat="rush_td"]').text.to_f
+                elsif(stat_type == "receiving")
+                    hash[:receptions] = entry.css('td[data-stat="rec"]').text.to_f
+                    hash[:receiving_yards] = entry.css('td[data-stat="rec_yds"]').text.to_f
+                    hash[:receiving_yards_per_catch] = entry.css('td[data-stat="rec_yds_per_att"]').text.to_f
+                    hash[:receiving_touchdowns] = entry.css('td[data-stat="rec_td"]').text.to_f
+                elsif(stat_type == "defense")
+                    hash[:interceptions_caught] = entry.css('td[data-stat="def_int"]').text.to_f
+                    hash[:passes_defended] = entry.css('td[data-stat="pass_defended"]').text.to_f
+                    hash[:tackles] = entry.css('td[data-stat="tackles_combined"]').text.to_f
+                    hash[:sacks] = entry.css('td[data-stat="sacks"]').text.to_f
+                    hash[:tackles_for_loss] = entry.css('td[data-stat="tackles_loss"]').text.to_f
+                    hash[:quarterback_hits] = entry.css('td[data-stat="qn_hits"]').text.to_f
+                end
+                out.push(hash)
+            end 
+        end 
+        return out
+    end
+end

data/lib/footballfiltertool.rb

@@ -0,0 +1,8 @@
+require "footballfiltertool/version"
+require_relative "./command_line_interface"
+module Footballfiltertool
+  class Error < StandardError; end
+  def self.run
+    CommandLineInterface.run
+  end
+end

data/lib/footballfiltertool/version.rb

@@ -0,0 +1,3 @@
+module Footballfiltertool
+  VERSION = "0.1.0"
+end

data/lib/player.rb

@@ -0,0 +1,137 @@
+require_relative "./data_scraper.rb"
+
+class Player
+  @@allowable_attributes = [
+    "name", 
+    "age", 
+    "position", 
+    "team", 
+    "pass_completions", 
+    "pass_attempts", 
+    "pass_completion_percentage",
+    "pass_touchdowns",
+    "interceptions_thrown",
+    "pass_yards",
+    "yards_per_pass_attempt",
+    "carries",
+    "rush_yards",
+    "rush_yards_per_attempt",
+    "rush_touchdowns",
+    "receptions",
+    "receiving_yards",
+    "receiving_yards_per_catch",
+    "receiving_touchdowns",
+    "sacks",
+    "interceptions_caught",
+    "passes_defended",
+    "tackles",
+    "tackles_for_loss",
+    "quarterback_hits",
+  ]
+
+  @@allowable_attributes.each do |attribute|
+    attr_accessor attribute.to_sym
+  end
+
+  def self.allowable_attributes
+    @@allowable_attributes
+  end
+
+  def has_attribute?(attribute)
+    self.class.allowable_attributes.include?(attribute)
+  end
+
+  @@all = []
+
+  def initialize(data_hash)
+    data_hash.each {|key, value| self.send(("#{key}="), value)}
+    @@all.push(self)
+  end
+
+  def self.all
+    return @@all
+  end
+
+  def self.delete_all 
+    all.clear 
+  end
+
+  def self.find_by_name (name) #returns array of results if multipe are found
+    out = nil
+    all.select do |player|
+      player.name == name 
+    end
+    if(out == nil)
+      out_data =  {
+        :type => "No Results",
+        :data => nil
+      } 
+    elsif(out.size == 1)
+      out_data = {
+        :type => "Unique Result",
+        :data => out[0]
+      }
+    elsif(out.size > 1)
+      out_data = {
+        :type => "Multiple Results",
+        :data => out
+      }
+    end
+    out_data
+  end
+
+  def self.find(name, team)
+    out = nil
+    all.each do |player|
+      if(player.name == name && player.team == team)
+        out = player
+      end 
+    end
+    return out
+
+  end
+
+  
+
+  def self.create_or_update(data_hash)
+    name = data_hash[:name]
+    team = data_hash[:team]
+    find_player = Player.find(name, team)
+    if(find_player == nil)
+      find_player = Player.new(data_hash)
+    else 
+      data_hash.each do |key, value| 
+        current_value = find_player.instance_variable_get("@#{key}")
+        if(current_value == 0 || current_value = "" || current_value == nil || current_value == 0.0)#ensures not overiding good data
+          find_player.send(("#{key}="), value)
+        end
+      end
+    end
+    return find_player
+  end
+
+  def self.display_all
+    all.each do|player| 
+      if(player.team = "SEA")
+        puts "#{player.name}, #{player.position}, #{player.team}" 
+      end
+    end
+  end
+
+  def self.import(year)
+    url_passing = "https://www.pro-football-reference.com/years/#{year}/passing.htm"
+    url_rushing = "https://www.pro-football-reference.com/years/#{year}/rushing.htm"
+    url_receiving = "https://www.pro-football-reference.com/years/#{year}/receiving.htm"
+    url_defense = "https://www.pro-football-reference.com/years/#{year}/defense.htm"
+
+    data_passing = DataScraper.scrape_data(url_passing, "passing")
+    data_rushing = DataScraper.scrape_data(url_rushing, "rushing")
+    data_receiving = DataScraper.scrape_data(url_receiving, "receiving")
+    data_defense = DataScraper.scrape_data(url_defense, "defense")
+
+    data_passing.each{|entry| Player.create_or_update(entry)}
+    data_rushing.each{|entry| Player.create_or_update(entry)}
+    data_receiving.each{|entry| Player.create_or_update(entry)}
+    data_defense.each{|entry| Player.create_or_update(entry)}
+  end
+end

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: footballfiltertool
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Michael Fuget
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-12-31 00:00:00.000000000 Z
+dependencies: []
+description: Pulls stats from the current football season and generates filtered and
+  sorted lists basaed on user input
+email:
+- michaelfuget@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/console
+- bin/main
+- bin/setup
+- lib/command_line_interface.rb
+- lib/data_scraper.rb
+- lib/footballfiltertool.rb
+- lib/footballfiltertool/version.rb
+- lib/player.rb
+homepage: https://github.com/mkfuget
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org/
+  homepage_uri: https://github.com/mkfuget
+  source_code_uri: https://github.com/mkfuget
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Football Stats filter tool 1.0
+test_files: []