reddit-to-telegram 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: def346e1939d931f21e0f24d1630cb4bd9a6d08d0ef7ebd5abbe825c1550a938
+  data.tar.gz: 2f82277c614573fe1fd857a6fb6ea61f9c9e05c0f988469ad058dc2e69b1c98d
+SHA512:
+  metadata.gz: f11773282239a115f8e1609f7cd96af138057b8ca14aaaad938da783888efa50c25ead86cbc7a04af2095b642c481f297d07b2ae972e34dc6f2c4f2a80cb1dce
+  data.tar.gz: 107f58634675023a1c0ac98a6be862dd5101169f76296bedc09c280bd21e8cb737ef6610557d5932f3034dc25f1aa4e66ef43af6b1d115a614405b1fdf6512f3

data/.gitignore

@@ -0,0 +1,2 @@
+tmp/*
+!tmp/.keep

data/.rubocop.yml

@@ -0,0 +1,14 @@
+Metrics/MethodLength:
+  Max: 20
+
+Style/Documentation:
+  Enabled: false
+
+Style/NumericPredicate:
+  Enabled: false
+
+Style/SingleArgumentDig:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.2.2

data/Gemfile

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,65 @@
+PATH
+  remote: .
+  specs:
+    reddit-to-telegram (0.0.0)
+      aws-sdk-simpledb
+      httparty
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    aws-eventstream (1.3.0)
+    aws-partitions (1.883.0)
+    aws-sdk-core (3.190.3)
+      aws-eventstream (~> 1, >= 1.3.0)
+      aws-partitions (~> 1, >= 1.651.0)
+      aws-sigv4 (~> 1.8)
+      jmespath (~> 1, >= 1.6.1)
+    aws-sdk-simpledb (1.42.0)
+      aws-sdk-core (~> 3, >= 3.188.0)
+      aws-sigv2 (~> 1.0)
+    aws-sigv2 (1.2.0)
+    aws-sigv4 (1.8.0)
+      aws-eventstream (~> 1, >= 1.0.2)
+    httparty (0.21.0)
+      mini_mime (>= 1.0.0)
+      multi_xml (>= 0.5.2)
+    jmespath (1.6.2)
+    json (2.7.1)
+    language_server-protocol (3.17.0.3)
+    mini_mime (1.1.5)
+    multi_xml (0.6.0)
+    parallel (1.24.0)
+    parser (3.3.0.5)
+      ast (~> 2.4.1)
+      racc
+    racc (1.7.3)
+    rainbow (3.1.1)
+    regexp_parser (2.9.0)
+    rexml (3.2.6)
+    rubocop (1.60.2)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.30.0, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.30.0)
+      parser (>= 3.2.1.0)
+    ruby-progressbar (1.13.0)
+    unicode-display_width (2.5.0)
+
+PLATFORMS
+  x86_64-linux
+
+DEPENDENCIES
+  reddit-to-telegram!
+  rubocop
+
+BUNDLED WITH
+   2.4.10

data/README.md

@@ -0,0 +1,9 @@
+ reddit-to-telegram
+=======================
+
+#### Fetches hot posts from chosen subreddits and pushes them to Telegram channels.
+
+I'll update readme with instructions soon.
+
+### TODO:
+- Error handling (maybe send them to another channel in Telegram)

data/lib/reddit-to-telegram.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require_relative "reddit_to_telegram/reddit/fetch"
+require_relative "reddit_to_telegram/store"
+require_relative "reddit_to_telegram/telegram/post"
+
+module RedditToTelegram
+  class << self
+    def post(sources)
+      return if sources.empty?
+
+      Store.setup
+
+      sources.each do |subreddit, telegram_chat_id|
+        res = Reddit::Fetch.hot(subreddit)
+        handle_res(res, subreddit, telegram_chat_id)
+      end
+    end
+
+    def handle_res(res, subreddit, telegram_chat_id)
+      return if res.nil?
+
+      post = find_new_post(subreddit, res)
+      return if post.nil?
+
+      Telegram::Post.push(post, telegram_chat_id)
+      Store::Posts.add(subreddit, post[:id])
+    end
+
+    def find_new_post(subreddit, posts)
+      posts.find { |post| !Store::Posts.dup?(subreddit, post[:id]) }
+    end
+  end
+end

data/lib/reddit_to_telegram/reddit/auth.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require "httparty"
+require_relative "../vars"
+
+module RedditToTelegram
+  module Reddit
+    class Auth
+      include HTTParty
+
+      URI = "https://www.reddit.com/api/v1/access_token"
+      PARAMS = { grant_type: "client_credentials" }.freeze
+      HEADERS = { "Content-Type" => "application/x-www-form-urlencoded" }.freeze
+
+      class << self
+        def token
+          HTTParty.post(
+            URI,
+            body: PARAMS,
+            headers: HEADERS,
+            basic_auth: { username: Vars::Reddit.client_id, password: Vars::Reddit.client_secret }
+          )["access_token"]
+        end
+      end
+    end
+  end
+end

data/lib/reddit_to_telegram/reddit/fetch.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "httparty"
+require_relative "auth"
+require_relative "output"
+require_relative "../store"
+require_relative "../vars"
+
+module RedditToTelegram
+  module Reddit
+    class Fetch
+      include HTTParty
+
+      BASE_URI = "https://oauth.reddit.com/r"
+      QUERY = { g: "GLOBAL", limit: Vars.max_stored_posts }.freeze
+      BASE_HEADERS = {
+        "Content-Type" => "application/json",
+        "Accept" => "application/json"
+      }.freeze
+
+      class << self
+        def hot(subreddit, retries_left = 5)
+          headers = BASE_HEADERS.merge("Authorization" => "Bearer #{Store::Reddit.token}")
+          res = HTTParty.get(
+            "#{BASE_URI}/#{subreddit}/hot.json",
+            query: QUERY,
+            headers:
+          )
+          handle_response(res, subreddit, retries_left)
+        end
+
+        def handle_response(res, subreddit, retries_left)
+          case res.code
+          when 401
+            Store::Reddit.token = Auth.token
+            hot(subreddit, retries_left) if retries_left > 0
+          when 429
+            sleep(10 / retries_left) if retries_left > 0
+            hot(subreddit, retries_left - 1) if retries_left > 0
+          when 200
+            Output.format_response(res)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reddit_to_telegram/reddit/output.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module RedditToTelegram
+  module Reddit
+    class Output
+      class << self
+        def format_response(res)
+          posts = res["data"]["children"]
+          posts.reject! { |post| post["data"]["stickied"] == true }
+          posts.map { |post| format_post(post) }.compact
+        end
+
+        def format_post(post)
+          data = post["data"]
+          if data["post_hint"] == "image"
+            format_image_post(data)
+          elsif data["post_hint"] == "link"
+            format_link_post(data)
+          elsif data["is_gallery"]
+            format_gallery_post(data)
+          elsif data["is_video"]
+            format_video_post(data)
+          end
+        end
+
+        def format_image_post(data)
+          base_post_format_attrs(data).merge(
+            { type: :image,
+              media: data["url"] }
+          )
+        end
+
+        def format_link_post(data)
+          base_post_format_attrs(data).merge(
+            { type: :text,
+              text: "#{data['title']}\n\n#{data['url']}" }
+          )
+        end
+
+        def format_gallery_post(data)
+          base_post_format_attrs(data).merge(
+            { type: :gallery,
+              media: prepare_gallery_links(data) }
+          )
+        end
+
+        def format_video_post(data)
+          video_data = data["secure_media"]["reddit_video"]
+          video_url = video_data["fallback_url"]
+          if video_data["has_audio"]
+            audio_url = "#{video_url.split('_')[0]}_AUDIO_128.mp4"
+            video_url = "https://sd.rapidsave.com/download.php"\
+                        "?permalink=https://reddit.com#{data['permalink']}"\
+                        "&video_url=#{video_url}&audio_url=#{audio_url}"
+          end
+
+          base_post_format_attrs(data).merge(
+            {
+              type: :video,
+              media: video_url,
+              misc: {
+                binary: video_data["has_audio"] || false
+              }
+            }
+          )
+        end
+
+        def base_post_format_attrs(data)
+          { id: data["name"],
+            text: data["title"] }
+        end
+
+        def prepare_gallery_links(data)
+          data["media_metadata"].map do |image|
+            image[1]["p"][0]["u"].split("?").first.gsub("preview", "i")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/reddit_to_telegram/store/aws_simple_db.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+require "aws-sdk-simpledb"
+require "json"
+require_relative "../vars"
+
+module RedditToTelegram
+  module Store
+    class AWSSimpleDB
+      DOMAIN_NAME = "reddit_to_telegram"
+      ITEM_NAME = "cached_data"
+
+      class << self
+        attr_reader :reddit_token
+
+        def setup
+          create_domain unless client.list_domains.domain_names.include?(DOMAIN_NAME)
+          read_db
+        end
+
+        def reddit_token=(val)
+          @reddit_token = val
+          write_db
+        end
+
+        def add_post(subreddit, id)
+          @posts[subreddit] = [] if @posts[subreddit].nil?
+          @posts[subreddit] << id
+          @posts[subreddit].shift if @posts[subreddit].count > Store::MAX_STORED_POSTS
+          write_db
+        end
+
+        def dup_post?(subreddit, id)
+          return false if @posts[subreddit].nil?
+
+          @posts[subreddit].include?(id)
+        end
+
+        def client
+          @client ||= Aws::SimpleDB::Client.new(
+            access_key_id: Vars::AWS.access_key_id,
+            secret_access_key: Vars::AWS.secret_access_key,
+            region: Vars::AWS.region
+          )
+        end
+
+        def read_db
+          res = client.get_attributes(
+            {
+              domain_name: "reddit_to_telegram",
+              item_name: "cached_data",
+              consistent_read: true
+            }
+          )
+
+          return assign_default_values if res.attributes.empty?
+
+          assign_values_from_db(res)
+        end
+
+        def assign_values_from_db(data)
+          @reddit_token = data.attributes.find { |a| a.name == "reddit_token" }.value || ""
+          @posts = {}
+          data.attributes.each do |attr|
+            @posts[attr.name.split("_").last.to_sym] = JSON.parse(attr.value) if attr.name.match?(/posts_.+/)
+          end
+        end
+
+        def write_db
+          client.put_attributes(
+            {
+              domain_name: DOMAIN_NAME,
+              item_name: ITEM_NAME,
+              attributes: prepare_db_attrs
+            }
+          )
+        end
+
+        def prepare_db_attrs
+          attrs = [
+            {
+              name: "reddit_token",
+              value: @reddit_token,
+              replace: true
+            }
+          ]
+
+          @posts.each do |subreddit, values|
+            attrs << { name: "posts_#{subreddit}", value: values.to_json, replace: true }
+          end
+
+          attrs
+        end
+
+        def assign_default_values
+          @reddit_token = ""
+          @posts = {}
+        end
+
+        def create_domain
+          res = client.list_domains
+          return unless res.successful?
+
+          return if res.domain_names.include?(DOMAIN_NAME)
+
+          client.create_domain({ domain_name: DOMAIN_NAME })
+        end
+      end
+    end
+  end
+end

data/lib/reddit_to_telegram/store/memory.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RedditToTelegram
+  module Store
+    class Memory
+      class << self
+        attr_accessor :reddit_token
+
+        @posts = {}
+
+        def setup; end
+
+        def add_post(subreddit, id)
+          @posts[subreddit] = [] if @posts[subreddit].nil?
+          @posts[subreddit] << id
+          @posts[subreddit].shift if @posts[subreddit].count > Store::MAX_STORED_POSTS
+        end
+
+        def dup_post?(subreddit, id)
+          return false if posts[subreddit].nil?
+
+          posts[subreddit].include?(id)
+        end
+
+        def posts
+          @posts ||= {}
+        end
+      end
+    end
+  end
+end

data/lib/reddit_to_telegram/store/temp_file.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "json"
+
+module RedditToTelegram
+  module Store
+    class TempFile
+      STORE_FILE_DIR = "#{Dir.pwd}/tmp/store.json".freeze
+
+      class << self
+        attr_reader :reddit_token, :posts
+
+        @reddit_token = nil
+        @posts = {}
+
+        def setup
+          read_file
+        end
+
+        def reddit_token=(val)
+          @reddit_token = val
+          write_file
+        end
+
+        def add_post(subreddit, id)
+          @posts[subreddit] = [] if @posts[subreddit].nil?
+          @posts[subreddit] << id
+          @posts[subreddit].shift if @posts[subreddit].count > Store::MAX_STORED_POSTS
+          write_file
+        end
+
+        def dup_post?(subreddit, id)
+          return false if posts[subreddit].nil?
+
+          posts[subreddit].include?(id)
+        end
+
+        def read_file
+          return assign_default_values unless File.exist?(STORE_FILE_DIR)
+
+          file = File.read(STORE_FILE_DIR)
+          data = JSON.parse(file)
+          @reddit_token = data["reddit_token"]
+          @posts = {}
+          data.each do |key, value|
+            @posts[key.split("_").last.to_sym] = value if key.match?(/posts_.+/)
+          end
+        end
+
+        def write_file
+          data = { reddit_token: @reddit_token }
+          @posts.each do |subreddit, values|
+            data["posts_#{subreddit}".to_sym] = values
+          end
+          File.open(STORE_FILE_DIR, "w") { |f| f.write(data.to_json) }
+        end
+
+        def assign_default_values
+          @reddit_token = nil
+          @posts = {}
+        end
+      end
+    end
+  end
+end

data/lib/reddit_to_telegram/store.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "store/aws_simple_db"
+require_relative "store/memory"
+require_relative "store/temp_file"
+
+module RedditToTelegram
+  module Store
+    MAX_STORED_POSTS = Vars.max_stored_posts ? Vars.max_stored_posts - 1 : 24
+    STORE_MAP = {
+      aws_simple_db: "RedditToTelegram::Store::AWSSimpleDB",
+      memory: "RedditToTelegram::Store::Memory",
+      temp_file: "RedditToTelegram::Store::TempFile"
+    }.freeze
+    DEFAULT_STORE = :aws_simple_db
+
+    STORE = Object.const_get("RedditToTelegram::Store::AWSSimpleDB")
+
+    class << self
+      attr_accessor :active
+
+      def setup(selected_store = DEFAULT_STORE)
+        self.active = Object.const_get(STORE_MAP[selected_store.to_sym])
+        active.send(:setup)
+      end
+    end
+
+    class Reddit
+      class << self
+        def token
+          Store.active.send(:reddit_token)
+        end
+
+        def token=(val)
+          Store.active.send(:reddit_token=, val)
+        end
+      end
+    end
+
+    class Posts
+      class << self
+        def add(subreddit, id)
+          Store.active.send(:add_post, subreddit, id)
+        end
+
+        def dup?(subreddit, id)
+          Store.active.send(:dup_post?, subreddit, id)
+        end
+      end
+    end
+  end
+end

data/lib/reddit_to_telegram/telegram/post.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require "httparty"
+require_relative "prepare_request"
+require_relative "video"
+
+module RedditToTelegram
+  module Telegram
+    class Post
+      include HTTParty
+
+      BASE_URI = "https://api.telegram.org/bot"
+      JSON_HEADERS = { "Content-Type" => "application/json", "Accept" => "application/json" }.freeze
+      FORM_HEADERS = { "Content-Type" => "multipart/form-data", "Accept" => "application/json" }.freeze
+      METHOD_MAP = {
+        image: :photo,
+        gallery: :mediagroup,
+        text: :message,
+        video: :video
+      }.freeze
+
+      class << self
+        def push(post, channel)
+          HTTParty.post(
+            "#{BASE_URI}#{Vars::Telegram.bot_token}/send#{METHOD_MAP[post[:type]]}",
+            **params(post, channel)
+          )
+
+          push({ type: :text, text: body[:caption] }, channel) if post[:type] == :gallery
+          Video.delete_file if post[:type] == :video
+        end
+
+        def params(post, channel)
+          binary = post.dig(:misc)&.dig(:binary)
+          body = PrepareRequest.body(post, channel)
+
+          pars = {
+            body: binary ? body : body.to_json,
+            headers: binary ? FORM_HEADERS : JSON_HEADERS
+          }
+          pars[:multipart] = true if binary
+          pars
+        end
+      end
+    end
+  end
+end

data/lib/reddit_to_telegram/telegram/prepare_request.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative "video"
+
+module RedditToTelegram
+  module Telegram
+    class PrepareRequest
+      class << self
+        def body(post, chat_id)
+          case post[:type]
+          when :image
+            { chat_id: "@#{chat_id}", photo: post[:media], caption: prepare_text(post, chat_id) }
+          when :gallery
+            { chat_id: "@#{chat_id}", media: prepare_gallery_media(post), caption: prepare_text(post, chat_id) }
+          when :text
+            { chat_id: "@#{chat_id}", text: prepare_text(post, chat_id) }
+          when :video
+            { chat_id: "@#{chat_id}", video: prepare_video(post), caption: prepare_text(post, chat_id) }
+          end
+        end
+
+        def prepare_text(post, chat_id)
+          id = post[:id].split("_")[1]
+          "#{post[:text]}\n\nhttps://redd.it/#{id}\n@#{chat_id}"
+        end
+
+        def prepare_gallery_media(post)
+          Array(post[:media]).map { |link| { type: "photo", media: link } }
+        end
+
+        def prepare_video(post)
+          return post[:media] unless post[:misc][:binary]
+
+          Video.from_link(post[:media])
+          File.open(Video::TEMP_VIDEO_PATH)
+        end
+      end
+    end
+  end
+end

data/lib/reddit_to_telegram/telegram/video.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "open-uri"
+
+module RedditToTelegram
+  module Telegram
+    class Video
+      TEMP_VIDEO_PATH = "#{Dir.pwd}/tmp/video.mp4".freeze
+
+      class << self
+        def from_link(link)
+          download = URI.parse(link).open
+          IO.copy_stream(download, TEMP_VIDEO_PATH)
+        end
+
+        def delete_file
+          f = File.open(TEMP_VIDEO_PATH, "r")
+        ensure
+          f.close unless f.nil? || f.closed?
+          File.delete(TEMP_VIDEO_PATH) if File.exist?(TEMP_VIDEO_PATH)
+        end
+      end
+    end
+  end
+end

data/lib/reddit_to_telegram/vars.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RedditToTelegram
+  module Vars
+    class << self
+      # rubocop:disable Metrics/ParameterLists
+      def assign_values(
+        max_stored_posts:,
+        aws_access_key_id:,
+        aws_secret_access_key:,
+        aws_region:,
+        reddit_client_id:,
+        reddit_client_secret:,
+        telegram_bot_token:
+      )
+
+        @max_stored_posts = max_stored_posts
+        AWS.instance_variable_set(:@access_key_id, aws_access_key_id)
+        AWS.instance_variable_set(:@secret_access_key, aws_secret_access_key)
+        AWS.instance_variable_set(:@region, aws_region)
+        Reddit.instance_variable_set(:@client_id, reddit_client_id)
+        Reddit.instance_variable_set(:@client_secret, reddit_client_secret)
+        Telegram.instance_variable_set(:@bot_token, telegram_bot_token)
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      def max_stored_posts
+        @max_stored_posts ||= ENV["RTT_MAX_STORED_POSTS"].to_i || 25
+      end
+    end
+
+    class AWS
+      class << self
+        def access_key_id
+          @access_key_id ||= ENV["RTT_AWS_ACCESS_KEY_ID"]
+        end
+
+        def secret_access_key
+          @secret_access_key ||= ENV["RTT_AWS_SECRET_ACCESS_KEY"]
+        end
+
+        def region
+          @region ||= ENV["RTT_AWS_REGION"]
+        end
+      end
+    end
+
+    class Reddit
+      class << self
+        def client_id
+          @client_id ||= ENV["RTT_REDDIT_CLIENT_ID"]
+        end
+
+        def client_secret
+          @client_secret ||= ENV["RTT_REDDIT_CLIENT_SECRET"]
+        end
+      end
+    end
+
+    class Telegram
+      class << self
+        def bot_token
+          @bot_token ||= ENV["RTT_TELEGRAM_BOT_TOKEN"]
+        end
+      end
+    end
+  end
+end

data/lib/reddit_to_telegram/version.rb

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

data/reddit-to-telegram.gemspec

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+$:.push File.expand_path("../lib", __FILE__)
+require "reddit_to_telegram/version"
+
+Gem::Specification.new do |s|
+  s.name        = "reddit-to-telegram"
+  s.version     = RedditToTelegram::VERSION
+  s.summary     = "Fetches hot posts from reddit and pushes them to telegram"
+  s.description = "This gem makes simple reddit-to-telegram ruby bots easy to create"
+  s.authors     = ["Mark Tityuk"]
+  s.email       = "mark.tityuk@gmail.com"
+  s.files       = `git ls-files`.split("\n")
+  s.homepage    = "https://github.com/dersnek/reddit-to-telegram"
+  s.license     = "MIT"
+
+  s.add_dependency "aws-sdk-simpledb"
+  s.add_dependency "httparty"
+
+  s.add_development_dependency "rubocop"
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: reddit-to-telegram
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mark Tityuk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2024-01-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-simpledb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: This gem makes simple reddit-to-telegram ruby bots easy to create
+email: mark.tityuk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".tool-versions"
+- Gemfile
+- Gemfile.lock
+- README.md
+- lib/reddit-to-telegram.rb
+- lib/reddit_to_telegram/reddit/auth.rb
+- lib/reddit_to_telegram/reddit/fetch.rb
+- lib/reddit_to_telegram/reddit/output.rb
+- lib/reddit_to_telegram/store.rb
+- lib/reddit_to_telegram/store/aws_simple_db.rb
+- lib/reddit_to_telegram/store/memory.rb
+- lib/reddit_to_telegram/store/temp_file.rb
+- lib/reddit_to_telegram/telegram/post.rb
+- lib/reddit_to_telegram/telegram/prepare_request.rb
+- lib/reddit_to_telegram/telegram/video.rb
+- lib/reddit_to_telegram/vars.rb
+- lib/reddit_to_telegram/version.rb
+- reddit-to-telegram.gemspec
+- tmp/.keep
+homepage: https://github.com/dersnek/reddit-to-telegram
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key: 
+specification_version: 4
+summary: Fetches hot posts from reddit and pushes them to telegram
+test_files: []