te_bot 0.1.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7d234f02d1972e727baf9fbc6576e7d9f2ef437c10ccdeb3cc208c3f2f3dd092
-  data.tar.gz: b5f032d95cab54dec2387cd9e1ad662d05f846f73247c8c64aa233e837e92678
+  metadata.gz: 6fa39962791458ebf9b8cd56bc4de36445e2fc5bbcdef2f360e12963cf970fc0
+  data.tar.gz: d774066a9e4d7a2608371de89444a16e8a9b7cd52842fa7e38bb9406b5f1a9f4
 SHA512:
-  metadata.gz: e810fb8f9052cd7c8ee2727acfbed634422a503f918b2d0e02a3a382228696c7d6d8cc493861958a95188644b127f31d8739fcaceaa6e2e2cd41bbf5fe3bec70
-  data.tar.gz: 9fb92b63eda3eda8b522e6455ee989fec4267809f6cf60819dfc082fbf02745e60a1e9378abe0f0ee8501dc083aeca65fe1e0ce06b8ea62216dbc1bf1a178519
+  metadata.gz: 5d9afb6cb164d7811dd2459313f703e0c84b639b5194f521ae7938d2a0474af011fcd7ae1cc5054b009d67717a7cec0da0da4053f591fc9599c43120246933ee
+  data.tar.gz: 7006934fa7a9652e3acc61a37bd80de279a2662d36aee1f0638a433e7a64a2fa3140e93850ed58b1a3a59f2d413589409cef2b4512d0ce18acf693b4f2735752

data/.standard.yml

@@ -1,3 +1,3 @@
 # For available configuration options, see:
 #   https://github.com/testdouble/standard
-ruby_version: 2.6
+ruby_version: 2.7

data/CHANGELOG.md

@@ -1,5 +1,26 @@
-## [Unreleased]
+## [Released]
 
 ## [0.1.0] - 2022-06-25
 
 - Initial release
+
+
+## [Released]
+
+## [0.2.0] - 2022-07-02
+
+- Change the implementation message replier from `reply(conn, message_string)` to `conn.reply text: message_string`.
+- Add support for other message types such as audio, video, animation, markdown, and document
+
+## [Released]
+
+## [0.3.0] - 2022-07-02
+
+- Support for the handler to return response direcly by returning rack array or hash.
+
+
+## [Unreleased]
+
+## [0.3.1] - 2022-07-03
+
+- Support for helpers with `helpers` macro

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    te_bot (0.1.0)
+    te_bot (0.4.0)
       faraday (~> 2.3)
       rack (~> 2.2)
 
@@ -14,10 +14,10 @@ GEM
     byebug (11.1.3)
     crack (0.4.5)
       rexml
-    faraday (2.3.0)
-      faraday-net_http (~> 2.0)
+    faraday (2.5.2)
+      faraday-net_http (>= 2.0, < 3.1)
       ruby2_keywords (>= 0.0.4)
-    faraday-net_http (2.0.3)
+    faraday-net_http (3.0.0)
     hashdiff (1.0.1)
     minitest (5.16.1)
     parallel (1.22.1)
@@ -57,6 +57,7 @@ GEM
       hashdiff (>= 0.4.0, < 2.0.0)
 
 PLATFORMS
+  x86_64-darwin-21
   x86_64-linux
 
 DEPENDENCIES

data/README.md

@@ -1,21 +1,24 @@
 # ::TeBot
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/te_bot`. To experiment with that code, run `bin/console` for an interactive prompt.
+[![Gem Version](https://badge.fury.io/rb/te_bot.svg)](https://badge.fury.io/rb/te_bot) ![Main Workflows](https://github.com/aaripurna/te_bot/actions/workflows/main.yml/badge.svg)
 
-This gem is used to handle telegram webhook and sending message with telegram bot
+Welcome to yet another telegram bot webhook handler.
+
+This gem is used to handle telegram webhook and sending message with telegram bot.
 
 ## Installation
 
 Install the gem and add to the application's Gemfile
 
-    gem "te_bot", github: "aaripurna/te_bot"
+    gem 'te_bot'
+
 Then run
 
-    $ bundle install
+    bundle install    
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
-    $ gem install te_bot -l https://github.com/aaripurna/te_bot.git
+    gem install te_bot
 
 ## Usage
 
@@ -25,23 +28,25 @@ This gem can be used as a standalone app since it implement rack interface. To u
 # app.rb
 
 require "te_bot"
+require "te_bot/sender_options"
 
 class MyWebhookApp < TeBot::Court
-    access_token ENV["YOUR_BOT_ACCESS_TOKEN"]
+  access_token ENV["YOUR_BOT_ACCESS_TOKEN"]
     
-    command("/start") do |conn, params|
-        reply(conn, "Welcome aboard my friend!")
-    end
+  command("/start") do
+    reply text: "Welcome aboard my friend!"
+  end
     
-    command("/today") do |conn, params|
-        reply(conn, Time.now.to_s)
-    end
+  command("/today") do
+    reply text: Time.now.to_s
+  end
 end
 ```
 
 To run this as a standalone app, you need to install `rack` and a webserver such as `puma`
 
