folding_at_home_client 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0b5eed2c78d8ff38ba693988b34c4a0858ae2e3816569ad5fdd672a8fed80f12
+  data.tar.gz: f412f9ce32d81ad8008f0241e33bb18a80e991fbb7af3f29c142d80a0053095f
+SHA512:
+  metadata.gz: 0f4a86bcdc2a9ae852fc465c82f7c8c8481b28a84c1b44f59e89eb1bb1200ef3ff2d6d65f49765523b76f68bef9eb4d4f32cac81b79b639f6e6d9210537f4929
+  data.tar.gz: 478940d0851f6de9d5d48ff909e5dd7c11c0f7e3f923c713d39dd0c3e17ba7fe3c7c6f7c390e3645113b4fb631dcb9cc37541dbfe55e3e6347113e12d8f9fd66

data/.rspec

@@ -0,0 +1,3 @@
+--format documentation
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,42 @@
+# Docs: https://docs.rubocop.org/rubocop/configuration
+
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.1
+
+Layout/ArgumentAlignment:
+  EnforcedStyle: 'with_fixed_indentation'
+  Enabled: true
+
+Metrics/MethodLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/ParameterLists:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/HashConversion:
+  Enabled: false
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: 'consistent_comma'
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: 'consistent_comma'

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Blake Gearin
+
+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,237 @@
+# folding_at_home_client
+
+Ruby client for the [Folding@home API](https://api.foldingathome.org)
+
+Need more historical data? Try out [`extreme_overclocking_client`](https://github.com/blakegearin/folding_at_home_client)
+
+## Getting Started
+
+Install and add to Gemfile:
+
+```bash
+bundle add folding_at_home_client
+```
+
+Install without bundler:
+
+```bash
+gem install folding_at_home_client
+```
+
+## Usage
+
+- [Users](#users)
+- [User](#user)
+- [Teams](#teams)
+- [Team](#team)
+- [Projects](#projects)
+- [Project](#project)
+- [Descriptions](#descriptions)
+- [Description](#description)
+- [Managers](#managers)
+- [Manager](#manager)
+- [Causes](#causes)
+- [GPUs](#gpus)
+- [GPU](#gpu)
+
+### Users
+
+```ruby
+# Fetch count of users
+FoldingAtHomeClient::Users.count
+
+# Fetch top users of all-time
+FoldingAtHomeClient::Users.top
+
+# Fetch top users from a specific month
+FoldingAtHomeClient::Users.top(month: 1, year: 2018)
+
+# Fetch daily users (unique based on name and team_id, not user id)
+# Caches the TXT file and limits fetching to every 3 hours
+# Optional: filepath, limit, name, order, page, per_page, position, sort_by, team_id
+FoldingAtHomeClient::Users.daily
+FoldingAtHomeClient::Users.daily(sort_by: :name, order: :desc)
+FoldingAtHomeClient::Users.daily(limit: 5)
+FoldingAtHomeClient::Users.daily(page: 1, per_page: 5)
+FoldingAtHomeClient::Users.daily(name: 'Anonymous')
+FoldingAtHomeClient::Users.daily(team_id: 0)
+FoldingAtHomeClient::Users.daily(name: 'Anonymous', team_id: 0)
+FoldingAtHomeClient::Users.daily(position: 10)
+FoldingAtHomeClient::Users.daily(filepath: 'my_daily_user_summary.txt')
+```
+
+### User
+
+```ruby
+id = 2
+name = "name"
+passkey = "passkey"
+team_id = 0
+
+# Create a user
+# Required: id or name
+user = FoldingAtHomeClient::User.new(id: id)
+user = FoldingAtHomeClient::User.new(name: name)
+user = FoldingAtHomeClient::User.new(id: id, name: name)
+
+# Fetch a user's stats, including teams
+# Required: id or name
+# Optional: passkey, team_id
+user = user.find_by(id: id)
+user = user.find_by(name: name)
+user = user.find_by(id: id, name: name)
+user = user.find_by(id: id, passkey: passkey)
+user = user.find_by(id: id, team_id: team_id)
+user = user.find_by(id: id, passkey: passkey, team_id: team_id)
+
+# Fetch a user's list of teams
+# Note: Suffixed with "_lookup" since teams is a class attribute
+# Required: id or name
+# Optional: passkey
+teams = user.teams_lookup
+teams = user.teams_lookup(passkey: passkey)
+
+# Fetch a user's list of contributed projects
+# Required: name
+projects = user.projects
+
+# Fetch a user's bonus stats
+# Required: name
+# Optional: passkey
+bonuses = user.bonuses
+bonuses = user.bonuses(passkey: passkey)
+```
+
+### Teams
+
+```ruby
+# Fetch count of teams
+FoldingAtHomeClient::Teams.count
+
+# Fetch top teams from a specific month
+FoldingAtHomeClient::Teams.top(month: 1, year: 2018)
+```
+
+### Team
+
+```ruby
+id = 1
+
+# Fetch a team
+# Required: id or name
+team = FoldingAtHomeClient::Team.find_by(id: id)
+
+# Fetch a teams's members
+# Required: id
+members = FoldingAtHomeClient::Team.new(id: id).members
+```
+
+### Projects
+
+```ruby
+# Fetch all projects
+FoldingAtHomeClient::Projects.all
+```
+
+### Project
+
+```ruby
+id = 2968
+
+project = FoldingAtHomeClient::Project.new(id: id)
+
+# Fetch a project
+# Required: id
+project = project.lookup
+
+# Fetch a project's contributors
+# Required: id
+contributors = project.contributors
+
+# Fetch a project's description
+# Required: description_id
+description = project.description
+```
+
+### Descriptions
+
+```ruby
+# Fetch all descriptions
+descriptions = FoldingAtHomeClient::Descriptions.all
+```
+
+### Description
+
+```ruby
+id = 195
+
+# Fetch a description
+# Required: id
+description = FoldingAtHomeClient::Description.new(id: id).lookup
+```
+
+### Managers
+
+```ruby
+# Fetch all managers
+managers = FoldingAtHomeClient::Managers.all
+```
+
+### Manager
+
+```ruby
+id = 326
+
+# Fetch a manager
+# Required: id
+manager = FoldingAtHomeClient::Manager.new(id: id).lookup
+```
+
+### Causes
+
+```ruby
+# Fetch all causes
+causes = FoldingAtHomeClient::Causes.all
+```
+
+### GPUs
+
+```ruby
+# Fetch all GPUs
+gpus = FoldingAtHomeClient::GPUs.all
+```
+
+### GPU
+
+```ruby
+vendor = 4318
+device = 5
+
+# Fetch a GPUs
+# Required: device, vendor
+gpu = FoldingAtHomeClient::GPU.find_by(vendor: vendor, device: device)
+```
+
+### Notes
+
+Currently only `GET` endpoints are supported. It's not exhaustive because some endpoints aren't particularly useful in terms of what they return compared to other endpoints.
+
+## 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 the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports, feature requests, and pull requests are welcome.
+
+## Links
+
+- [Folding@home](https://foldingathome.org)
+
+- [Folding@home Download](https://foldingathome.org/start-folding)
+
+- [Folding@home Stats](https://stats.foldingathome.org)
+
+- [EXTREME Overclocking (EOC) Stats](https://folding.extremeoverclocking.com/aggregate_summary.php)

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/folding_at_home_client.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require_relative 'lib/folding_at_home_client/version'
+
+Gem::Specification.new do |spec|
+  spec.name = 'folding_at_home_client'
+  spec.version = FoldingAtHomeClient::VERSION
+
+  spec.authors = ['Blake Gearin']
+  spec.email = 'hello@blakeg.me'
+
+  spec.summary = 'Ruby client for Folding@Home'
+  spec.description = 'Ruby client for Folding@Home'
+  spec.homepage = 'https://github.com/blakegearin/folding_at_home_client'
+  spec.license = 'MIT'
+  spec.required_ruby_version = '>= 3.1.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/blakegearin/folding_at_home_client'
+  spec.metadata['github_repo'] = 'ssh://github.com/blakegearin/folding_at_home_client'
+
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?(*%w[bin/ test/ spec/ features/ .git .circleci appveyor Gemfile])
+    end
+  end
+
+  spec.bindir = 'exe'
+  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'faraday', '~> 2.9'
+  spec.metadata['rubygems_mfa_required'] = 'true'
+end

data/lib/folding_at_home_client/causes.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module FoldingAtHomeClient
+  module Causes
+    extend Request
+
+    def self.all
+      endpoint = '/project/cause'
+
+      request(endpoint:)
+    end
+  end
+end

data/lib/folding_at_home_client/description.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module FoldingAtHomeClient
+  class Description
+    include Request
+
+    attr_reader :id,
+      :manager,
+      :body,
+      :updated_at,
+      :error
+
+    def initialize(
+      id:,
+      description: nil,
+      manager: nil,
+      projects: nil,
+      modified: nil
+    )
+      @id = id
+
+      @body = description if description
+      @manager = manager if manager
+      @projects = projects if projects
+      @updated_at = modified if modified
+    end
+
+    def lookup
+      endpoint = "/project/description/#{id}"
+      description_hash = request(endpoint:).first
+
+      error = description_hash[:error]
+
+      if error
+        @error = error
+        return self
+      end
+
+      @body = description_hash[:description]
+      @manager = description_hash[:manager]
+      @updated_at = description_hash[:modified]
+
+      self
+    end
+  end
+end

data/lib/folding_at_home_client/descriptions.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module FoldingAtHomeClient
+  module Descriptions
+    extend Request
+
+    def self.all
+      endpoint = '/project/description'
+
+      request_and_instantiate_objects(endpoint:, object_class: Description)
+    end
+  end
+end

data/lib/folding_at_home_client/gpu.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module FoldingAtHomeClient
+  class GPU
+    extend Request
+
+    attr_reader :vendor,
+      :device,
+      :type,
+      :species,
+      :description,
+      :error
+
+    def initialize(
+      vendor: nil,
+      device: nil,
+      type: nil,
+      species: nil,
+      description: nil,
+      error: nil
+    )
+      @vendor = vendor
+      @device = device
+      @type = type if type
+      @species = species if species
+      @description = description if description
+
+      @error = error if error
+    end
+
+    def self.find_by(vendor:, device:)
+      endpoint = "/gpus/#{vendor}/#{device}"
+      gpu_hash = request(endpoint:).first
+
+      gpu_hash[:vendor] = vendor
+      gpu_hash[:device] = device
+
+      error = gpu_hash[:error]
+      gpu_hash.delete(:status) if error
+
+      new_gpu = allocate
+      new_gpu.send(:initialize, **gpu_hash)
+
+      new_gpu
+    end
+  end
+end

data/lib/folding_at_home_client/gpus.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module FoldingAtHomeClient
+  module GPUs
+    extend Request
+
+    def self.all
+      endpoint = '/gpus'
+
+      request_and_instantiate_objects(endpoint:, object_class: GPU)
+    end
+  end
+end

data/lib/folding_at_home_client/manager.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module FoldingAtHomeClient
+  class Manager
+    include Request
+
+    attr_reader :id,
+      :name,
+      :description,
+      :thumb,
+      :url,
+      :institution,
+      :error
+
+    def initialize(
+      id: nil,
+      name: nil,
+      description: nil,
+      thumb: nil,
+      url: nil,
+      institution: nil
+    )
+      @id = id if id
+
+      @name = name if name
+      @description = description if description
+      @thumb = thumb if thumb && !thumb.empty?
+      @url = url if url && !url.empty?
+      @institution = institution if institution && !institution.empty?
+    end
+
+    def lookup
+      endpoint = "/project/manager/#{id}"
+      manager_hash = request(endpoint:).first
+
+      error = manager_hash[:error]
+
+      if error
+        @error = error
+        return self
+      end
+
+      @name = manager_hash[:name]
+      @description = manager_hash[:description]
+
+      thumb = manager_hash[:thumb]
+      @thumb = thumb if thumb && !thumb.empty?
+
+      url = manager_hash[:url]
+      @url = url if url && !url.empty?
+
+      institution = manager_hash[:institution]
+      @institution = institution if institution && !institution.empty?
+
+      self
+    end
+  end
+end

data/lib/folding_at_home_client/managers.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module FoldingAtHomeClient
+  module Managers
+    extend Request
+
+    def self.all
+      endpoint = '/project/manager'
+
+      request_and_instantiate_objects(endpoint:, object_class: Manager)
+    end
+  end
+end

data/lib/folding_at_home_client/project.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module FoldingAtHomeClient
+  class Project
+    include Request
+
+    attr_reader :id,
+      :description_id,
+      :manager,
+      :cause,
+      :thumb,
+      :url,
+      :institution,
+      :updated_at,
+      :error
+
+    def initialize(
+      id:,
+      description: nil,
+      manager: nil,
+      cause: nil,
+      modified: nil
+    )
+      @id = id
+
+      @description_id = description if description
+      @manager = Manager.new(name: manager) if manager
+      @cause = cause if cause
+      @updated_at = modified if modified
+    end
+
+    def lookup
+      endpoint = "/project/#{@id}"
+      project_hash = request(endpoint:).first
+
+      error = project_hash[:error]
+
+      if error
+        @error = error
+        return self
+      end
+
+      @body = project_hash[:description]
+      @manager = Manager.new(
+        name: project_hash[:manager],
+        thumb: project_hash[:mthumb],
+        description: project_hash[:mdescription]
+      )
+      @cause = project_hash[:cause]
+      @updated_at = project_hash[:modified]
+
+      self
+    end
+
+    def contributors
+      endpoint = '/project/contributors'
+      params = { projects: @id }
+
+      request(endpoint:, params:).map do |name|
+        User.new(name:)
+      end
+    end
+
+    def description
+      Description.new(id: @description_id).lookup
+    end
+  end
+end

data/lib/folding_at_home_client/projects.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module FoldingAtHomeClient
+  module Projects
+    extend Request
+
+    def self.all
+      endpoint = '/project'
+
+      request_and_instantiate_objects(endpoint:, object_class: Project)
+    end
+  end
+end

data/lib/folding_at_home_client/request.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: false
+
+class DoNotEncoder
+  def self.encode(params)
+    buffer = ''
+
+    params.each do |key, value|
+      buffer << "#{key}=#{value}&"
+    end
+
+    buffer.chop
+  end
+
+  def self.decode(params)
+    Faraday::FlatParamsEncoder.decode(params)
+  end
+end
+
+module FoldingAtHomeClient
+  module Request
+    API_URL = 'https://api.foldingathome.org'.freeze
+    HEADERS = {
+      'Accept' => 'application/json',
+    }.freeze
+
+    def connection(base_url: API_URL)
+      Faraday.new(url: base_url) do |faraday|
+        faraday.request :url_encoded
+        faraday.adapter Faraday.default_adapter
+
+        faraday.options.params_encoder = DoNotEncoder
+      end
+    end
+
+    def format_response(response)
+      parsed_response = JSON.parse(response.body, symbolize_names: true)
+      parsed_response.is_a?(Array) ? parsed_response : [parsed_response]
+    end
+
+    def request_unencoded(endpoint_and_params:, base_url: API_URL, format_response: true)
+      response = connection(base_url:).get(endpoint_and_params)
+
+      return format_response(response) if format_response
+
+      response
+    end
+
+    def request(endpoint:, base_url: API_URL, format_response: true, params: {})
+      full_url = base_url + endpoint
+      response = Faraday.get(full_url, params, HEADERS)
+
+      return format_response(response) if format_response
+
+      response
+    end
+
+    def request_and_instantiate_objects(endpoint:, object_class:, params: {})
+      request(endpoint:, params:).map do |hash|
+        # require 'pry'
+        # binding.pry
+        # puts 'end of pry'
+        object_class.new(**hash)
+      end
+    end
+
+    # def request_and_instantiate_objects(endpoint:, object_class:, params: {})
+    #   request(endpoint:, params:).map do |hash|
+    #     object_class.new(*hash.values_at(*object_class.members))
+    #   end
+    # end
+  end
+end

data/lib/folding_at_home_client/team.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+module FoldingAtHomeClient
+  class Team
+    include Request
+    extend Request
+
+    attr_accessor :id, :name
+    attr_reader :rank,
+      :score,
+      :wus,
+      :founder,
+      :url,
+      :logo,
+      :user_score,
+      :user_wus,
+      :error
+
+    # rubocop:disable Lint/UnusedMethodArgument
+    def initialize(
+      id: nil,
+      team: nil,
+      name: nil,
+      wus: nil,
+      rank: nil,
+      trank: nil,
+      credit: nil,
+      tscore: nil,
+      twus: nil,
+      founder: nil,
+      score: nil,
+      url: nil,
+      logo: nil,
+      last: nil,
+      active_7: nil,
+      active_50: nil,
+      error: nil
+    )
+      @id = id || team.to_i if id || team
+      @name = name if name
+
+      @rank = trank || rank if trank || rank
+
+      @score = tscore || credit if tscore || credit
+      @wus = twus || wus if twus || wus
+
+      @founder = founder if founder
+      @url = url if url
+      @logo = logo if logo
+
+      @user_score = score if !tscore.nil? && score
+      @user_wus = wus if !twus.nil? && wus
+
+      @error = error if error
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+
+    def self.find_by(id: nil, name: nil)
+      team = allocate
+
+      team.id ||= id if id
+      team.name ||= name if name
+
+      endpoint_and_params = '/team'
+
+      if team.id && !team.id.to_s.empty?
+        endpoint_and_params += "/#{team.id}"
+      elsif team.name && !team.name.empty?
+        endpoint_and_params += "/find?name=#{escape_param(team.name)}"
+      else
+        raise ArgumentError, 'Required: id or name of team'
+      end
+
+      team_hash = nil
+
+      begin
+        team_hash = request_unencoded(endpoint_and_params:).first
+        raise StandardError if team_hash[:error]
+      rescue StandardError
+        if team.name
+          query_endpoint_and_params = "/team?q=#{escape_param(team.name)}"
+          query_team_hash = request_unencoded(endpoint_and_params: query_endpoint_and_params).first
+
+          team.id = query_team_hash&.fetch(:id, nil)
+          endpoint = "/#{team.id}"
+
+          team_hash = request(endpoint:).first if team.id
+        end
+      end
+
+      error = team_hash[:error]
+      team_hash.delete(:status) if error
+
+      team.send(:initialize, **team_hash)
+
+      team
+    end
+
+    def members
+      endpoint = "/team/#{@id}/members"
+
+      members_array = request(endpoint:)
+      keys = members_array.shift.map(&:to_sym)
+
+      members_array.map do |member_array|
+        member_hash = Hash[keys.zip(member_array)]
+
+        User.new(**member_hash)
+      end
+    end
+
+    def self.escape_param(name)
+      name.gsub(' ', '%20').gsub('&', '%26').gsub(',', '%2C')
+    end
+  end
+end

data/lib/folding_at_home_client/teams.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module FoldingAtHomeClient
+  module Teams
+    extend Request
+
+    def self.count
+      endpoint = '/team/count'
+
+      request(endpoint:).first
+    end
+
+    def self.top(month: nil, year: nil)
+      endpoint = '/team/monthly'
+      params = {
+        month:,
+        year:,
+      }
+
+      request_and_instantiate_objects(
+        endpoint:,
+        params:,
+        object_class: Team
+      )
+    end
+  end
+end

data/lib/folding_at_home_client/user.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module FoldingAtHomeClient
+  class User
+    include Request
+    extend Request
+
+    attr_accessor :id, :name
+    attr_reader :work_units,
+      :wus_daily,
+      :active7,
+      :active50,
+      :credit,
+      :last,
+      :rank,
+      :score,
+      :teams,
+      :error
+
+    # rubocop:disable Lint/UnusedMethodArgument, Naming/MethodParameterName
+    def initialize(
+      id: nil,
+      name: nil,
+      work_unit: nil,
+      work_units: nil,
+      wu: nil,
+      active7: nil,
+      active50: nil,
+      credit: nil,
+      last: nil,
+      rank: nil,
+      score: nil,
+      team: nil,
+      teams: nil,
+      users: nil,
+      error: nil
+    )
+      @id = id if id
+      @name = name if name
+
+      @work_units = work_units&.to_i || wu&.to_i unless work_units.nil? && wu.nil?
+
+      @active7 = active7 if active7
+      @active50 = active50 if active50
+      @credit = credit if credit
+      @last = last if last
+      @rank = rank if rank
+      @score = score.to_i if score
+
+      teams = [team] if teams.nil? && team
+
+      teams = teams&.map do |team_thing|
+        if team_thing.is_a?(Hash)
+          Team.new(**team_thing) unless team_thing[:score]&.zero?
+        elsif team_thing.is_a?(String)
+          Team.new(id: team_thing.to_i)
+        else
+          team_thing
+        end
+      end&.compact
+
+      @teams = teams if teams
+
+      @error = error if error
+    end
+    # rubocop:enable Lint/UnusedMethodArgument, Naming/MethodParameterName
+
+    def lookup(passkey: nil, team_id: nil)
+      endpoint = user_endpoint(id: @id, name: @name)
+
+      params = {}
+      params[:passkey] = passkey if passkey
+      params[:team] = team_id if team_id
+
+      user_hash = nil
+
+      begin
+        user_hash = request(endpoint:, params:).first
+      rescue JSON::ParserError
+        if @name
+          query_endpoint = '/search/user'
+          query_params = { query: @name }
+
+          query_user_hash = request(endpoint: query_endpoint, params: query_params).first
+          @id = query_user_hash&.fetch(:id, nil)
+          user_hash = request(endpoint: user_endpoint, params:).first if @id
+        end
+      end
+
+      error = user_hash[:error]
+
+      if error
+        @error = error
+        return self
+      end
+
+      @id = user_hash[:id]
+      @name = user_hash[:name]
+
+      @work_units_daily = @work_units if user_hash[:wus] && !@work_units.nil?
+      @work_units = user_hash[:wus]
+
+      @active7 = user_hash[:active7]
+      @active50 = user_hash[:active50]
+      @credit = user_hash[:credit] if user_hash[:credit]
+      @last = user_hash[:last]
+      @rank = user_hash[:rank]
+      @score = user_hash[:score]
+
+      teams = user_hash[:teams]&.map do |team_hash|
+        Team.new(**team_hash) unless team_hash[:score]&.zero?
+      end&.compact
+
+      @teams = teams if teams
+
+      self
+    end
+
+    def self.find_by(id: nil, name: nil, passkey: nil, team_id: nil)
+      user = allocate
+
+      user.id ||= id if id
+      user.name ||= name if name
+
+      endpoint = user_endpoint(id: user.id, name: user.name)
+
+      params = {}
+      params[:passkey] = passkey if passkey
+      params[:team] = team_id if team_id
+
+      user_hash = nil
+
+      begin
+        user_hash = request(endpoint:, params:).first
+      rescue JSON::ParserError
+        if user.name
+          query_endpoint = '/search/user'
+          query_params = { query: user.name }
+
+          query_user_hash = request(endpoint: query_endpoint, params: query_params).first
+          @id = query_user_hash&.fetch(:id, nil)
+          user_hash = request(endpoint: user_endpoint, params:).first if @id
+        end
+      end
+
+      error = user_hash[:error]
+
+      if error
+        user_hash.delete(:status)
+
+        user.send(:initialize, **user_hash)
+        return user
+      end
+
+      @id = user_hash[:id]
+      @name = user_hash[:name]
+      @work_units = user_hash[:wus]
+      @active7 = user_hash[:active7]
+      @active50 = user_hash[:active50]
+      @credit = user_hash[:credit]
+      @last = user_hash[:last]
+      @rank = user_hash[:rank]
+      @score = user_hash[:score]
+
+      teams = user_hash[:teams]&.map do |team_hash|
+        Team.new(**team_hash) unless team_hash[:score]&.zero?
+      end&.compact
+
+      user_hash[:teams] = teams if teams
+
+      user.send(:initialize, **user_hash)
+
+      user
+    end
+
+    def teams_lookup(passkey: nil)
+      endpoint = user_endpoint(name_required: true)
+      endpoint += '/teams'
+
+      params = {}
+      params[:passkey] = passkey if passkey
+
+      request_and_instantiate_objects(
+        endpoint:,
+        params:,
+        object_class: Team
+      )
+    end
+
+    def projects
+      endpoint = user_endpoint(name_required: true)
+      endpoint += '/projects'
+
+      request(endpoint:)
+    end
+
+    def bonuses(passkey: nil)
+      raise ArgumentError, 'Required: name of user' unless @name
+
+      endpoint = '/bonus'
+      params = {
+        user: @name,
+      }
+      params[:passkey] = passkey if passkey
+
+      request(endpoint:, params:)
+    end
+
+    class << self
+      private
+
+      def user_endpoint(id: nil, name: nil)
+        if id && !id.to_s.empty?
+          "/uid/#{id}"
+        elsif name && !name.empty?
+          "/user/#{CGI.escape(name)}"
+        elsif name_required
+          raise ArgumentError, 'Required: name of user'
+        else
+          raise ArgumentError, 'Required: id or name of user'
+        end
+      end
+    end
+
+    private
+
+    # def user_endpoint(name_required: false)
+    #   if @id && !@id.to_s.empty? && !name_required
+    #     "/uid/#{@id}"
+    #   elsif @name && !@name.empty?
+    #     "/user/#{CGI.escape(@name)}"
+    #   elsif name_required
+    #     raise ArgumentError, 'Required: name of user'
+    #   else
+    #     raise ArgumentError, 'Required: id or name of user'
+    #   end
+    # end
+
+    def user_endpoint(id: @id, name: @name, name_required: false)
+      if id && !id.to_s.empty? && !name_required
+        "/uid/#{id}"
+      elsif name && !name.empty?
+        "/user/#{CGI.escape(name)}"
+      elsif name_required
+        raise ArgumentError, 'Required: name of user'
+      else
+        raise ArgumentError, 'Required: id or name of user'
+      end
+    end
+  end
+end

data/lib/folding_at_home_client/users.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'open-uri'
+
+module FoldingAtHomeClient
+  module Users
+    extend Request
+
+    DAILY_FILE = 'daily_user_summary.txt'
+
+    def self.count
+      endpoint = '/user-count'
+
+      request(endpoint:).first
+    end
+
+    def self.top(month: nil, year: nil)
+      endpoint = '/user'
+      params = {}
+
+      if month && year
+        endpoint += '/monthly'
+        params = {
+          month:,
+          year:,
+        }
+      end
+
+      request_and_instantiate_objects(
+        endpoint:,
+        params:,
+        object_class: User
+      )
+    end
+
+    def self.update_daily_file(filepath: DAILY_FILE, force: false)
+      last_timestamp = File.open(filepath, &:readline).chomp
+      time_difference_in_hours = (Time.now.utc - Time.parse(last_timestamp)) / 3600
+
+      return unless time_difference_in_hours >= 3.0 || force
+
+      IO.copy_stream(
+        URI.open('https://apps.foldingathome.org/daily_user_summary.txt'),
+        filepath
+      )
+    end
+
+    def self.daily(params = {})
+      filepath = params[:filepath] || DAILY_FILE
+      update_daily_file(filepath:)
+
+      header_lines = 2
+
+      position = params[:position]&.to_i || false
+
+      unless position
+        page = params[:page]&.to_i
+        per_page = params[:per_page]&.to_i
+        paginating = !page.nil? && !per_page.nil?
+
+        skip_line_index = paginating ? ((page - 1) * per_page) : false
+
+        unless paginating
+          limit = params[:limit]&.to_i || 10
+
+          name = params[:name] || false
+          team_id = params[:team_id]&.to_i || false
+        end
+      end
+
+      keys = []
+      users = []
+
+      File.foreach(filepath).each_with_index do |line, index|
+        next if index.zero?
+
+        line_array = line_to_array(line)
+
+        if index == 1
+          keys = line_array.map(&:to_sym)
+          next
+        elsif paginating && (index < (skip_line_index + header_lines))
+          next
+        end
+
+        user_hash = Hash[keys.zip(line_array)]
+
+        if position
+          next unless (position + header_lines) == index
+
+          return User.new(**user_hash)
+        elsif name || team_id
+          name_match = name ? name == user_hash[:name] : true
+          team_match = team_id ? team_id == user_hash[:team].to_i : true
+
+          users.push(User.new(**user_hash)) if name_match && team_match
+        else
+          users.push(User.new(**user_hash))
+
+          break if paginating && users.length >= per_page
+        end
+
+        break if users.length >= limit
+      end
+
+      sort_by = params[:sort_by] || false
+      users.sort_by! { |user| user.send(sort_by) } if sort_by
+
+      order = params[:order] || false
+      users.reverse! if order && order.to_s.downcase == 'desc'
+
+      users
+    end
+
+    def self.line_to_array(line)
+      line.chomp.split("\t")
+    end
+  end
+end

data/lib/folding_at_home_client/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module FoldingAtHomeClient
+  VERSION = '0.1.0'
+end

data/lib/folding_at_home_client.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative 'folding_at_home_client/version'
+
+require 'faraday'
+require 'json'
+
+# Helper
+require_relative 'folding_at_home_client/request'
+
+# Classes
+require_relative 'folding_at_home_client/causes'
+require_relative 'folding_at_home_client/description'
+require_relative 'folding_at_home_client/gpu'
+require_relative 'folding_at_home_client/manager'
+require_relative 'folding_at_home_client/project'
+require_relative 'folding_at_home_client/team'
+require_relative 'folding_at_home_client/user'
+
+# Modules
+require_relative 'folding_at_home_client/descriptions'
+require_relative 'folding_at_home_client/gpus'
+require_relative 'folding_at_home_client/managers'
+require_relative 'folding_at_home_client/projects'
+require_relative 'folding_at_home_client/teams'
+require_relative 'folding_at_home_client/users'

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: folding_at_home_client
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Blake Gearin
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2024-08-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.9'
+description: Ruby client for Folding@Home
+email: hello@blakeg.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rspec"
+- ".rubocop.yml"
+- LICENSE
+- README.md
+- Rakefile
+- folding_at_home_client.gemspec
+- lib/folding_at_home_client.rb
+- lib/folding_at_home_client/causes.rb
+- lib/folding_at_home_client/description.rb
+- lib/folding_at_home_client/descriptions.rb
+- lib/folding_at_home_client/gpu.rb
+- lib/folding_at_home_client/gpus.rb
+- lib/folding_at_home_client/manager.rb
+- lib/folding_at_home_client/managers.rb
+- lib/folding_at_home_client/project.rb
+- lib/folding_at_home_client/projects.rb
+- lib/folding_at_home_client/request.rb
+- lib/folding_at_home_client/team.rb
+- lib/folding_at_home_client/teams.rb
+- lib/folding_at_home_client/user.rb
+- lib/folding_at_home_client/users.rb
+- lib/folding_at_home_client/version.rb
+homepage: https://github.com/blakegearin/folding_at_home_client
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/blakegearin/folding_at_home_client
+  source_code_uri: https://github.com/blakegearin/folding_at_home_client
+  github_repo: ssh://github.com/blakegearin/folding_at_home_client
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.26
+signing_key:
+specification_version: 4
+summary: Ruby client for Folding@Home
+test_files: []