pushover 3.0.3 → 4.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1462e57e5e54fdde38e0ffd646012e186505e391ab4a6e806a05e20daf00fd4c
-  data.tar.gz: 6d932f6727563a8329f14fe3c8a7a5d7039fb325f8320e3e6d2586107e7a6073
+  metadata.gz: 7a19291da36f95fd19954df7a7b93aa1d4b78cb8708702fe4c8ebafb6d14a4c8
+  data.tar.gz: b416babb1ae31c5d7e2fe51707785c4bd87c6dfead296568dd378155ac852a82
 SHA512:
-  metadata.gz: 4c215eaa108f2b43ece3568b6149c901d0e643d33c31a05703125b1982a09dd6c7be26fce91a7096a7d99ce65ee8e41d08bdd426fbd2aab3030a4982c80f4783
-  data.tar.gz: e3ee589d7db9836f53246740d43fb9a3be22bc3f4908095634991053d7cb34bad02bfa9e6678c2a928eda3314137364890624b10b4fbb2f8aa2e1666e204a68b
+  metadata.gz: ffbdf22b369588fd862768b8ad4ba7ce285d78b22c50a64334d9668deaadec498d29d8bde17a05de9969875d9773266f9dc68a90e5c470707eca5906dffd8272
+  data.tar.gz: c9aee830ca7abff85081dbda9ba6f912055667607e606e294a6aeaed551f16e574330079dc2362936264904f1cf7209e631ce96f4dbc8eb2d6ea96ed9ca98e7f

data/.github/workflows/ci.yml

@@ -0,0 +1,28 @@
+name: CI
+
+'on':
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+permissions:
+  contents: read
+
+jobs:
+  verify:
+    name: Verify
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v7
+
+      - name: Set up Ruby
+        uses: ruby/setup-ruby@v1
+        with:
+          bundler-cache: true
+
+      - name: Run CI
+        run: bundle exec rake ci

data/.gitignore

@@ -18,3 +18,4 @@ tmp
 spec/test_config
 .rspec
 *.tmp
+CURRENT_WORK.md

data/.rubocop.yml

@@ -1,15 +1,14 @@
-require: rubocop-rspec
+plugins: rubocop-rspec
 
 AllCops:
-  TargetRubyVersion: 2.4.0
+  NewCops: enable
+  TargetRubyVersion: 3.3
   Exclude:
-    - 'vendor/**/*'
     - 'tmp/**/*'
-    - 'spec/spec_helper.rb'
+    - 'vendor/bundle/**/*'
 
 # The defaults for these seem to be based on a rails env, this is not rails.
 Metrics/ModuleLength:
-  CountComments: false
   Max: 250
 
 Metrics/ClassLength:
@@ -27,8 +26,8 @@ Metrics/CyclomaticComplexity:
 Metrics/PerceivedComplexity:
   Max: 10
 
-# it's 2016, people have wide monitors.
-Metrics/LineLength:
+# Line length is intentionally unrestricted.
+Layout/LineLength:
   Enabled: false
 
 Metrics/BlockLength:
@@ -47,7 +46,7 @@ Style/RegexpLiteral:
     - 'Guardfile'
     - '*.gemspec'
 
-# Prefer single-quoted strings when you don't need string interpolation or special symbols
+# String literal quote style is not enforced.
 Style/StringLiterals:
   Enabled: false
 
@@ -59,22 +58,10 @@ Style/FrozenStringLiteralComment:
 
 Style/MixinUsage:
   Exclude:
-  - 'bin/*'
-  - 'exe/*'
+    - 'bin/*'
+    - 'exe/*'
 
-# Specs don't need inline documentation.
-Style/Documentation:
-  Enabled: true
-  Exclude:
-    - 'spec/**/*'
-
-RSpec/NamedSubject:
-  Enabled: false
-
-Lint/Debugger:
-  Enabled: false
-
-# Purty hashes.
-Layout/AlignHash:
+# Align hash pairs as tables.
+Layout/HashAlignment:
   EnforcedHashRocketStyle: table
   EnforcedColonStyle: table

data/.ruby-version

@@ -0,0 +1 @@
+3.3.0

data/CONVENTIONS.md

