calendlyr 0.7.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d69cdfb2373e6ecbed4936f15670331a83b20816bd77e9aec6c166e43d47cde3
-  data.tar.gz: ebe3df79b6d23e1e6539d63c0bf447396aa80037304f765b04414cf4e862a745
+  metadata.gz: ca7216a6bc050ebad873636af0bb988c8841d7828fe6cebc0a0497947c0a9dc7
+  data.tar.gz: e36f58a64ad9277fdd38bb44fe69aeb4e7d84fe10fb6b9274a474bb609406340
 SHA512:
-  metadata.gz: a3c733ada27c62a49fd5f2644ae2d0e6861c4c5e50b287b0e4173d7873a5e7f2cb83c37c3cde5509551bdea6c13b2d1c6469922c5a632076423c6f5aa8d26199
-  data.tar.gz: b6554a78bffea8609e5871f1c16e617997bcba34e2c348b285e1b5d27140a22009d91674dece47e37513fe6e7155c035654a49abd7713e211c0a64881e29b44c
+  metadata.gz: 36c382f6725f7fdc22acfd11bee564dbcd5c448df265f49d07c450e074ab23c3a1f165970e4f5f925feebbcfbd7f3dae827ecc144a5ca0fb0c0524f9dcaa2d3c
+  data.tar.gz: 2e60e92afb872bb9590cda26e3208ed1bed7f069ea644a55738c5c6284447241c0c90358ff2a19d1e3c1149a790db2e69648c8ed945cd9ed6e4a9ed36526d575

data/.github/workflows/ci.yml

@@ -11,7 +11,7 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        ruby: ["2.7", "3.0", "3.2", "3.3"]
+        ruby: ["3.2", "3.3", "3.4", "4.0"]
 
     steps:
       - uses: actions/checkout@v4
@@ -27,7 +27,11 @@ jobs:
         run: bundle exec standardrb
 
       - name: Run tests
-        run: |
-          bundle exec rake test
-        env:
-          CODECOV_TOKEN: ${{secrets.CODECOV_TOKEN}}
+        run: bundle exec rake test
+
+      - name: Upload coverage
+        if: matrix.ruby == '3.4'
+        uses: codecov/codecov-action@v4
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
+          files: coverage/.resultset.json

data/.gitignore

@@ -22,4 +22,6 @@ tmp
 mkmf.log
 vendor
 .idea/
