diligense 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fee0b40f03c5b52e6cb0683a3586a66cb92e8a9708d72a9facda56b9a3b661ec
+  data.tar.gz: 1e4e59ca8ec828f4188dcd52536f472f9c51e13b41b5c4bba0e6dc67a4216fcd
+SHA512:
+  metadata.gz: a1da038a14a705b7424317995d45ef3dd3484f4756f60fd589525afae89f612fbdac5e0b3b7f387717b95ee355426fc974bed630df2f7c45314ca32a6d724527
+  data.tar.gz: d2e2fc4002332fbde439116abf9058c0b3371457d9e85ed9aff0be50405ff17ebbe7a4c163711b56214f62755a82b4461bf4b157c828b627d33a95c311eeb0a0

data/CHANGELOG.md

@@ -0,0 +1,17 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+## [0.1.0] - 2025-10-30
+
+### Added
+- Initial release
+- Rails-inspired routing system for Telegram bots
+- Controller-based message handling
+- Basic bot functionality with HTTParty integration
+- Zeitwerk for autoloading

data/README.md

@@ -0,0 +1,19 @@
+# Ruby Telegram Bot
+
+A Ruby application for Telegram bot with Rails-like structure.
+
+## Setup
+
+1. Install dependencies:
+   ```bash
+   bundle install
+   ```
+
+2. Run the application:
+   ```bash
+   ./bin/bot
+   ```
+
+## Ruby Version
+
+This project uses Ruby 3.4.4

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/lib/diligense/api_client.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Diligense
+  class ApiClient
+    BASE_URL = 'https://api.telegram.org/bot'
+
+    attr_reader :bot_info
+
+    def initialize(token)
+      @token = token
+      @bot_info = fetch_bot_info
+      print_bot_info
+    end
+
+    def get_updates(offset: nil, timeout: 30)
+      params = { timeout: timeout }
+      params[:offset] = offset if offset
+
+      response = HTTParty.get("#{BASE_URL}#{@token}/getUpdates", query: params)
+
+      return [] unless response.success?
+
+      response.parsed_response['result']
+    end
+
+    def send_message(chat_id:, text:, **options)
+      params = {
+        chat_id: chat_id,
+        text: text
+      }.merge(options)
+
+      response = HTTParty.post("#{BASE_URL}#{@token}/sendMessage", body: params)
+
+      unless response.success?
+        raise "Failed to send message: #{response.code} - #{response.message}"
+      end
+
+      response.parsed_response['result']
+    end
+
+    private
+
+    def fetch_bot_info
+      response = HTTParty.get("#{BASE_URL}#{@token}/getMe")
+
+      unless response.success?
+        raise "Failed to fetch bot info: #{response.code} - #{response.message}"
+      end
+
+      response.parsed_response['result']
+    end
+
+    def print_bot_info
+      return unless @bot_info
+
+      puts "\n🤖 Bot Information:"
+      puts "  ID: #{@bot_info['id']}"
+      puts "  Name: #{@bot_info['first_name']}"
+      puts "  Username: @#{@bot_info['username']}" if @bot_info['username']
+      puts "  Can join groups: #{@bot_info['can_join_groups']}"
+      puts "  Can read all group messages: #{@bot_info['can_read_all_group_messages']}"
+      puts "  Supports inline queries: #{@bot_info['supports_inline_queries']}"
+      puts
+    end
+  end
+end

data/lib/diligense/application.rb