@@ -0,0 +1,19 @@
+# Project Conventions
+
+## Design
+
+- Prefer modern Ruby patterns over legacy implementation patterns.
+- Preserve released public behavior when practical, but do not preserve obsolete implementation details unless they are explicitly part of the supported contract.
+
+## Ruby runtime
+
+- Run Ruby, Bundler, Rake, RSpec, RuboCop, and other Ruby commands through `/opt/homebrew/bin/rbenv exec`.
+- The Codex shell may resolve `/usr/bin/ruby` (Apple Ruby 2.6) instead of the project's Ruby version.
+- The project runtime is defined by `.ruby-version`.
+
+## HTTP client
+
+- Use Excon for Pushover HTTP requests. Do not introduce another HTTP client without a specific need.
+- Use Excon's request stubs for mocked HTTP tests.
+- Consult the installed Excon documentation or source before assuming library behavior.
+- it has no context 7 documentation, so read the source code for details.

data/Gemfile

@@ -4,7 +4,6 @@ gemspec
 gem 'excon'
 gem 'gli'
 gem 'oj'
-gem 'codecov', :require => false, :group => :test
 
 group :test do
   gem 'bump'
@@ -13,7 +12,7 @@ group :test do
   gem 'rspec'
   gem 'rubocop'
   gem 'rubocop-rspec'
-  gem 'simplecov'
+  gem 'simplecov', '~> 1.0.3'
   gem 'yard'
 end
 

data/Guardfile

@@ -41,8 +41,8 @@ end
 
 unless ENV["DISABLE_YARD"] == 'true'
   guard 'yard' do
-    watch(%r{app\/.+\.rb})
-    watch(%r{lib\/.+\.rb})
-    watch(%r{ext\/.+\.c})
+    watch(%r{app/.+\.rb})
+    watch(%r{lib/.+\.rb})
+    watch(%r{ext/.+\.c})
   end
 end

data/README.md

@@ -1,76 +1,268 @@
 # Pushover