-bin/my_console
+bin/my_console
+.atl/*
+.DS_Store

data/CHANGELOG.md

@@ -2,6 +2,104 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.0.0]
+
+### Added
+* Auto-pagination via `Enumerator::Lazy` — `collection.auto_paginate` returns a lazy enumerator that traverses all pages on demand without pre-fetching. Compose with `.take(n)`, `.select { }`, `.map { }`, etc.
+* `#next_page` method on `Collection` — returns the next page as a new `Collection`, or `nil` when there are no more pages.
+* `#next_page_url` attr_reader on `Collection` — exposes the raw next-page URL string.
+* `list_all` convenience methods on every resource with list endpoints:
+  - `client.events.list_all`, `client.events.list_all_invitees`
+  - `client.event_types.list_all`, `client.event_types.list_all_availability_schedules`, `client.event_types.list_all_memberships`
+  - `client.organizations.list_all_memberships`, `client.organizations.list_all_invitations`, `client.organizations.list_all_activity_log`
+  - `client.groups.list_all`, `client.groups.list_all_relationships`
+  - `client.availability.list_all_user_busy_times`, `client.availability.list_all_user_schedules`
+  - `client.routing_forms.list_all`, `client.routing_forms.list_all_submissions`
+  - `client.webhooks.list_all`
+  - `client.locations.list_all`
+  - `client.outgoing_communications.list_all`
+* `GET /event_type_available_times` — `client.event_types.list_available_times(event_type:, start_time:, end_time:)` returns a `Collection` of `EventTypes::AvailableTime` objects. No pagination (not supported by this endpoint).
+* `GET /event_type_memberships` — `client.event_types.list_memberships(event_type:)` and `list_all_memberships`. Returns `EventTypes::Membership` objects.
+* `POST /scheduling_links` — `client.scheduling_links.create(owner:, owner_type:, max_event_count:)` returns a `SchedulingLink` object. Bare UUID expansion for `owner`.
+* `GET /organizations/{uuid}` — `client.organizations.retrieve(uuid:)` returns an `Organization` object.
+* `GET /outgoing_communications` — `client.outgoing_communications.list(organization:)` and `list_all`. Returns `OutgoingCommunication` objects.
+* `GET /sample_webhook_data` — `client.webhooks.sample(event:, organization:, scope:)` returns the raw response hash (shape varies by event type).
+
+### Changed — Breaking
+* **`Collection#next_page`** (attr_reader returning the raw URL string) is now **`Collection#next_page_url`**. If you were reading the raw next-page URL via `collection.next_page`, change to `collection.next_page_url`.
+* **`Collection#next_page`** is now a **method** that returns the next `Collection` object (or `nil`), not the raw URL string.
+
+### Notes
+* Version 1.0.0 signals complete Calendly API v2 coverage. All documented endpoints are now implemented.
+* Changes originally prepared for an unreleased `0.11.0` were shipped as part of `1.0.0`.
+
+[1.0.0]: https://github.com/araluce/calendlyr/compare/v0.10.0...v1.0.0
+
+## [0.10.0]
+
+### Added
+* `Calendlyr::Webhook.verify!`, `valid?`, and `parse` — verify signed webhook payloads with HMAC-SHA256, optional timestamp tolerance, and typed payload parsing
+* `Calendlyr.configure`, `Calendlyr.configuration`, `Calendlyr.client`, and `Calendlyr.reset!` — module-level global configuration and default client support with token/timeout settings
+* Optional request/response logging via `Client.new(logger:)` or `Calendlyr.configure { |c| c.logger = ... }` — INFO for method/URL/status/duration, DEBUG for response body (truncated), WARN for retries, ERROR for API errors. Authorization header is never logged.
+* `Object#to_json` — Serialize any API object to JSON. Works with `JSON.generate`, nested objects, and arrays. The internal `client` reference is automatically excluded from serialization.
+* `client.data_compliance.delete_scheduled_event_data` — Remove scheduled events data within a time range (`POST /data_compliance/deletion/events`)
+* `put_request` support in `Resource` base class for PUT HTTP verb
+* `Collection` now includes `Enumerable` — use `each`, `map`, `select` directly on collections
+* Configurable HTTP timeouts via `Client.new(token:, open_timeout:, read_timeout:)` (default 30s)
+* Automatic retry with exponential backoff for 429 Too Many Requests (max 3 retries, respects `Retry-After` header)
+
+### Changed — Breaking
+* **`Calendlyr::Object`** no longer inherits from `OpenStruct`. Replaced with a zero-dependency hash-backed class. Dynamic dot-access for all API fields is preserved. If you were relying on `OpenStruct`-specific methods (e.g., `marshal_dump`), this is a breaking change.
+* Empty API responses (e.g., DELETE) now return `{}` instead of `true`
+* Requires Ruby >= 3.2.0 (dropped support for Ruby 2.4–3.1)
+
+### Fixed
+* Error messages now include request context (`GET /path`) and expose structured attributes on `Calendlyr::Error` (`status`, `http_method`, `path`, `response_body`) for easier debugging
+* **Security:** Removed `OpenSSL::SSL::VERIFY_NONE` — SSL connections now properly verify certificates
+* **Security:** Bare `rescue` replaced with `rescue JSON::ParserError` — non-JSON errors are no longer silently swallowed
+* `Invitee#cancel` now correctly uses the event UUID instead of the invitee UUID
+* `CGI.parse` replaced with `URI.decode_www_form` for Ruby 4.0 compatibility
+* Tautological test assertions (`assert` with string literal) replaced with `assert_equal`
+
+### Removed
+* `codecov` gem dependency (deprecated since Feb 2022, incompatible with Ruby 4.0). Coverage uploads now use `codecov-action` in CI.
+
+[0.10.0]: https://github.com/araluce/calendlyr/compare/v0.9.0...v0.10.0
+
+## [0.9.0]
+
+### Added
+* `client.event_types.create` — Create standard event types (`POST /event_types`)
+* `client.event_types.update` — Update existing event types (`PATCH /event_types/:uuid`)
+* `client.event_types.list_availability_schedules` — List availability schedules for an event type (`GET /event_type_availability_schedules`)
+* `client.event_types.update_availability_schedule` — Update availability schedules (`PATCH /event_type_availability_schedules`)
+* `client.locations.list` — List host's connected locations: Zoom, Google Meet, etc. (`GET /locations`)
+* `client.events.create_invitee` — Programmatically book events via the Scheduling API (`POST /invitees`)
+* `patch_request` support in `Resource` base class for PATCH HTTP verb
+
+### Changed
+* Updated `Event` fixtures with `buffered_start_time`, `buffered_end_time`, `meeting_notes_plain`, `meeting_notes_html`, and `cancellation` fields
+* Updated `Invitee` fixtures with `no_show`, `reconfirmation`, `scheduling_method`, and `invitee_scheduled_by` fields
+
+### Removed — Breaking
+* **`client.outgoing_communications`** — `OutgoingCommunicationsResource` removed (endpoint no longer in Calendly API docs)
+* **`client.scheduling_links`** — `SchedulingLinksResource` and `SchedulingLink` object removed (endpoint no longer in Calendly API docs)
+* **`client.webhooks.sample_webhook_data`** — Method removed (endpoint no longer in Calendly API docs)
+* **`client.event_types.list_available_times`** — Method and `EventTypes::AvailableTime` object removed (endpoint no longer in Calendly API docs)
+* **`client.event_types.list_memberships`** — Method and `EventTypes::Membership` object removed (endpoint no longer in Calendly API docs)
+* **`EventType#available_times`** — Convenience method removed (delegates to removed `list_available_times`)
+* **`Share#associated_scheduling_links`** — Method removed (depends on removed `SchedulingLink`)
+* **`Organization#sample_webhook_data`** — Convenience method removed (delegates to removed `webhooks.sample_webhook_data`)
+
+[0.9.0]: https://github.com/araluce/calendlyr/compare/v0.8.0...v0.9.0
+
+## [0.8.0]
+* **Breaking:** All error classes (`BadRequest`, `NotFound`, `Unauthenticated`, `PermissionDenied`, `ExternalCalendarError`, `TooManyRequests`, `InternalServerError`) now inherit from `Calendlyr::Error` instead of `StandardError`. Code using `rescue Calendlyr::Error` will now catch all API errors.
+* Fix: Response handling with empty body
+* Fix: Some doc typos
+
+[0.8.0]: https://github.com/araluce/calendlyr/compare/v0.7.5...v0.8.0
+
 ## [0.7.5]
 * Fix: Calendlyr::TooManyRequests was not included in autoloading list
 * Fix: Calendlyr::ExternalCalendarError typo in class name

data/README.md

@@ -1,103 +1,239 @@
-[![](https://img.shields.io/github/license/araluce/calendlyr?kill_cache=1)](https://github.com/araluce/calendlyr/blob/master/LICENSE.txt)
-[![](https://github.com/araluce/calendlyr/actions/workflows/ci.yml/badge.svg?kill_cache=1)](https://github.com/araluce/calendlyr/actions)
-[![codecov](https://codecov.io/gh/araluce/calendlyr/branch/master/graph/badge.svg?token=YSUU4PHM6Y&kill_cache=1)](https://codecov.io/gh/araluce/calendlyr)
-![Gem Downloads (for specified version)](https://img.shields.io/gem/dt/calendlyr)
+[![](https://img.shields.io/github/license/araluce/calendlyr)](https://github.com/araluce/calendlyr/blob/master/LICENSE.txt)
+[![](https://github.com/araluce/calendlyr/actions/workflows/ci.yml/badge.svg)](https://github.com/araluce/calendlyr/actions)
+[![codecov](https://codecov.io/gh/araluce/calendlyr/branch/master/graph/badge.svg?token=YSUU4PHM6Y)](https://codecov.io/gh/araluce/calendlyr)
+![Gem Downloads](https://img.shields.io/gem/dt/calendlyr)
 
-# Calendly API Rubygem
+# Calendlyr
 
-Easy and comprehensive rubygem for [Calendly](https://calendly.com/). Currently supports [API v2](https://calendly.stoplight.io/docs/api-docs).
+![Calendlyr logo](logos/calendlyr_bg_white.png)
 
-You just need a Personal Access Token.
+The simplest way to interact with [Calendly's API v2](https://developer.calendly.com/api-docs) in Ruby. No runtime dependencies, no ceremony — just a Personal Access Token and you're good to go.
 
-## Dependencies
+## Installation
 
-No dependencies :tada:
+Calendlyr requires **Ruby >= 3.2.0**.
 
-We understand the importance of not adding unwanted dependencies.
+Add to your Gemfile:
 
-## 📚 Docs
+```ruby
+gem "calendlyr"
+```
 
-### Installation
+Then run `bundle install`. That's it.
 
-Add this line to your application's Gemfile:
+## Quick Start
 
 ```ruby
-gem 'calendlyr', '0.7.5'
+client = Calendlyr::Client.new(token: ENV["CALENDLY_TOKEN"])
+
+# List your scheduled events — just pass the UUID, no full URI needed
+events = client.events.list(user: "YOUR_USER_UUID")
+events.data
+#=> [#<Calendlyr::Event>, #<Calendlyr::Event>, ...]
+
+# Access event details naturally
+event = events.data.first
+event.name       #=> "30 Minute Meeting"
+event.status      #=> "active"
+event.start_time  #=> "2024-01-15T10:00:00.000000Z"
+
+# List invitees for an event
+invitees = client.events.list_invitees(uuid: event.uuid)
+invitees.data.first.email  #=> "john@example.com"
 ```
 
-And then execute:
+## Global configuration
 
-    $ bundle
+For single-tenant apps, you can configure `Calendlyr` once and reuse a default client:
 
-Or install it yourself as:
+```ruby
+Calendlyr.configure do |config|
+  config.token = ENV.fetch("CALENDLY_TOKEN")
+  config.open_timeout = 5
+  config.read_timeout = 15
+end
+
+client = Calendlyr.client
+events = client.events.list(user: "YOUR_USER_UUID")
+```
 
-    $ gem install calendlyr
+`Calendlyr.client` memoizes a client instance and rebuilds it if token or timeout values change.
 
-### Usage
+### Optional request/response logging
 
-To access the API, you'll need to create a `Calendlyr::Client` and provide your token. You can generate your Personal Access Token at [https://calendly.com/integrations/api_webhooks](https://calendly.com/integrations/api_webhooks)
+Calendlyr can emit request lifecycle logs with any logger-like object that responds to `info`, `debug`, `warn`, and `error`. Logging is opt-in, and the gem does not ship a logger implementation for you.
 
 ```ruby
-client = Calendlyr::Client.new(token: ENV["CALENDLY_TOKEN"])
+require "logger"
+
+client = Calendlyr::Client.new(token: ENV["CALENDLY_TOKEN"], logger: Logger.new($stdout))
 ```
 
-The client then provides access to all of the resources.
-
-### Resources
-
-The gem is designed to closely mirror the Calendly API, making it easy to convert API examples into gem code
-
-Responses are created as objects, like `Calendlyr::Event`. Having types like `Calendlyr::User` is useful for understanding the type of object you're working with. These objects are built using `OpenStruct`, allowing you to access data in a Ruby-like way.
-
-* [Pagination](docs/resources/pagination.md)
-* **Activity Log**
-    * [Calendlyr::ActivityLog](docs/resources/activity_log/list_activity_log_entries.md)
-* **Availabilities**
-    * [Calendlyr::Availabilities::Rule](docs/resources/availabilities/availability_rule.md)
-    * [Calendlyr::Availabilities::UserSchedule](docs/resources/availabilities/user_availability_schedule.md)
-    * [Calendlyr::Availabilities::UserBusyTime](docs/resources/availabilities/user_busy_time.md)
-* [Data Compliance](docs/resources/data_compliance.md)
-* **Event Types**
-    * [Calendlyr::EventType](docs/resources/event_types/event_type.md)
-    * [Calendlyr::EventTypes::AvailableTime](docs/resources/event_types/available_time.md)
-    * [Calendlyr::EventTypes::Membership](docs/resources/event_types/membership.md)
-    * [Calendlyr::EventTypes::Profile](docs/resources/event_types/profile.md)
-* **Groups**
-    * [Calendlyr::Group](docs/resources/groups/group.md)
-    * [Calendlyr::Groups::Relationship](docs/resources/groups/relationship.md)
-* **Organizations**
-    * [Calendlyr::Organization](docs/resources/organizations/organization.md)
-    * [Calendlyr::Organizations::Invitation](docs/resources/organizations/invitation.md)
-    * [Calendlyr::Organizations::Membership](docs/resources/organizations/membership.md)
-* **Routing Forms**
-    * [Calendlyr::RoutingForm](docs/resources/routing_forms/routing_form.md)
-    * [Calendlyr::RoutingForms::Submission](docs/resources/routing_forms/submission.md)
-* **Schedule Events**
-    * [Calendlyr::Event](docs/resources/events/event.md)
-    * [Calendlyr::Events::Cancellation](docs/resources/events/cancellation.md)
-    * [Calendlyr::Events::Guest](docs/resources/events/guest.md)
-    * [Calendlyr::Events::Invitee](docs/resources/events/invitee.md)
-    * [Calendlyr::Events::InviteeNoShow](docs/resources/events/invitee_no_show.md)
-* [Scheduled Links](docs/resources/scheduling_link.md)
-* [Shares](docs/resources/share.md)
-* [Users](docs/resources/user.md)
-* **Webhooks**
-    * [Calendlyr::Webhooks::Subscription](docs/resources/webhooks/subscription.md)
-    * [Calendlyr::Webhooks::Payload](docs/resources/webhooks/payload.md)
-    * [Calendlyr::Webhooks::InviteePayload](docs/resources/webhooks/invitee_payload.md)
+`Logger` is just an example. You can pass any object that responds to `info`, `debug`, `warn`, and `error`.
+
+If you're on Ruby 4 and want to use Ruby's `Logger`, make sure your application includes the `logger` gem.
+
+Or configure it globally:
+
+```ruby
+Calendlyr.configure do |config|
+  config.token = ENV.fetch("CALENDLY_TOKEN")
+  config.logger = Logger.new($stdout)
+end
+```
+
+In Rails, this is typically configured in an initializer:
+
+```ruby
+# config/initializers/calendlyr.rb
+Calendlyr.configure do |config|
+  config.token = ENV.fetch("CALENDLY_TOKEN")
+end
+```
+
+> [!IMPORTANT]
+> `Calendlyr.client` is module-global and **not thread-safe for multi-tenant usage**.
+> If your app serves multiple tenants or uses per-request credentials, use `Calendlyr::Client.new(token:)` per request.
+
+### Bare UUIDs
+
+Most methods that take a Calendly resource reference (like `user:`, `organization:`, `event_type:`, or `owner:`) accept both bare UUIDs and full URIs. When supported, the gem expands bare UUIDs automatically:
+
+```ruby
+# Both are equivalent:
+client.events.list(user: "YOUR_USER_UUID")
+client.events.list(user: "https://api.calendly.com/users/YOUR_USER_UUID")
+```
+
+The gem mirrors the Calendly API closely, so converting API examples into gem code is straightforward. Responses are wrapped in Ruby objects with dot-access for every field.
+
+> **Note:** A few endpoints still expect a full Calendly URI for specific parameters. When that matters, the resource docs call it out explicitly.
+
+### Webhook signature verification
+
+`Calendlyr::Webhook` (singular) verifies signed webhook payloads. This is separate from `client.webhooks` / `Calendlyr::Webhooks` (plural), which are API resources for managing webhook subscriptions.
+
+- Calendly sends the signature in the `Calendly-Webhook-Signature` HTTP header.
+- In Rack/Rails, that header is available as `HTTP_CALENDLY_WEBHOOK_SIGNATURE`.
+- `verify!` raises on invalid signature/timestamp; `valid?` returns `true`/`false`; `parse` verifies first, then JSON-parses and wraps the payload.
+
+```ruby
+payload = request.body.read
+signature_header = request.get_header("HTTP_CALENDLY_WEBHOOK_SIGNATURE")
+signing_key = ENV.fetch("CALENDLY_WEBHOOK_SIGNING_KEY")
+
+if Calendlyr::Webhook.valid?(payload: payload, signature_header: signature_header, signing_key: signing_key)
+  webhook = Calendlyr::Webhook.parse(
+    payload: payload,
+    signature_header: signature_header,
+    signing_key: signing_key
+  )
+
+  webhook.event   #=> "invitee.created"
+  webhook.payload #=> Calendlyr::Webhooks::InviteePayload (for invitee.* events)
+                 #=> Calendlyr::Object (for other/unknown events)
+end
+```
+
+### JSON serialization
+
+All API objects support `#to_json` for easy serialization (caching, logging, API proxying):
+
+```ruby
+event = client.events.retrieve(uuid: "ABC123")
+
+event.to_json
+#=> '{"uri":"https://api.calendly.com/scheduled_events/ABC123","name":"30 Minute Meeting",...}'
+
+# Works with JSON.generate and nested objects
+JSON.generate(event)
+
+# Round-trip: parse back into an Object
+parsed = Calendlyr::Object.new(JSON.parse(event.to_json))
+parsed.name  #=> "30 Minute Meeting"
+```
+
+> **Note:** `#to_json` and `#to_h` exclude the internal `client` reference — only API data is serialized.
+
+### Error context
+
+API errors now include the HTTP method and path in the message, and expose structured attributes for debugging:
+
+```ruby
+begin
+  client.events.retrieve(uuid: "INVALID_UUID")
+rescue Calendlyr::NotFound => error
+  error.message       #=> "[Error 404] GET /scheduled_events/INVALID_UUID — Not Found. The resource you requested does not exist."
+  error.status        #=> 404
+  error.http_method   #=> "GET"
+  error.path          #=> "/scheduled_events/INVALID_UUID"
+  error.response_body #=> { "title" => "Not Found", "message" => "..." }
+end
+```
+
+This makes debugging failed requests much easier without changing existing `rescue Calendlyr::Error` patterns.
+
+## Auto-pagination
+
+Calendlyr supports lazy auto-pagination for paginated collection endpoints. There are two ways to consume paginated results:
+
+### `list_all` — Eager, returns a flat Array
+
+The simplest option. Fetches every page and returns all items as an Array.
+
+```ruby
+# Get all events across all pages (e.g., hundreds of events)
+events = client.events.list_all(organization: "YOUR_ORG_UUID")
+events  #=> [#<Calendlyr::Event>, #<Calendlyr::Event>, ...]
+
+# Same pattern works for every resource with a list method:
+client.event_types.list_all(organization: "YOUR_ORG_UUID")
+client.webhooks.list_all(organization: "YOUR_ORG_UUID", scope: "organization")
+client.organizations.list_all_memberships(organization: "YOUR_ORG_UUID")
+client.organizations.list_all_invitations(uuid: "YOUR_ORG_UUID")
+client.organizations.list_all_activity_log(organization: "YOUR_ORG_UUID")
+client.groups.list_all(organization: "YOUR_ORG_UUID")
+client.groups.list_all_relationships(organization: "YOUR_ORG_UUID")
+client.routing_forms.list_all(organization: "YOUR_ORG_UUID")
+client.routing_forms.list_all_submissions(form: "YOUR_FORM_UUID")
+client.availability.list_all_user_busy_times(user: "YOUR_USER_UUID", start_time: "...", end_time: "...")
+client.availability.list_all_user_schedules(user: "YOUR_USER_UUID")
+client.locations.list_all
+client.event_types.list_all_memberships(event_type: "YOUR_EVENT_TYPE_UUID")
+client.outgoing_communications.list_all(organization: "YOUR_ORG_UUID")
+```
+
+### `auto_paginate` — Lazy Enumerator
+
+Returns an `Enumerator::Lazy` that fetches pages on demand. Pages are only requested as you consume items, so you can stop early without fetching all pages.
+
+```ruby
+collection = client.events.list(organization: "YOUR_ORG_UUID")
+
+# Take only the first 50 events — fetches only as many pages as needed
+first_50 = collection.auto_paginate.take(50)
+
+# Filter lazily — stops fetching once the condition is met
+active = collection.auto_paginate.select { |e| e.status == "active" }.first(10)
+
+# Consume all items lazily
+collection.auto_paginate.each do |event|
+  puts event.name
+end
+```
+
+## Documentation
+
+For the full list of available resources and methods, check out the [API Reference](docs/resources/).
+
+The docs in this repository focus on the Ruby wrapper API. For request/response schemas and endpoint-level behavior, use the official Calendly API docs linked from each resource page.
 
 ## Contributing
 
-1. Fork it ( https://github.com/araluce/calendlyr/fork )
+1. [Fork it](https://github.com/araluce/calendlyr/fork)
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
 
-When adding resources, update the list of resources in `lib/calendlyr`. Additionally, write a spec and include it in the list in the README
-
-## Thanks
-
-Many thanks to[@markets](https://github.com/markets) (our behind-the-scenes contributor) for all the comments, insights, and tips on this Ruby gem project, and for helping me grow professionally day by day :raised_hands:
-
-Thanks also to [@excid3](https://github.com/excid3) and his [Vultr.rb](https://github.com/excid3/vultr.rb) rubygem project.
+When adding resources, please write tests and update the [docs](docs/resources/).

data/calendlyr.gemspec

@@ -7,20 +7,22 @@ Gem::Specification.new do |spec|
   spec.email = ["araluce11@gmail.com"]
 
   spec.summary = "Ruby bindings for Calendly API."
-  spec.description = "Ruby bindings for Calendly API. Calendly APIs can be found here: https://calendly.stoplight.io/docs/api-docs/"
+  spec.description = "Ruby bindings for Calendly API v2. Full docs: https://developer.calendly.com/api-docs/"
   spec.homepage = "https://github.com/araluce/calendlyr"
   spec.license = "MIT"
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.2.0")
   spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "https://github.com/araluce/calendlyr/blob/master/CHANGELOG.md"
+  spec.metadata["documentation_uri"] = "https://github.com/araluce/calendlyr/tree/master/docs"
 
   spec.files = `git ls-files -z`.split("\x0")
   spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "rake", "~> 13.2"
+  spec.add_development_dependency "logger", "~> 1.6"
   spec.add_development_dependency "minitest", "~> 5.25"
-  spec.add_development_dependency "standard", "~> 1.37" # Max version that supports Ruby 2.7
-  spec.add_development_dependency "webmock", "~> 3.23"
-  spec.add_development_dependency "codecov", "~> 0.6"
+  spec.add_development_dependency "rake", "~> 13.2"
   spec.add_development_dependency "simplecov", "~> 0.21"
+  spec.add_development_dependency "standard", "~> 1.37"
+  spec.add_development_dependency "webmock", "~> 3.23"
 end

data/docs/resources/activity_log/list_activity_log_entries.md

@@ -13,7 +13,8 @@ Visit official [API Doc](https://developer.calendly.com/api-docs/d37c7f031f339-l
 For the example bellow we will use only required parameters, but you can use any other parameter as well.
 
 ```ruby
-client.organizations.activity_log(organization: `organization_uri`)
+# organization: accepts a bare UUID or full Calendly URI
+client.organizations.activity_log(organization: "ORG_UUID")
 #=> #<Calendlyr::Collection @data=[#<Calendlyr::ActivityLog, ...], @client=#<Calendlyr::Client>>
 ```
 

data/docs/resources/availabilities/user_availability_schedule.md

@@ -20,8 +20,9 @@ client.availabilities.retrieve_user_schedule(uuid: @uuid)
 Return the availability schedules of the given user. See [official API doc](https://developer.calendly.com/api-docs/8098de44af94c-list-user-availability-schedules)
 
 ```ruby
-client.availabilities.list_user_schedules(user: @user)
-#=> #<Calendlyr::Collection @data=[#<Calendlyr::Availabilities::UserSchedule uri="https://api.calendly.com/user_availability_schedule/abc123", default=true, name="Working Hours", user="https://api.calendly.com/users/abc123", timezone="America/New_York", rules=[#<OpenStruct type="wday", intervals=[#<OpenStruct from="08:30", to="09:30">], wday="sunday", date="2022-12-31">], client=#<Calendlyr::Client>, uuid="abc123">, #<Calendlyr::Availabilities::UserSchedule uri="https://api.calendly.com/user_availability_schedule/abc456", default=false, name="Evening Hours", user="https://api.calendly.com/users/abc123", timezone="America/New_York", rules=[#<OpenStruct type="wday", intervals=[#<OpenStruct from="08:30", to="17:00">], wday="monday">, #<OpenStruct type="wday", intervals=[#<OpenStruct from="08:30", to="17:00">], wday="tuesday">, #<OpenStruct type="wday", intervals=[], wday="wednesday">, #<OpenStruct type="wday", intervals=[#<OpenStruct from="08:30", to="17:00">], wday="thursday">, #<OpenStruct type="wday", intervals=[#<OpenStruct from="08:30", to="17:00">], wday="friday">, #<OpenStruct type="wday", intervals=[], wday="saturday">, #<OpenStruct type="date", intervals=[#<OpenStruct from="08:30", to="09:30">], date="2028-12-31">], client=#<Calendlyr::Client>, uuid="abc456">], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
+# user: accepts a bare UUID or full Calendly URI
+client.availabilities.list_user_schedules(user: "USER_UUID")
+#=> #<Calendlyr::Collection @data=[#<Calendlyr::Availabilities::UserSchedule>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
 ```
 
 #### List on me

data/docs/resources/availabilities/user_busy_time.md

@@ -14,8 +14,9 @@ Date range can be no greater than 1 week (7 days).
 
 For the example bellow we will use only required parameters, but you can use any other parameter as well.
 ```ruby
-client.availabilities.list_user_busy_times(user: `user_uri`, start_time: `start_time`, end_time: `end_time`)
-#=> #<Calendlyr::Collection @data=[#<Calendlyr::Availabilities::UserBusyTime type="calendly", start_time="2020-01-02T20:00:00.000000Z", end_time="2020-01-02T20:30:00.000000Z", buffered_start_time="2020-01-02T19:30:00.000000Z", buffered_end_time="2020-01-02T21:00:00.000000Z", event=#<OpenStruct uri="https://api.calendly.com/scheduled_events/abc123">, client=#<Calendlyr::Client>, uuid=nil>, #<Calendlyr::UserBusyTime type="calendly", start_time="2020-01-05T20:00:00.000000Z", end_time="2020-01-05T20:30:00.000000Z", buffered_start_time="2020-01-05T19:30:00.000000Z", buffered_end_time="2020-01-05T21:00:00.000000Z", event=#<OpenStruct uri="https://api.calendly.com/scheduled_events/abc12345">, client=#<Calendlyr::Client>, uuid=nil>, #<Calendlyr::UserBusyTime type="external", start_time="2020-01-07T20:00:00.000000Z", end_time="2020-01-07T20:30:00.000000Z", client=#<Calendlyr::Client>, uuid=nil>], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
+# user: accepts a bare UUID or full Calendly URI
+client.availabilities.list_user_busy_times(user: "USER_UUID", start_time: start_time, end_time: end_time)
+#=> #<Calendlyr::Collection @data=[#<Calendlyr::Availabilities::UserBusyTime>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
 ```
 
 ## Object methods

data/docs/resources/data_compliance.md

@@ -2,7 +2,7 @@
 
 ## Delete Invitee Data
 
-Remove invitee data from all previously booked events in your organization..
+Remove invitee data from all previously booked events in your organization.
 Visit official [API Doc](https://developer.calendly.com/api-docs/4cf896120a018-delete-invitee-data)
 
 ```ruby

data/docs/resources/event_types/availability_schedule.md

@@ -0,0 +1,28 @@
+# Availability Schedule Calendlyr::EventTypes::AvailabilitySchedule
+
+Availability schedule object for event types.
+
+## Client requests
+
+### List
+
+Returns a list of availability schedules for an event type.
+
+```ruby
+client.event_types.list_availability_schedules(event_type_uuid: event_type_uuid)
+#=> #<Calendlyr::Collection @data=[#<Calendlyr::EventTypes::AvailabilitySchedule>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
+```
+
+### Update
+
+Updates availability schedules for an event type.
+
+```ruby
+client.event_types.update_availability_schedule(
+  event_type_uuid: event_type_uuid,
+  availability_schedules: [
+    {start_time: "2023-10-27T09:00:00Z", end_time: "2023-10-27T12:00:00Z"}
+  ]
+)
+#=> {"message"=>"Availability schedules updated successfully."}
+```

data/docs/resources/event_types/available_time.md

@@ -1,21 +1,25 @@
-# Available Time Calendlyr::EventTypes::AvailableTime
+# Available Time (`Calendlyr::EventTypes::AvailableTime`)
 
-An available meeting time slot for the given event type.
+Available time for a specific Event Type in a given time window.
 
-Visit official [API Doc](https://developer.calendly.com/api-docs/2d8d322931358-event-type-available-time)
+Visit official [API Doc](https://developer.calendly.com/api-docs)
 
 ## Client requests
 
-### List
-Returns a list of available times for an event type within a specified date range.
+### List Available Times
 
-Date range can be no greater than 1 week (7 days).
+Returns available time slots for an Event Type between `start_time` and `end_time`.
 
-For the examples bellow we will use only required parameters, but you can use any other parameter as well.
-
-Visit official [API Doc](https://developer.calendly.com/api-docs/6a1be82aef359-list-event-type-available-times)
+Visit official [API Doc](https://developer.calendly.com/api-docs)
 
 ```ruby
-client.event_types.list_available_times(event_type, event_type, start_time: start_time, end_time: end_time)
-#=> #<Calendlyr::Collection @data=[#<Calendlyr::EventTypes::AvailableTime>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
+# event_type: accepts a bare UUID or full Calendly URI
+client.event_types.list_available_times(
+  event_type: "EVENT_TYPE_UUID",
+  start_time: "2026-04-07T09:00:00Z",
+  end_time: "2026-04-07T18:00:00Z"
+)
+#=> #<Calendlyr::Collection @data=[#<Calendlyr::EventTypes::AvailableTime>, ...], ...>
 ```
+
+This endpoint does not support pagination.