telegrama 0.1.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a091a95e5e3a04865deef8b71ecf50da3f947026c0a1ad411d7d5827a5b6cc34
-  data.tar.gz: 2029971f6180699d8efba99814ed5305103f23a52507f2b0be3a452c0e8f0f9a
+  metadata.gz: 3ae6c6b2bb6c3da545107d0f91b63e490fbd6e7e5a6e6be633291346c9f6ebcb
+  data.tar.gz: 42b7590b77f6497a8b972a97a1bb8cd371f89bf5db322bcd779b7d0a7ae9a331
 SHA512:
-  metadata.gz: '048dee76d2c78e1813abf08a19524388983edb40fee8a0f53f274d92aa37e8f032e0149cf3b0628edb24bc8e94a4d0428f96565570c2ac5ff30db52b7944ca6d'
-  data.tar.gz: 1703bd66425bb79171a64626da8d08bad982f0d1536846c9bc2b215bd5e06e6c3086fe0366003ee1f5c5319c32e5e69fe22e368025eb99f776e43ed24936456d
+  metadata.gz: 596ad2ca19bb16c3c50d83f0ee7891e4a0ffe44218f34de187497ddb23a58862695564183402abe3b13e290801dc3bcaf033e00330e26b5faf5da2d97eb6e3bd
+  data.tar.gz: 810fe478ac180741ca83d2210eb179776ad815e647297cb037ad1d33a49cf0a81630bc27ac11a4393309ef4be23b23f330f0b75754c60cacaf37b78668adb658

data/.simplecov

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# SimpleCov configuration file (auto-loaded before test suite)
+# This keeps test_helper.rb clean and follows best practices
+
+SimpleCov.start do
+  # Use SimpleFormatter for terminal-only output (no HTML generation)
+  formatter SimpleCov::Formatter::SimpleFormatter
+
+  # Track coverage for the lib directory (gem source code)
+  add_filter "/test/"
+
+  # Track the lib and app directories
+  track_files "{lib,app}/**/*.rb"
+
+  # Enable branch coverage for more detailed metrics
+  enable_coverage :branch
+
+  # Set minimum coverage threshold to prevent coverage regression
+  minimum_coverage line: 80, branch: 75
+
+  # Disambiguate parallel test runs
+  command_name "Job #{ENV['TEST_ENV_NUMBER']}" if ENV['TEST_ENV_NUMBER']
+end
+
+# Print coverage summary to terminal after tests complete
+SimpleCov.at_exit do
+  SimpleCov.result.format!
+  puts "\n" + "=" * 60
+  puts "COVERAGE SUMMARY"
+  puts "=" * 60
+  puts "Line Coverage:   #{SimpleCov.result.covered_percent.round(2)}%"
+  puts "Branch Coverage: #{SimpleCov.result.coverage_statistics[:branch]&.percent&.round(2) || 'N/A'}%"
+  puts "=" * 60
+end

data/AGENTS.md