-[![Build Status](https://travis-ci.org/erniebrodeur/pushover.svg?branch=master)](https://travis-ci.org/erniebrodeur/pushover) [![codecov](https://codecov.io/gh/erniebrodeur/pushover/branch/master/graph/badge.svg)](https://codecov.io/gh/erniebrodeur/pushover)
 
-This gem provides a CLI and an API interface to https://pushover.net.
+This gem provides a CLI and a Ruby API for [Pushover](https://pushover.net).
 
 ## Installation
 
-To install:
+Install the gem:
 
-    gem install pushover
+```shell
+gem install pushover
+```
+
+Or add it to your Gemfile and run `bundle install`:
 
-To use inside of an application, add this to the your gemfile:
+```ruby
+gem 'pushover'
+```
 
-    gem 'pushover'
+## Ruby API
 
-and run bundle to make it available:
+Create one client with your application token, then use its API resources:
 
-    bundle
+```ruby
+require 'pushover'
 
+client = Pushover::Client.new(token: 'app-token')
+
+response = client.messages.create(
+  user: 'user-or-group-key',
+  message: 'Deployment completed',
+  title: 'Production'
+)
+```
 
-## Usage
+`messages.create` supports the Pushover Message API's JSON parameters:
 
-For now, not much is supported on the CLI.
+- `user` and `message` are required.
+- `device`, `title`, `url`, `url_title`, `priority`, `sound`, `timestamp`, and `ttl` are optional.
+- `html` and `monospace` accept booleans or `1` and `0`, but cannot both be enabled.
+- Emergency priority (`priority: 2`) requires `retry` and `expire`, and may include `callback` and `tags`.
+- Attachments use `attachment_base64` with `attachment_type`, such as `image/png`, and are limited to 5 MiB after decoding.
 
-Sending a message:
+To encrypt the supported message fields end to end, pass the 64-character hexadecimal key configured on the receiving devices:
 
-    pushover --token=your_app_token --user=user_key message here we go again, on my own.
-    pushover -tyour_app_token -uuser_key message here we go again, on my own.
+```ruby
+response = client.messages.create(
+  user: 'user-or-group-key',
+  message: 'Encrypted message',
+  encryption_key: ENV.fetch('PUSHOVER_ENCRYPTION_KEY')
+)
+```
 
-Getting receipt details:
+Deterministic request errors raise `ArgumentError` before a network request. Pushover API errors, including HTTP 4xx responses, are returned as `Pushover::Response` objects:
 
+```ruby
+response.status     # 0 or 1
+response.request    # Pushover request identifier
+response.errors     # API validation errors, if any
+response.receipt    # emergency message receipt, if any
+response.headers    # response headers, including application limits
+response.attributes # other response fields
+```
 
-    pushover -tyour_app_token receipt receipt-hash
+Retrieve the status of an emergency message receipt through the same client:
 
-Currently unsupported message features:
- - attachments
- - callbacks
- - setting timestamp
+```ruby
+response = client.receipts.get(receipt: 'AbCdEf0123456789GhIjKlMnOpQrSt')
+```
 
+Cancel future retries for an emergency message before it expires:
 
-### Api
+```ruby
+response = client.receipts.cancel(receipt: 'AbCdEf0123456789GhIjKlMnOpQrSt')
+```
 
-``` ruby
-  require 'pushover'
+Cancel future retries for all active emergency messages sent by the application with one tag:
 
-  ### message
-  message = Pushover::Message.new(token: 'token', user: 'user_key', message: '...')
-  message.push
+```ruby
+response = client.receipts.cancel_by_tag(tag: 'l=chicago')
+```
+
+Receipt identifiers must contain exactly 30 alphanumeric characters. Receipt status fields are returned in `response.attributes`, including `acknowledged`, `acknowledged_at`, `acknowledged_by`, `acknowledged_by_device`, `last_delivered_at`, `expired`, `expires_at`, `called_back`, and `called_back_at`.
+
+Cancellation stops future emergency-priority retries. `cancel_by_tag` accepts one nonempty tag and encodes it as a single URL path segment. Pushover permits receipt polling no more often than once every five seconds and retains receipt status for up to one week. The client does not enforce that interval or automatically retry requests. Connection failures continue to raise Excon transport exceptions.
+
+Validate a user or group identifier, optionally for one device:
+
+```ruby
+response = client.users.validate(
+  user: 'uQiRzpo4DXghDmr9QzzfQu27cmVRsG',
+  device: 'droid2'
+)
+```
+
+`user` must be a 30-character alphanumeric user or group identifier. `device` is optional and, when supplied, must be 1 to 25 characters using letters, numbers, underscores, or hyphens. Without a device, Pushover validates that the account has at least one active device. Successful validation returns active device names in `response.attributes['devices']` and licensed platforms in `response.attributes['licenses']`. Invalid or inactive users and devices are returned as Pushover API errors in the response.
+
+Retrieve the sounds available to the application account:
+
+```ruby
+response = client.sounds.get
+available_sounds = response.attributes['sounds']
+```
 
+The sounds hash maps each value accepted by `messages.create(sound: ...)` to its display name. It includes Pushover's built-in sounds and custom sounds uploaded by the account that owns the application token. Omit `sound`, or pass a blank value, to use the recipient's default sound.
 
-  ### Receipt
-  Pushover::Message.new(token: 'token', user: 'user_key', message: '...', 'priority': 2, expire: 1, retry: 60).push
+Retrieve the current monthly message usage limits:
 
-  receipt = Pushover::Receipt.new(receipt: "receipt", token: 'token')
-  receipt.get
+```ruby
+response = client.limits.get
+monthly_limit = response.attributes['limit']
+remaining = response.attributes['remaining']
+reset_at = Time.at(response.attributes['reset'])
+```
+
+`limit` is the account or team's monthly allowance, including purchased capacity. `remaining` is the number of messages left, and `reset` is the Unix timestamp for the next reset. Despite the historical endpoint and header names, these values represent usage shared across all applications owned by the account or team.
+
+Update one or more fields on a user's registered Glances widgets:
+
+```ruby
+response = client.glances.update(
+  user: 'uQiRzpo4DXghDmr9QzzfQu27cmVRsG',
+  title: 'Widgets Sold',
+  text: '30',
+  percent: 75
+)
+```
+
+`title`, `text`, and `subtext` accept up to 100 characters. `count` accepts any integer, including negative values, and `percent` accepts integers from 0 through 100. `device` may restrict the update to one device. At least one data field is required. Omitted data fields retain their previous values; pass an empty string to clear a field, including `count` or `percent`.
+
+Glances updates do not create notifications and may take up to 10 minutes to appear. Pushover recommends at least 20 minutes between Apple Watch updates, and watchOS limits them to 50 per day. The client does not throttle updates.
+
+Create an empty delivery group:
+
+```ruby
+response = client.groups.create(name: 'On-call West')
+group_key = response.attributes['group']
+```
+
+The application token may belong to any application on the account or team that will own the group. Group names must be unique within that account; Pushover validates uniqueness. The returned 30-character group key can be used as the `user` value when sending messages.
+
+List the delivery groups owned by the application token's account or team:
+
+```ruby
+response = client.groups.list
+group_entries = response.attributes['groups']
+```
+
+Each entry contains a `group` key and `name`. Pushover does not document a sort order or pagination contract, so callers should not depend on response ordering.
+
+Retrieve a delivery group's name and memberships:
+
+```ruby
+response = client.groups.get(group: group_key)
+group_name = response.attributes['name']
+members = response.attributes['users']
+```
+
+Each member contains `user`, `device`, `memo`, and `disabled`. A `device` of `nil` represents an unrestricted membership. Team members also include `name` and `email`. Pushover does not document membership ordering or pagination.
+
+Manage group memberships and names:
+
+```ruby
+client.groups.add_user(group: group_key, user: user_key, device: 'iphone', memo: 'Primary on-call')
+client.groups.disable_user(group: group_key, user: user_key, device: 'iphone')
+client.groups.enable_user(group: group_key, user: user_key, device: 'iphone')
+client.groups.remove_user(group: group_key, user: user_key, device: 'iphone')
+client.groups.rename(group: group_key, name: 'Operations')
+```
+
+An added membership may include one device and a memo of up to 200 characters. Omitting `device`, or passing it as blank, creates an all-device membership. For removal, disabling, and enabling, an omitted or blank device affects every membership matching the user key; pass a device to target only that membership. Pushover enforces group-name uniqueness on the owning account or team.
+
+Optionally migrate an existing user key to an application subscription:
+
+```ruby
+response = client.subscriptions.migrate(
+  subscription: 'Forum-f504h08fhlasdfj',
+  user: 'uQiRzpo4DXghDmr9QzzfQu27cmVRsG',
+  device_name: 'droid2',
+  sound: 'pushover'
+)
+subscribed_user_key = response.attributes['subscribed_user_key']
+```
+
+Pushover calls this user-key migration, but it is only needed when voluntarily adopting subscription-managed recipients for previously collected user keys. `subscription` must be a nonempty subscription code, and `user` must be a 30-character alphanumeric user key. `device_name` is optional and follows the standard device-name rules. `sound` may be any string because Pushover supports account-specific custom sounds; a blank sound selects the user's default. Pushover validates live subscriptions, users, devices, and sound availability.
+
+Retrieve the application's available prepaid license credits, or permanently assign one credit:
+
+```ruby
+credits = client.licenses.get.attributes['credits']
+
+response = client.licenses.assign(
+  email: 'person@example.com',
+  os: 'Desktop'
+)
+remaining_credits = response.attributes['credits']
+```
+
+`licenses.assign` requires a valid 30-character `user` key or a nonblank `email`; the gem does not invent an e-mail format beyond that documented requirement. `os` may be blank, `Android`, `iOS`, or `Desktop`. A blank or omitted value assigns the license to the first platform the user registers. Each call assigns one permanent, nonrefundable license. Assignment failures remain structured in `response.errors`, and the client never automatically retries the assignment.
+
+Administer a Pushover for Teams organization with its Team API token:
+
+```ruby
+team = Pushover::Client.new(token: 'team-api-token').teams
+
+response = team.get
+team_name = response.attributes['name']
+members = response.attributes['users']
+```
+
+`client.teams` requires a Team API token, not an Application API Token. The client cannot distinguish the credential types locally, so Pushover returns an API error when the wrong token type is supplied. Team names, users, administrator flags, and nested device details are preserved in `response.attributes`.
+
+Add a team user with only an e-mail address, or include the documented invitation and administration options:
+
+```ruby
+response = team.add_user(
+  email: 'member@example.com',
+  name: 'Team Member',
+  password: '',
+  instant: true,
+  admin: false,
+  group: 'On-call'
+)
+```
+
+`email` must be a nonblank string. `name`, `password`, and `group` are optional strings. A blank or omitted password lets Pushover assign and e-mail a random password. `instant: true` requests a seven-day Instant Login link, and `admin: true` adds the user as an administrator. False flags are omitted. A named Delivery Group is created by Pushover if it does not exist; omitting `group` uses the auto-updating Team Delivery Group.
+
+Revoke an invitation that has not been accepted, or remove a current team user:
+
+```ruby
+team.revoke_invitation(email: 'invitee@example.com')
+team.remove_user(email: 'departing-member@example.com')
+```
+
+Removing a user does not delete their Pushover account, but Pushover removes them from the team's Delivery Groups. Pushover also enforces that at least one administrator remains. Membership, invitation, and group-creation state are validated by Pushover.
+
+### Legacy API compatibility
+
+The former message and receipt interfaces remain available as deprecated compatibility wrappers, with no scheduled removal:
+
+```ruby
+Pushover::Message.new(token: 'app-token', user: 'user-key', message: 'Hello').push
+Pushover::Receipt.new(token: 'app-token', receipt: 'AbCdEf0123456789GhIjKlMnOpQrSt').get
+```
+
+Calling `push` or `get` emits a deprecation warning naming the replacement and delegates to the shared client resources. New code should use `client.messages.create` and `client.receipts.get`. The legacy raw `attachment` keyword remains accepted for constructor compatibility, but non-nil values are rejected because they cannot be safely translated to the supported `attachment_base64` and `attachment_type` interface.
+
+## CLI
+
+Send a message:
+
+```shell
+pushover --token=app-token --user=user-key message here we go again
+pushover -tapp-token -uuser-key message here we go again
+```
 
-  ### Responses
-  response = Pushover::Message.new(token: 'token', user: 'user_key', message: '...').push
+Get receipt details:
 
-  # the below data is populated from the response
-  puts response.status     # return the status of the request, 0 or 1
-  puts response.request    # uuid of the request
-  puts response.errors     # array of errors (if any)
-  puts response.receipt    # receipt (if requested)
-  puts response.headers    # response headers (includes limits)
-  puts response.attributes # any other k/v pair returned from pushover
+```shell
+pushover -tapp-token receipt AbCdEf0123456789GhIjKlMnOpQrSt
 ```
 
 ## Contributing
 
-1. Fork it
-2. Switch to development (`git checkout development`)
-3. Create your feature branch (`git checkout -b my-new-feature`)
-4. Commit your changes (`git commit -am 'Added some feature'`)
-5. Push to the branch (`git push origin my-new-feature`)
-6. Create new Pull Request against `development`
+1. Fork the repository.
+2. Create a feature branch from `main`.
+3. Run `bundle exec rake ci`.
+4. Commit and push your changes.
+5. Open a pull request against `main`.

data/Rakefile

@@ -1,63 +1,13 @@
-require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-require "open-uri"
-### Configurables
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
 
-files = {
-  Gemfile:         'https://gist.githubusercontent.com/erniebrodeur/5a5518f5051210f1828a0712bf623dc8/raw',
-  Rakefile:        'https://gist.githubusercontent.com/erniebrodeur/afc92b72158413aa1f85d8d1facd267a/raw',
-  Rubocop:         'https://gist.githubusercontent.com/erniebrodeur/f7f63996ef1e017aee9bf9d8e680a1df/raw',
-  Tasks:           'https://gist.githubusercontent.com/erniebrodeur/03573fecf4f274101c14f6802abdbe83/raw',
-  BinAdd:          'https://gist.githubusercontent.com/erniebrodeur/a815ee4d8bd9ccc54d91025a5543ebb8/raw',
-  VsCodeFormatter: 'https://gist.githubusercontent.com/erniebrodeur/b24d757c0c625d108019eaceff2234cc/raw'
-}
-
-# spec
 RSpec::Core::RakeTask.new(:spec)
-task default: :spec
-
-# automagical updating
-desc "updates for various bits of the development environment."
-
-namespace :update do
-  desc "update everything (multitasked)"
-  multitask(all: %i[gemfile rakefile rubocop tasks vscode_formatter])
-
-  desc 'Update Gemfile from gist'
-  task :gemfile do
-    grab_file 'Gemfile', files[:Gemfile]
-  end
-
-  desc 'Update Rakefile from gist'
-  task :rakefile do
-    grab_file 'Rakefile', files[:Rakefile]
-  end
-
-  desc 'Update .rubocop.yml from gist'
-  task :rubocop do
-    grab_file '.rubocop.yml', files[:Rubocop]
-  end
-
-  desc 'Update .vscode/tasks.json from gist'
-  task :tasks do
-    mkdir_p '.vscode'
-    grab_file '.vscode/tasks.json', files[:Tasks]
-  end
-
-  desc 'Update vscode_formatter.rb in spec_helper'
-  task :vscode_formatter do
-    mkdir_p 'spec'
-    grab_file 'spec/vscode_formatter.rb', files[:VsCodeFormatter]
-  end
-
-  desc 'Add a new lib and spec file (binary)'
-  task :binadd do
-    mkdir_p 'bin'
-    grab_file 'bin/add', files[:BinAdd]
-  end
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.options = ['--cache-root', 'tmp/rubocop_cache']
 end
 
-def grab_file(filename, uri)
-  File.write filename, OpenURI.open_uri(uri).read
-  puts "Updated #{filename} from: #{uri}"
-end
+desc 'Run all continuous integration checks'
+task ci: %i[spec rubocop]
+
+task default: :ci

data/exe/pushover

@@ -4,7 +4,7 @@ require 'pushover'
 
 include GLI::App
 
-program_desc 'A simple todo list'
+program_desc 'Send Pushover messages and retrieve receipts'
 subcommand_option_handling :normal
 
 flag %i[t token], type: String, desc: 'Application token'
@@ -21,16 +21,17 @@ command :message do |c|
   c.flag :expire, type: String, desc: 'how long should a priority message live'
   c.flag :retry, type: String, desc: 'how often should a resend be attempted (until acknowledged)'
   c.action do |global_options, options, args|
-    puts Pushover::Message.new({
-      message: args.join(" "), user: global_options[:user], token: global_options[:token]
-    }.merge(GLI::Options.new(options).to_h.reject { |_k, v| v.nil? })).push
+    params = { message: args.join(" "), user: global_options[:user] }.merge(GLI::Options.new(options).to_h.compact)
+    %i[priority expire retry].each { |key| params[key] = params[key].to_i if params.key?(key) }
+
+    puts Pushover::Client.new(token: global_options[:token]).messages.create(**params)
   end
 end
 
 desc 'get a receipt'
 command :receipt do |c|
   c.action do |global_options, _options, args|
-    puts Pushover::Receipt.new(token: global_options[:token], receipt: args[0]).get
+    puts Pushover::Client.new(token: global_options[:token]).receipts.get(receipt: args[0])
   end
 end
 

data/lib/pushover/client.rb

@@ -0,0 +1,53 @@
+module Pushover
+  # Client holds shared application credentials and exposes API resources.
+  class Client
+    attr_reader :connection, :token
+
+    def initialize(token:, connection: Pushover::Excon)
+      raise ArgumentError, 'token must be supplied' unless token.is_a?(String) && !token.empty?
+
+      @token = token
+      @connection = connection
+    end
+
+    def messages
+      @messages ||= Messages.new(self)
+    end
+
+    def receipts
+      @receipts ||= Receipts.new(self)
+    end
+
+    def users
+      @users ||= Users.new(self)
+    end
+
+    def sounds
+      @sounds ||= Sounds.new(self)
+    end
+
+    def limits
+      @limits ||= Limits.new(self)
+    end
+
+    def glances
+      @glances ||= Glances.new(self)
+    end
+
+    def groups
+      @groups ||= Groups.new(self)
+    end
+
+    def subscriptions
+      @subscriptions ||= Subscriptions.new(self)
+    end
+
+    def licenses
+      @licenses ||= Licenses.new(self)
+    end
+
+    def teams
+      @teams ||= Teams.new(self)
+    end
+  end
+end