@@ -0,0 +1,59 @@
+module Diligense
+  class Application
+    def initialize(root_path)
+      @root_path = root_path
+
+      @loader = Zeitwerk::Loader.new
+      @loader.push_dir(File.join(@root_path, 'app'))
+      @loader.enable_reloading
+      @loader.setup
+
+      token = ENV['TG_TOKEN']
+      raise 'TG_TOKEN environment variable is not set' unless token
+
+      @api_client = ApiClient.new(token)
+      @offset = nil
+      @router = load_routes
+    end
+
+    def run
+      loop do
+        updates = @api_client.get_updates(offset: @offset)
+
+        updates.each do |update|
+          if update.include?('message')
+            message_update = Types::Updates::MessageUpdate.new(update)
+            dispatch_message(message_update)
+          end
+
+          @offset = update['update_id'] + 1
+        end
+      end
+    end
+
+    private
+
+    def load_routes
+      routes_path = File.join(@root_path, 'config', 'routes.rb')
+      router = eval(File.read(routes_path))
+      puts "Loaded #{router.routes.size} route(s)"
+      router
+    end
+
+    def dispatch_message(message_update)
+      handler_class_name = @router.match(message_update)
+
+      unless handler_class_name
+        puts "No route matched for message #{message_update.id}"
+        return
+      end
+
+      handler_class = Object.const_get(handler_class_name)
+      handler = handler_class.new(message_update: message_update, api_client: @api_client)
+      handler.call
+    rescue StandardError => e
+      puts "Error handling message: #{e.message}"
+      puts e.backtrace.first(5)
+    end
+  end
+end

data/lib/diligense/message_controller.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Diligense
+  class MessageController
+    attr_reader :message
+
+    def initialize(message_update:, api_client:)
+      @message = message_update.message
+      @api_client = api_client
+      @message_update = message_update
+
+      @message&.instance_variable_set(:@api_client, @api_client)
+    end
+
+    def call
+      return unless should_call_plain_message?
+
+      plain_message if respond_to?(:plain_message)
+    end
+
+    private
+
+    def should_call_plain_message?
+      return false unless @message_update.type == :message
+      return false unless @message
+      return false if @message.has_attachments?
+
+      true
+    end
+  end
+end

data/lib/diligense/route.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Diligense
+  class Route
+    attr_reader :type, :matcher, :handler
+
+    def initialize(type:, matcher:, handler:)
+      @type = type
+      @matcher = matcher
+      @handler = handler
+    end
+
+    def match(message_update)
+      result = (
+        case @type
+        when :chat_id
+          match_chat_id?(message_update)
+        when :user_id
+          match_user_id?(message_update)
+        when :chat_type
+          match_chat_type?(message_update)
+        when :message_type
+          match_message_type?(message_update)
+        when :text_pattern
+          match_text_pattern?(message_update)
+        when :default
+          true
+        else
+          false
+        end
+      )
+
+      result ? @handler : nil
+    end
+
+    private
+
+    def match_chat_id?(message_update)
+      chat_id = extract_chat_id(message_update)
+      return false unless chat_id
+
+      @matcher == chat_id
+    end
+
+    def match_user_id?(message_update)
+      user_id = extract_user_id(message_update)
+      return false unless user_id
+
+      @matcher == user_id
+    end
+
+    def match_chat_type?(message_update)
+      chat_type = extract_chat_type(message_update)
+      return false unless chat_type
+
+      if @matcher.is_a?(Array)
+        @matcher.include?(chat_type)
+      else
+        @matcher == chat_type
+      end
+    end
+
+    def match_message_type?(message_update)
+      raw_message = message_update.instance_variable_get(:@raw)['message']
+      return false unless raw_message
+
+      raw_message.key?(@matcher.to_s)
+    end
+
+    def match_text_pattern?(message_update)
+      raw_message = message_update.instance_variable_get(:@raw)['message']
+      return false unless raw_message
+
+      text = raw_message['text']
+      return false unless text
+
+      case @matcher
+      when Regexp
+        @matcher.match?(text)
+      when String
+        text == @matcher
+      else
+        false
+      end
+    end
+
+    def extract_chat_id(message_update)
+      raw_message = message_update.instance_variable_get(:@raw)['message']
+      raw_message&.dig('chat', 'id')
+    end
+
+    def extract_user_id(message_update)
+      raw_message = message_update.instance_variable_get(:@raw)['message']
+      raw_message&.dig('from', 'id')
+    end
+
+    def extract_chat_type(message_update)
+      raw_message = message_update.instance_variable_get(:@raw)['message']
+      raw_message&.dig('chat', 'type')
+    end
+  end
+end