@@ -0,0 +1,5 @@
+# AGENTS.md
+
+This file provides guidance to AI Agents (like OpenAI's Codex, Cursor Agent, Claude Code, etc) when working with code in this repository.
+
+Please go ahead and read the full context for this project at `.cursor/rules/0-overview.mdc` and `.cursor/rules/1-quality.mdc` now. Also read the README for a good overview of the project.

data/Appraisals

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Note: Rails < 7.2 is not compatible with Ruby 3.4
+# (Logger became a bundled gem in Ruby 3.4, and only Rails 7.2+ handles this)
+# See: https://stdgems.org/logger/
+
+# Test against Rails 7.2 (minimum version compatible with Ruby 3.4)
+appraise "rails-7.2" do
+  gem "rails", "~> 7.2.0"
+end
+
+# Test against Rails 8.0
+appraise "rails-8.0" do
+  gem "rails", "~> 8.0.0"
+end
+
+# Test against Rails 8.1 (latest)
+appraise "rails-8.1" do
+  gem "rails", "~> 8.1.0"
+end

data/CHANGELOG.md

@@ -1,3 +1,33 @@
+## [Unreleased]
+
+## [0.3.0] - 2026-05-22
+
+- Added support for sending messages to Telegram forum topics with `message_thread_id`
+- Added `config.message_thread_id` as an optional default forum topic for all messages
+- Added per-message `message_thread_id:` overrides, including `message_thread_id: nil`
+  to bypass a configured default topic for one send
+- Preserved `message_thread_id` through async ActiveJob delivery, string-key serialized
+  options, and Markdown-to-HTML-to-plain-text fallback retries
+- Added validation so `message_thread_id` must be a positive integer when present
+- Fixed `parse_mode: nil` to omit the `parse_mode` parameter from Telegram API
+  requests instead of sending `null`
+- Fixed plain-text sends so `parse_mode: nil` does not inherit MarkdownV2 or HTML
+  escaping from configured formatting defaults
+- Fixed HTML sends so they do not inherit MarkdownV2 escaping from configured
+  formatting defaults
+- Fixed MarkdownV2 escaping for underscores inside identifiers such as `is_bot`,
+  `message_thread_id`, and `send_message`
+
+## [0.2.0] - 2026-01-17
+
+- Added Minitest test suite
+- Fixed duplicate Error class definition causing conflicts
+- Fixed missing `log_info` method
+- Fixed `parse_mode: nil` handling to properly respect explicit nil override
+- Fixed `strip_markdown` method to correctly strip markdown characters
+- Fixed `retry_delay` validation to accept float values (e.g., 0.5 seconds)
+- Added Ruby 3.5+ compatibility with `ostruct` dependency
+
 ## [0.1.3] - 2025-02-28
 
 - Added client options for retries and timeout

data/CLAUDE.md

@@ -0,0 +1,5 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+Please go ahead and read the full context for this project at `.cursor/rules/0-overview.mdc` and `.cursor/rules/1-quality.mdc` now. Also read the README for a good overview of the project.

data/README.md

@@ -1,8 +1,11 @@
-# 💬 `telegrama` – a tiny wrapper to send admin Telegram messages
+# 💬 `telegrama` – Send Telegram admin notifications in your Rails app
 
-[![Gem Version](https://badge.fury.io/rb/telegrama.svg?v=0.1.1)](https://badge.fury.io/rb/telegrama?v=0.1.1)
+[![Gem Version](https://badge.fury.io/rb/telegrama.svg)](https://badge.fury.io/rb/telegrama) [![Build Status](https://github.com/rameerez/telegrama/workflows/Tests/badge.svg)](https://github.com/rameerez/telegrama/actions)
 
-Send quick, simple admin / logging Telegram messages via a Telegram bot.
+> [!TIP]
+> **🚀 Ship your next Rails app 10x faster!** I've built **[RailsFast](https://railsfast.com/?ref=telegrama)**, a production-ready Rails boilerplate template that comes with everything you need to launch a software business in days, not weeks. Go [check it out](https://railsfast.com/?ref=telegrama)!
+
+`telegrama` lets you send quick, simple admin / logging Telegram messages via a Telegram bot.
 
 Useful for Rails developers using Telegram messages for notifications, admin alerts, errors, logs, daily summaries, and status updates, like:
 
@@ -50,6 +53,12 @@ Telegrama.send_message(a_general_message, chat_id: general_chat_id)
 Telegrama.send_message(marketing_message, chat_id: marketing_chat_id)
 ```
 
+You can also send messages to a specific topic inside a forum-enabled Telegram group:
+
+```ruby
+Telegrama.send_message(deploy_message, chat_id: engineering_group_id, message_thread_id: deployments_topic_id)
+```
+
 The goal with this gem is to provide a straightforward, no-frills, minimal API to send Telegram messages reliably for admin purposes, without you having to write your own wrapper over the Telegram API.
 
 ## Quick start
@@ -72,6 +81,7 @@ Then, create an initializer file under `config/initializers/telegrama.rb` and se
 Telegrama.configure do |config|
   config.bot_token = Rails.application.credentials.dig(Rails.env.to_sym, :telegram, :bot_token)
   config.chat_id   = Rails.application.credentials.dig(Rails.env.to_sym, :telegram, :chat_id)
+  config.message_thread_id = nil  # Optional default Telegram forum topic ID
   config.default_parse_mode = 'MarkdownV2'
   
   # Optional prefix/suffix for all messages (useful to identify messages from different apps or environments)
@@ -160,6 +170,22 @@ Both `message_prefix` and `message_suffix` are optional and can be used independ
   Telegrama.send_message("Hello, alternate group!", chat_id: alternate_chat_id)
   ```
 
+- **`message_thread_id`**
+  *Send to a specific Telegram forum topic inside a group. Telegram's Bot API calls topic IDs `message_thread_id` values.*
+  **Usage Example:**
+  ```ruby
+  Telegrama.send_message("Deploy finished!", chat_id: engineering_group_id, message_thread_id: deployments_topic_id)
+  ```
+
+  You can get this ID from an incoming Telegram update sent inside the topic, or from the `ForumTopic` returned by Telegram's `createForumTopic` API.
+
+  You can also configure a default topic:
+  ```ruby
+  config.message_thread_id = deployments_topic_id
+  ```
+
+  To bypass a configured default topic for one message, pass `message_thread_id: nil`.
+
 - **`parse_mode`**
   *Override the default parse mode (default is `"MarkdownV2"`).*
   **Usage Example:**
@@ -264,7 +290,7 @@ Telegrama includes a sophisticated state machine-based markdown formatter that p
 
 The formatter is designed to be robust even with complex inputs, ensuring your messages always look great in Telegram:
 
-```ruby
+````ruby
 # Complex formatting example that works perfectly
 message = <<~MSG
   📊 *Monthly Report*
@@ -287,20 +313,18 @@ message = <<~MSG
 MSG
 
 Telegrama.send_message(message)
+````
 
 ## Testing
 
-The gem includes a comprehensive test suite.
+The gem includes a Minitest test suite.
 
 To run the tests:
 
 ```bash
-bundle install
 bundle exec rake test
 ```
 
-The test suite uses SQLite3 in-memory database and requires no additional setup.
-
 ## 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.
@@ -313,4 +337,4 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/rameer
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/gemfiles/rails_7.2.gemfile

@@ -0,0 +1,19 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "irb"
+gem "rake", "~> 13.0"
+gem "rails", "~> 7.2.0"
+
+group :test do
+  gem "appraisal"
+  gem "minitest", "~> 6.0"
+  gem "minitest-mock"
+  gem "minitest-reporters", "~> 1.6"
+  gem "rack-test"
+  gem "simplecov", require: false
+  gem "webmock", "~> 3.23"
+end
+
+gemspec path: "../"

data/gemfiles/rails_8.0.gemfile

@@ -0,0 +1,19 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "irb"
+gem "rake", "~> 13.0"
+gem "rails", "~> 8.0.0"
+
+group :test do
+  gem "appraisal"
+  gem "minitest", "~> 6.0"
+  gem "minitest-mock"
+  gem "minitest-reporters", "~> 1.6"
+  gem "rack-test"
+  gem "simplecov", require: false
+  gem "webmock", "~> 3.23"
+end
+
+gemspec path: "../"

data/gemfiles/rails_8.1.gemfile

@@ -0,0 +1,19 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "irb"
+gem "rake", "~> 13.0"
+gem "rails", "~> 8.1.0"
+
+group :test do
+  gem "appraisal"
+  gem "minitest", "~> 6.0"
+  gem "minitest-mock"
+  gem "minitest-reporters", "~> 1.6"
+  gem "rack-test"
+  gem "simplecov", require: false
+  gem "webmock", "~> 3.23"
+end
+
+gemspec path: "../"

data/lib/telegrama/client.rb

@@ -13,25 +13,33 @@ module Telegrama
 
     # Send a message with built-in error handling and fallbacks
     def send_message(message, options = {})
+      options = normalize_option_keys(options)
+
       # Allow chat ID override; fallback to config default
       chat_id = options.delete(:chat_id) || Telegrama.configuration.chat_id
 
+      # Allow topic/thread override; fallback to config default.
+      # Explicit nil means "send to the chat normally", even when a default topic is configured.
+      message_thread_id = if options.key?(:message_thread_id)
+                            options.delete(:message_thread_id)
+                          else
+                            Telegrama.configuration.message_thread_id
+                          end
+      validate_message_thread_id!(message_thread_id)
+
       # Get client options from config
       client_opts = Telegrama.configuration.client_options || {}
       client_opts = client_opts.merge(@config)
 
       # Default to MarkdownV2 parse mode unless explicitly overridden
-      parse_mode = options[:parse_mode] || Telegrama.configuration.default_parse_mode
+      # Use key? to allow explicit nil override (for plain text without formatting)
+      parse_mode = options.key?(:parse_mode) ? options[:parse_mode] : Telegrama.configuration.default_parse_mode
 
-      # Allow runtime formatting options, merging with configured defaults
-      formatting_opts = options.delete(:formatting) || {}
-
-      # Add parse mode specific options
-      if parse_mode == 'MarkdownV2'
-        formatting_opts[:escape_markdown] = true unless formatting_opts.key?(:escape_markdown)
-      elsif parse_mode == 'HTML'
-        formatting_opts[:escape_html] = true unless formatting_opts.key?(:escape_html)
-      end
+      # Allow runtime formatting options, merging with configured defaults.
+      # Escape behavior must match the outgoing Telegram parse mode; otherwise
+      # plain-text sends can display MarkdownV2 escape characters literally.
+      formatting_opts = normalize_option_keys(options.delete(:formatting) || {})
+      formatting_opts = formatting_options_for_parse_mode(parse_mode, formatting_opts)
 
       # Format the message text with our formatter
       formatted_message = Formatter.format(message, formatting_opts)
@@ -45,10 +53,11 @@ module Telegrama
         payload = {
           chat_id: chat_id,
           text: formatted_message,
-          parse_mode: parse_mode,
           disable_web_page_preview: options.fetch(:disable_web_page_preview,
                                                  Telegrama.configuration.disable_web_page_preview)
         }
+        payload[:parse_mode] = parse_mode unless parse_mode.nil?
+        payload[:message_thread_id] = message_thread_id unless message_thread_id.nil?
 
         # Additional options such as reply_markup can be added here
         payload.merge!(options.select { |k, _| [:reply_markup, :reply_to_message_id].include?(k) })
@@ -114,6 +123,43 @@ module Telegrama
 
     private
 
+    def normalize_option_keys(options)
+      return {} if options.nil?
+
+      options.to_h.each_with_object({}) do |(key, value), normalized|
+        normalized[key.respond_to?(:to_sym) ? key.to_sym : key] = value
+      end
+    end
+
+    def validate_message_thread_id!(message_thread_id)
+      return if message_thread_id.nil?
+
+      unless message_thread_id.is_a?(Integer) && message_thread_id.positive?
+        raise ArgumentError, "Telegrama send_message option error: message_thread_id must be a positive integer."
+      end
+    end
+
+    def formatting_options_for_parse_mode(parse_mode, formatting_opts)
+      case parse_mode
+      when 'MarkdownV2'
+        {
+          escape_html: false
+        }.merge(formatting_opts).tap do |opts|
+          opts[:escape_markdown] = true unless opts.key?(:escape_markdown)
+        end
+      when 'HTML'
+        {
+          escape_markdown: false
+        }.merge(formatting_opts).tap do |opts|
+          opts[:escape_html] = true unless opts.key?(:escape_html)
+        end
+      when nil
+        formatting_opts.merge(escape_markdown: false, escape_html: false)
+      else
+        formatting_opts
+      end
+    end
+
     def perform_request(payload, options = {})
       uri = URI("https://api.telegram.org/bot#{Telegrama.configuration.bot_token}/sendMessage")
       request = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
@@ -159,6 +205,4 @@ module Telegrama
       defined?(Rails) && Rails.respond_to?(:logger) ? Rails.logger : Logger.new($stdout)
     end
   end
-
-  class Error < StandardError; end
 end

data/lib/telegrama/configuration.rb

@@ -10,6 +10,10 @@ module Telegrama
     # You can override this on the fly when sending messages.
     attr_accessor :chat_id
 
+    # Default message thread ID for sending messages to a forum topic.
+    # You can override this on the fly when sending messages.
+    attr_accessor :message_thread_id
+
     # Default parse mode for messages (e.g. "MarkdownV2" or "HTML").
     attr_accessor :default_parse_mode
 
@@ -57,6 +61,7 @@ module Telegrama
       # Credentials (must be set via initializer)
       @bot_token = nil
       @chat_id = nil
+      @message_thread_id = nil
 
       # Defaults for message formatting
       @default_parse_mode = 'MarkdownV2'
@@ -90,6 +95,7 @@ module Telegrama
     def validate!
       validate_bot_token!
       validate_default_parse_mode!
+      validate_message_thread_id!
       validate_formatting_options!
       validate_client_options!
       true
@@ -110,6 +116,14 @@ module Telegrama
       end
     end
 
+    def validate_message_thread_id!
+      return if message_thread_id.nil?
+
+      unless message_thread_id.is_a?(Integer) && message_thread_id.positive?
+        raise ArgumentError, "Telegrama configuration error: message_thread_id must be a positive integer."
+      end
+    end
+
     def validate_formatting_options!
       unless formatting_options.is_a?(Hash)
         raise ArgumentError, "Telegrama configuration error: formatting_options must be a hash."
@@ -134,7 +148,8 @@ module Telegrama
         raise ArgumentError, "Telegrama configuration error: client_options must be a hash."
       end
 
-      [:timeout, :retry_count, :retry_delay].each do |key|
+      # timeout and retry_count must be positive integers
+      [:timeout, :retry_count].each do |key|
         if client_options.key?(key)
           val = client_options[key]
           unless val.is_a?(Integer) && val.positive?
@@ -142,6 +157,14 @@ module Telegrama
           end
         end
       end
+
+      # retry_delay can be a positive integer or float (e.g., 0.5 seconds)
+      if client_options.key?(:retry_delay)
+        val = client_options[:retry_delay]
+        unless val.is_a?(Numeric) && val.positive?
+          raise ArgumentError, "Telegrama configuration error: client_options[:retry_delay] must be a positive number."
+        end
+      end
     end
   end
 end

data/lib/telegrama/formatter.rb

@@ -179,8 +179,12 @@ module Telegrama
           @result += '*'
           advance
         elsif char == '_' && !escaped?
-          enter_state(:italic)
-          @result += '_'
+          if italic_opening_delimiter?
+            enter_state(:italic)
+            @result += '_'
+          else
+            @result += '\\_'
+          end
           advance
         elsif char == '[' && !escaped?
           if looking_at_markdown_link?
@@ -256,8 +260,12 @@ module Telegrama
         char = current_char
 
         if char == '_' && !escaped?
-          exit_state
-          @result += '_'
+          if italic_closing_delimiter?
+            exit_state
+            @result += '_'
+          else
+            @result += '\\_'
+          end
           advance
         elsif char == '\\' && !escaped?
           handle_escape_sequence
@@ -389,6 +397,34 @@ module Telegrama
         @chars[@position + 1]
       end
 
+      # Get the previous character
+      def previous_char
+        @position.positive? ? @chars[@position - 1] : nil
+      end
+
+      # Underscores inside identifiers should render literally, not start italics.
+      def italic_opening_delimiter?
+        following = next_char
+        return false if following.nil? || whitespace?(following)
+
+        !word_char?(previous_char)
+      end
+
+      def italic_closing_delimiter?
+        previous = previous_char
+        return false if previous.nil? || whitespace?(previous)
+
+        !word_char?(next_char)
+      end
+
+      def word_char?(char)
+        !!(char =~ /[[:alnum:]]/)
+      end
+
+      def whitespace?(char)
+        !!(char =~ /\s/)
+      end
+
       # Check if next character is one of the given characters
       def next_char_is?(*chars)
         has_chars_ahead?(1) && chars.include?(next_char)
@@ -473,8 +509,34 @@ module Telegrama
     # @param text [String] The text with markdown formatting
     # @return [String] The text with markdown formatting removed
     def self.strip_markdown(text)
-      # Remove all markdown syntax for plain text delivery
-      text.gsub(/[*_~`]|\[.*?\]\(.*?\)/, '')
+      result = text.dup
+
+      # Remove markdown links [text](url) -> text
+      result.gsub!(/\[([^\]]*)\]\([^)]*\)/, '\1')
+
+      # Remove triple backtick code blocks (preserve content)
+      result.gsub!(/```[a-z]*\n?(.*?)```/m, '\1')
+
+      # Remove inline code backticks (preserve content)
+      result.gsub!(/`([^`]*)`/, '\1')
+
+      # Remove bold formatting (both ** and *)
+      result.gsub!(/\*\*([^*]*)\*\*/, '\1')
+      result.gsub!(/\*([^*]*)\*/, '\1')
+
+      # Remove italic formatting (both __ and _)
+      result.gsub!(/__([^_]*)__/, '\1')
+      result.gsub!(/(?<![\\])_([^_]*)_/, '\1')
+
+      # Remove strikethrough
+      result.gsub!(/~~([^~]*)~~/, '\1')
+      result.gsub!(/~([^~]*)~/, '\1')
+
+      # Remove any remaining unmatched formatting characters at word boundaries
+      # but preserve them in the middle of words (like file_name)
+      result.gsub!(/(?<=\s)[*_~`]+|[*_~`]+(?=\s|$)/, '')
+
+      result
     end
 
     # Convert HTML to Telegram MarkdownV2 format

data/lib/telegrama/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Telegrama
-  VERSION = "0.1.3"
+  VERSION = "0.3.0"
 end

data/lib/telegrama.rb

@@ -40,11 +40,20 @@ module Telegrama
 
     # Helper method for logging errors
     def log_error(message)
-      if defined?(Rails)
+      if defined?(Rails) && Rails.respond_to?(:logger)
         Rails.logger.error("[Telegrama] #{message}")
       else
         warn("[Telegrama] #{message}")
       end
     end
+
+    # Helper method for logging info messages
+    def log_info(message)
+      if defined?(Rails) && Rails.respond_to?(:logger)
+        Rails.logger.info("[Telegrama] #{message}")
+      else
+        puts("[Telegrama] #{message}")
+      end
+    end
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: telegrama
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Javi R
 bindir: exe
 cert_chain: []
-date: 2025-02-28 00:00:00.000000000 Z
+date: 2026-05-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -23,6 +23,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 6.0.0
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.5'
 description: Send quick, simple admin / logging Telegram messages via a Telegram bot.
   Useful for Rails developers using Telegram messages for notifications, admin alerts,
   daily summaries, and status updates. Parses and escapes Markdown for beautifully
@@ -34,10 +48,17 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".simplecov"
+- AGENTS.md
+- Appraisals
 - CHANGELOG.md
+- CLAUDE.md
 - LICENSE.txt
 - README.md
 - Rakefile
+- gemfiles/rails_7.2.gemfile
+- gemfiles/rails_8.0.gemfile
+- gemfiles/rails_8.1.gemfile
 - lib/telegrama.rb
 - lib/telegrama/client.rb
 - lib/telegrama/configuration.rb