-    $ bundle add rack puma
+    bundle add rack puma
+
 create a file named `config.ru` as the rack entrypoint.
 
 ```rb
@@ -53,12 +58,12 @@ run MyWebhookApp.new
 ```
 To run the app we can use rackup
 
-    $ bundle exec rackup
+    bundle exec rackup
 
 For more detailed information about rack please visit [Rack Repository](https://github.com/rack/rack).
 
 Now, our `MyWebhookApp` class is ready to handle some commands from telegram bot which are `/start` and `/today`.
-The command aslo support argument that will be passed to the `#command` block as `params`. To pass arguments, we can simply type `/today city:Jakarta limit:10`. The argument will be parsed as a Hash with string key => `{"city" => "Jakarta", "limit" => "10"}`. While the parameter `conn` is the message object which contains the full message including the chat_id to repy to.
+The command aslo support argument that will be passed in the instance method `params`. To pass arguments, we can simply type `/today city:Jakarta limit:10`. The argument will be parsed as a Hash with string key => `{"city" => "Jakarta", "limit" => "10"}`.
 
 To add a default handler for non existing command we can use the `#default_command` macro.
 
@@ -66,36 +71,38 @@ To add a default handler for non existing command we can use the `#default_comma
 # app.rb
 
 class MyWebhookApp < TeBot::Court
-    default_command do |conn, params|
-        reply(conn, "Sorry, Comand not found. Try another command. or type /help")
-    end
+  default_command do
+    reply text: "Sorry, Comand not found. Try another command. or type /help"
+  end
 end
 ```
 
-Other type of messages are also supported by using this macros `text` for regular text message, `query`, `document`, `audio`, and `voice`. For more detail please check this [Telegram Docs](https://core.telegram.org/bots/webhooks#testing-your-bot-with-updates). These macros is only expecting `conn` as an argument.
+All the messages are passed in the instance method `message`
+
+Other type of messages are also supported by using this macros `text` for regular text message, `query`, `document`, `audio`, and `voice`. For more detail please check this [Telegram Docs](https://core.telegram.org/bots/webhooks#testing-your-bot-with-updates).
 
 ```rb
 # app.rb
 
 class MyWebhookApp < TeBot::Court
-    text do |conn|
-        message = do_some_fancy_stuff_here(conn)
-        reply(conn, message)
-    end
+  text do
+    reply_message = do_some_fancy_stuff_here(message)
+    reply text: reply_message
+  end
 end
 ```
-And also we can define a macro for defaul action `#default_action` if the request does not match with this [Documentation](https://core.telegram.org/bots/webhooks#testing-your-bot-with-updates), Or we have not create the handler for that specific message type. Just becarefull, the `conn.data` might returns nil if the message format doesnot match the documentation.
+And also we can define a macro for default action `#default_action` if the request does not match with this [Documentation](https://core.telegram.org/bots/webhooks#testing-your-bot-with-updates), Or we have not created the handler for that specific message type.
 
 ```rb
 # app.rb
 
 class MyWebhookApp < TeBot::Court
-    default_action do |conn|
-        reply(conn, "No, I can't talk like people. use command instead") if conn.data&.chat_id
-    end
+  default_action do
+    reply text: "No, I can't talk like people. use command instead"
+  end
 end
 ```
-Since this app implements rack interface, and railr is also a rack based application. We can mount this app direcly inside rails app.
+Since this app implements rack interface, and rails is also a rack based application. We can mount this app direcly inside rails app.
 
 ```rb
 # config/routes.rb
@@ -103,19 +110,101 @@ Since this app implements rack interface, and railr is also a rack based applica
 require "lib/to/your_webhook"
 
 Rails.application.routes.draw do
-    mount MyAwessomWebhook.new => "telegram_webhook"
+  mount MyAwessomWebhook.new => "telegram_webhook"
 end
 ```
 
 ### Sending Message to Telegram
 To send message direcly to telegram, we can use this module `TeBot::Wire`
+and need to require `"te_bot/sender_options"` to add default handler for different type of messages.
+Available message types are `:text`, `:markdown`, `:photo`, `:audio`, `:document`, `:video`, `:animation` amd `:voice`
 
+Some supported message by default:
 ```rb
 # app.rb
 sender = TeBot::Wire.new(ENV['YOUR_ACCESS_TOKEN_HERE'])
-sender.send_message(chat_id, message_string)
+sender.send_message(chat_id, text: message_string)
+sender.send_message(chat_id, markdown: markdown_string)
+
+sender.send_message(chat_id, photo: { photo: url, caption: caption })
+sender.send_message(chat_id, video: { video: url, caption: caption})
+sender.send_message(chat_id, document: { document: url, caption: caption})
+sender.send_message(chat_id, audio: { audio: url, caption: caption})
+sender.send_message(chat_id, animation: { animation: url, caption: caption})
+
+```
+
+For markdown telegram supports MarkdownV2 [refer to this](https://core.telegram.org/bots/api#markdownv2-style)
+Please check the [documentation](https://core.telegram.org/bots/api#sendmessage) for more details.
+
+### Custom Handler
+
+Of course you can add more handler by extending the `TeBot::Wire` class
+
+```ruby
+# in/your/custom_handler.rb
+
+TeBot::Wire.class_eval do
+  sender :json do |chat_id, message|
+    make_request("sendMessage", body: { chat_id: chat_id, json: message }.to_json)
+  end
+end
+```
+
+### Helpers
+
+Using module
+```ruby
+# request_helpers.rb
+
+module RequestHelpers
+  def get_nearest_hospitals
+    # do some fancy stuff
+  end
+
+  def get_the_nearest_routes(hospitals)
+    # do some even fancier stuff
+  end 
+
+  def render_markdown(routes)
+    # do something else
+  end
+end
+
+class MyWebhookApp < TeBot::Court
+  include RequestHelpers
+
+  #... the rest of the code
+end
+
+```
+
+Using instance methods
+```ruby
+
+# app.rb
+
+class MyWebhookApp < TeBot::Court
+  command("/findhospital") do
+    hospitals = get_nearest_hospitals(params)
+    routes = get_the_nearest_routes(hospitals)
+
+    reply markdown: render_markdown(routes)
+  end
+
+  def get_nearest_hospitals(data)
+    # do some fancy stuff
+  end
+
+  def get_the_nearest_routes(hospitals)
+    # do some even fancier stuff
+  end 
+
+  def render_markdown(routes)
+    # do something else
+  end
+end
 ```
-This gem only support [sendMessage](https://core.telegram.org/bots/api#sendmessage) API for this moment.
 
 ## Development
 

data/lib/te_bot/cable.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module TeBot
+  module Cable
+    def chat_id
+      message.data&.chat_id
+    end
+
+    def reply(**payload)
+      return if chat_id.nil?
+
+      wire.send_message chat_id, **payload
+    end
+  end
+end

data/lib/te_bot/court.rb

@@ -5,6 +5,8 @@ require "json"
 
 module TeBot
   class Court
+    include TeBot::Cable
+
     class << self
       attr_reader :wire, :commands
 
@@ -20,14 +22,6 @@ module TeBot
         @default_action ||= block
       end
 
-      def reply(conn, message)
-        send_message(conn.data&.chat_id, message)
-      end
-
-      def send_message(chat_id, message)
-        wire.send_message(chat_id, message)
-      end
-
       def command(text, &block)
         @commands ||= {}
         @commands[text] = block
@@ -35,19 +29,40 @@ module TeBot
 
       ::TeBot::Message::GENERAL_MESSAGE_TYPES.each do |m|
         define_method(m) do |&block|
-          instance_variable_get("@#{m}") || instance_variable_set("@#{m}", block)
-          instance_variable_get("@#{m}")
+          @message_handlers ||= {}
+
+          if block.respond_to?(:call)
+            @message_handlers[m] = block
+          else
+            @message_handlers[m]
+          end
         end
       end
+
+      def message_handlers(handler)
+        @message_handlers ||= {}
+        @message_handlers[handler]
+      end
+    end
+
+    attr_reader :params, :message, :wire
+
+    def initialize
+      @params = {}
+      @message = nil
+      @command = nil
+      @wire = self.class.wire
     end
 
     def call(env)
       json_only(env) do |body|
         response = handle_request(body)
 
-        if response.is_a?(Array)
-          status, headers, body = response
-          [status, headers, body]
+        case response
+        in [Integer, Hash, Array] => rack_response
+          rack_response
+        in Hash => json_body
+          [200, {"Content-Type" => "application/json"}, [JSON.generate(json_body)]]
         else
           [200, {"Content-Type" => "application/json"}, [JSON.generate({"message" => "success"})]]
         end
@@ -72,32 +87,34 @@ module TeBot
     end
 
     def handle_request(body)
-      message = ::TeBot::Message.new(body)
+      @message = ::TeBot::Message.new(body)
+
+      @command, @params = @message.data&.content&.parse
 
-      message.command do
-        command, params = message.data.content.parse
-        handler = self.class.commands[command]
+      @params = params
 
+      @message.command do
+        handler = self.class.commands[@command]
         if handler.respond_to?(:call)
-          handler.call(message, params)
+          instance_eval(&handler)
         elsif self.class.default_command.respond_to?(:call)
-          self.class.default_command.call(message, params)
+          instance_eval(&self.class.default_command)
         end
       end
 
-      ::TeBot::Message::GENERAL_MESSAGE_TYPES.each do |f|
-        message.public_send(f) do
-          handler = self.class.public_send(f)
+      ::TeBot::Message::GENERAL_MESSAGE_TYPES.each do |message_type|
+        @message.public_send(message_type) do
+          handler = self.class.message_handlers(message_type)
 
           next unless handler.respond_to?(:call)
-          handler.call(message)
+          instance_eval(&handler)
         end
       end
 
-      if message.handler.respond_to?(:call)
-        message.call
+      if @message.handler.respond_to?(:call)
+        instance_eval(&@message.handler)
       elsif self.class.default_action.respond_to?(:call)
-        self.class.default_action.call(message)
+        instance_eval(&self.class.default_action)
       end
     end
   end

data/lib/te_bot/message.rb

@@ -17,17 +17,17 @@ module TeBot
       @message
     end
 
-    MESSAGE_TYPES.each do |format|
-      define_method(format) do |&block|
-        instance_variable_set("@#{format}", block)
+    MESSAGE_TYPES.each do |f|
+      define_method(f) do |&block|
+        @formats ||= {}
+        @formats[f.to_s] = block
       end
     end
 
     def handler
       return unless data || data.content
       content_class = data.content.class.name.split("::").last.downcase
-
-      instance_variable_get("@#{content_class}")
+      @formats[content_class]
     end
 
     def call

data/lib/te_bot/sender_options.rb

@@ -0,0 +1,37 @@
+require_relative "./wire"
+require "json"
+
+TeBot::Wire.class_eval do
+  sender :text do |chat_id, message|
+    make_request("sendMessage", body: {chat_id: chat_id, text: message}.to_json)
+  end
+
+  # this is using MarkdownV2 https://core.telegram.org/bots/api#markdownv2-style
+  sender :markdown do |chat_id, message|
+    make_request("sendMessage", body: {chat_id: chat_id, text: message, parse_mode: "MarkdownV2"}.to_json)
+  end
+
+  sender :photo do |chat_id, message|
+    make_request("sendPhoto", body: message.merge({chat_id: chat_id}).to_json)
+  end
+
+  sender :audio do |chat_id, message|
+    make_request("sendAudio", body: message.merge({chat_id: chat_id}).to_json)
+  end
+
+  sender :document do |chat_id, message|
+    make_request("sendDocument", body: message.merge({chat_id: chat_id}).to_json)
+  end
+
+  sender :video do |chat_id, message|
+    make_request("sendVideo", body: message.merge({chat_id: chat_id}).to_json)
+  end
+
+  sender :animation do |chat_id, message|
+    make_request("sendAnimation", body: message.merge({chat_id: chat_id}).to_json)
+  end
+
+  sender :voice do |chat_id, message|
+    make_request("sendVoice", body: message.merge({chat_id: chat_id}).to_json)
+  end
+end

data/lib/te_bot/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module TeBot
-  VERSION = "0.1.0"
+  VERSION = "0.4.0"
 end

data/lib/te_bot/wire.rb

@@ -5,24 +5,47 @@ require "faraday/net_http"
 
 module TeBot
   class Wire
+    class << self
+      def sender(message_format, handler = nil, &block)
+        @senders ||= {}
+        @senders[message_format] = (block || handler)
+      end
+
+      def senders
+        @senders || {}
+      end
+    end
+
     CONN = Faraday.new(
       url: "https://api.telegram.org/",
       headers: {"Content-Type" => "application/json"}
     )
 
-    def url(path)
-      "/bot#{@access_token}/#{path}"
-    end
-
     def initialize(access_token)
       @access_token = access_token
     end
 
-    def send_message(chat_id, message)
-      CONN.post(url("sendMessage")) do |req|
-        req.params["chat_id"] = chat_id
-        req.params["text"] = message
+    def make_request(path, params: nil, headers: nil, body: nil)
+      CONN.post(url(path)) do |req|
+        req.params.merge!(params) if params
+        req.headers.merge!(headers) if headers
+        req.body = body if body
       end
     end
+
+    def url(path)
+      "/bot#{@access_token}/#{path}"
+    end
+
+    def send_message(chat_id, **payload)
+      message_format, message = payload.first
+      handler = self.class.senders[message_format]
+
+      raise ArgumentError, "Message type invalid. sender :#{message_format} not defined" if handler.nil?
+
+      return instance_exec(chat_id, message, &handler) if handler.respond_to?(:call)
+
+      public_send(handler, chat_id, message)
+    end
   end
 end

data/lib/te_bot.rb

@@ -6,6 +6,7 @@ module TeBot
   autoload :Court, "te_bot/court.rb"
   autoload :Wire, "te_bot/wire.rb"
   autoload :Message, "te_bot/message.rb"
+  autoload :Cable, "te_bot/cable.rb"
 
   class Error < StandardError; end
   # Your code goes here...

data/te_bot.gemspec

@@ -11,11 +11,11 @@ Gem::Specification.new do |spec|
   spec.summary = "Self-contaned telegram bot handler."
   spec.description = "All at one telegram bot."
   spec.homepage = "https://github.com/aaripurna/te_bot"
-  spec.required_ruby_version = ">= 2.6.0"
+  spec.required_ruby_version = ">= 2.7.0"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/aaripurna/te_bot"
-  spec.metadata["changelog_uri"] = "https://github.com/aaripurna/te_bot/blob/main/CHANGELOG.md)"
+  spec.metadata["changelog_uri"] = "https://github.com/aaripurna/te_bot/blob/main/CHANGELOG.md"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
@@ -28,12 +28,6 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
-
   spec.add_dependency "rack", "~> 2.2"
   spec.add_dependency "faraday", "~> 2.3"
-
-  # For more information and examples about making a new gem, check out our
-  # guide at: https://bundler.io/guides/creating_gem.html
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: te_bot
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Nawa Aripurna
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2022-06-26 00:00:00.000000000 Z
+date: 2022-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rack
@@ -53,8 +53,10 @@ files:
 - README.md
 - Rakefile
 - lib/te_bot.rb
+- lib/te_bot/cable.rb
 - lib/te_bot/court.rb
 - lib/te_bot/message.rb
+- lib/te_bot/sender_options.rb
 - lib/te_bot/version.rb
 - lib/te_bot/wire.rb
 - sig/te_bot.rbs
@@ -64,7 +66,7 @@ licenses: []
 metadata:
   homepage_uri: https://github.com/aaripurna/te_bot
   source_code_uri: https://github.com/aaripurna/te_bot
-  changelog_uri: https://github.com/aaripurna/te_bot/blob/main/CHANGELOG.md)
+  changelog_uri: https://github.com/aaripurna/te_bot/blob/main/CHANGELOG.md
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -73,7 +75,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="