data/lib/diligense/router.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Diligense
+  class Router
+    attr_reader :routes
+
+    def initialize
+      @routes = []
+    end
+
+    def draw(&block)
+      instance_eval(&block)
+      self
+    end
+
+    def chat(chat_id, to:)
+      add_route(type: :chat_id, matcher: chat_id, handler: to)
+    end
+
+    def user(user_id, to:)
+      add_route(type: :user_id, matcher: user_id, handler: to)
+    end
+
+    def dialog(to:)
+      add_route(type: :chat_type, matcher: 'private', handler: to)
+    end
+
+    def group(to:)
+      add_route(type: :chat_type, matcher: %w[group supergroup], handler: to)
+    end
+
+    def channel(to:)
+      add_route(type: :chat_type, matcher: 'channel', handler: to)
+    end
+
+    def message_type(type, to:)
+      add_route(type: :message_type, matcher: type, handler: to)
+    end
+
+    def text_matches(pattern, to:)
+      add_route(type: :text_pattern, matcher: pattern, handler: to)
+    end
+
+    def default(to:)
+      add_route(type: :default, matcher: nil, handler: to)
+    end
+
+    def match(message_update)
+      @routes.each do |route|
+        handler = route.match(message_update)
+        return handler if handler
+      end
+      nil
+    end
+
+    private
+
+    def add_route(type:, matcher:, handler:)
+      @routes << Route.new(type: type, matcher: matcher, handler: handler)
+    end
+  end
+end

data/lib/diligense/types/message.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Diligense
+  module Types
+    class Message
+      attr_reader :id, :content, :created_at
+
+      def initialize(raw, api_client: nil)
+        @raw = raw
+        @api_client = api_client
+
+        @id = raw.fetch('message_id')
+        @created_at = Time.at(raw.fetch('date')).to_datetime
+      end
+
+      def text
+        @raw['text']
+      end
+
+      def has_attachments?
+        attachment_keys = %w[photo video document audio voice video_note sticker animation]
+        attachment_keys.any? { |key| @raw.key?(key) }
+      end
+
+      def reply(text)
+        raise 'API client not set' unless @api_client
+
+        chat_id = @raw.dig('chat', 'id')
+        @api_client.send_message(chat_id: chat_id, text: text)
+      end
+    end
+  end
+end

data/lib/diligense/types/updates/message_update.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Diligense
+  module Types
+    module Updates
+      class MessageUpdate
+        attr_reader :id, :message
+
+        def initialize(raw)
+          @raw = raw
+
+          @id = raw.fetch('update_id')
+          @message = Types::Message.new(raw.fetch('message')) if raw['message']
+        end
+
+        def type
+          return :message if @raw['message']
+
+          :unknown
+        end
+      end
+    end
+  end
+end

data/lib/diligense/version.rb

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

data/lib/diligense.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'zeitwerk'
+require 'httparty'
+
+loader = Zeitwerk::Loader.for_gem
+loader.setup
+
+module Diligense
+end
+
+require_relative 'diligense/version'

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: diligense
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Artem Levenkov
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: A Ruby framework for building Telegram bots with Rails-like conventions
+  including routing, controllers, and message handling
+email:
+- me@alev.pro
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- Rakefile
+- lib/diligense.rb
+- lib/diligense/api_client.rb
+- lib/diligense/application.rb
+- lib/diligense/message_controller.rb
+- lib/diligense/route.rb
+- lib/diligense/router.rb
+- lib/diligense/types/message.rb
+- lib/diligense/types/updates/message_update.rb
+- lib/diligense/version.rb
+homepage: https://github.com/alev-pro/diligense
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/alev-pro/diligense
+  source_code_uri: https://github.com/alev-pro/diligense
+  changelog_uri: https://github.com/alev-pro/diligense/blob/master/CHANGELOG.md
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.4.4
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.7
+specification_version: 4
+summary: Rails-inspired framework for building Telegram bots
+test_files: []