twitter_tweet_bot 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8a2b63d602240d7b56c182f40ec07306600818005a0b5d35b9cf6f8a93e405cf
+  data.tar.gz: 9c2b1c30135546c64319ddaf38bf75ee15184d9d3a7b0d42404c96380b036ba0
+SHA512:
+  metadata.gz: 453ac53d4a7240829771bee7d8a94e5b1b1a5bfebdb26352fbe63579bdad9df20ac2da805da551f8a8d5f9a20ab9c3e6361dbcc5c8c96e8a14f42e3201d0d7c9
+  data.tar.gz: 6ae79d1b5ac9de5a26830eb28ba6ae8a62e0df6e85beda2ae9975b3d625bfab7495b5b5d6a704dfd66e5b6327b7e04406b86dfd3d8587d0140058889ce73922a

data/README.md

@@ -0,0 +1,172 @@
+# twitter_tweet_bot
+Tweet Bot with Twitter's V2 API.<br/>
+（by Twitter's V2 API / OAuth 2.0 with PCKE）
+
+## Getting Started
+
+```rb
+# Gemfile
+gem 'twitter_tweet_bot'
+```
+
+Then run `bundle install`.
+
+## Usage
+
+```rb
+require 'twitter_tweet_bot'
+
+TwitterTweetBot.post_tweet(<ACEESS_TOKEN>, 'Yeah!')
+```
+
+1. Congiuration
+2. Issue Authorization URL
+3. Go to Authorization URL
+4. Fetch Access Token
+5. Post Tweet
+
+<details>
+
+<summary>Details</summary>
+
+#### Step1. Congiuration
+
+```rb
+require 'twitter_tweet_bot'
+
+TwitterTweetBot.configure do |config|
+  # Twitter's Bot Name (any)
+  config.name = 'iambot'
+  # Twitter's Client ID
+  config.client_id = '*****'
+  # Twitter's Client Secret
+  config.client_secret = '*****'
+  # Redirect URL After Authorization
+  config.redirect_uri = 'https://example.com/twitter/callback'
+  # Twitter's App Scopes with OAuth 2.0
+  config.scopes = ['tweet.read', 'tweet.write', 'users.read', 'offline.access']
+end
+```
+
+#### Step2. Issue an authorization url
+
+```rb
+authorization = TwitterTweetBot.authorization
+# =>
+#  #<TwitterTweetBot::Entity::Authorization
+#   @code_verifier="*****",
+#   @state="***",
+#   @url="https://twitter.com/i/oauth2/authorize?response_type=code&redirect_uri=<YOUR_REDIRECT_URI>&client_id=<YOUR_CLIENT_ID>&scope=<SCOPES>&code_challenge=*****&code_challenge_method=S256&state=***">
+```
+
+#### Step3. Rerirect (or Go) to `authorization.url`
+
+And smash `"Authorize app"`.
+
+If authorized, redirected to your `config.redirect_uri`.<br/>
+Check **CODE** in Twitter's response.
+
+```
+e.g. https://example.com/twitter/callback?state=***&code=*****
+```
+
+#### Step4. Fetch an access token
+
+```rb
+token = TwitterTweetBot.fetch_token('<CODE>', authorization.code_verifier)
+# =>
+#  #<TwitterTweetBot::Entity::Token
+#   @access_token="<YOUR_ACCESS_TOKEN>",
+#   @expires_in=7200,
+#   @refresh_token="<YOUR_REFRESH_TOKEN>",
+#   @scope="tweet.write users.read tweet.read offline.access",
+#   @token_type="bearer">
+```
+
+#### Step5. Post a tweet
+
+```rb
+TwitterTweetBot.post_tweet(token.access_token, 'Yeah!')
+# =>
+#  #<TwitterTweetBot::Entity::Tweet
+#   @edit_history_tweet_ids=["0123456789"],
+#   @id="0123456789",
+#   @text="Yeah!">
+```
+
+#### Ex. Restore an access token (required `'offline.access'` in scopes)
+
+```rb
+TwitterTweetBot.refresh_token(token.refresh_token)
+```
+</details>
+
+### Caching
+
+`TwitterTweetBot` can cache follow variables automatically in any store (like `Rails.cache`).
+
+- `code_verifier`
+- `state`
+- `access_token`
+- `refresh_token`
+
+If needed, require `'twitter_tweet_bot/cache'`.
+
+```rb
+require 'twitter_tweet_bot/cache'
+
+TwitterTweetBot.post_tweet('Yeah!')
+```
+
+<details>
+
+<summary>Details</summary>
+
+#### Step1. Congiuration
+
+```rb
+require 'twitter_tweet_bot'
+
+TwitterTweetBot.configure do |config|
+  # ...
+
+  # Any Cache Store (required `#write(key, value)` and `#read(key)` implementation).
+  config.cache_provider = ActiveSupport::Cache.lookup_store(:file_store, '../tmp/cache')
+end
+```
+
+#### Step2. Issue an authorization url
+
+```rb
+# `code_verifier` and `state` will be cached.
+TwitterTweetBot.authorization
+```
+
+#### Step3. Fetch an access token
+
+
+```rb
+# `access_token` and `refresh_token` will be cached.
+TwitterTweetBot.fetch_token('<CODE>')
+```
+
+Don't need to pass `code_verifier`.<br/>
+(resolved from cache)
+
+#### Step4. Post a tweet
+
+```rb
+TwitterTweetBot.post_tweet('Yeah!')
+```
+
+Don't need to pass `access_token`.<br/>
+(resolved from cache)
+
+#### Ex. Check a cache
+
+```rb
+TwitterTweetBot.client.cache.read
+# =>
+#  { :code_verifier=>"*****", :state=>"***", :access_token=>"*****", :refresh_token=>"*****" }
+```
+</details>

data/lib/twitter_tweet_bot/api/access_token.rb

@@ -0,0 +1,64 @@
+require 'base64'
+require 'twitter_tweet_bot/api/http'
+
+module TwitterTweetBot
+  module API
+    class AccessToken
+      private_class_method :new
+
+      include HTTP
+
+      API_ENDPOTNT = 'https://api.twitter.com/2/oauth2/token'.freeze
+      GRANT_TYPE = 'authorization_code'.freeze
+
+      def self.fetch(
+        client_id:,
+        client_secret:,
+        redirect_uri:,
+        code:,
+        code_verifier:,
+        **
+      )
+        new(client_id, client_secret, redirect_uri)
+          .fetch(code, code_verifier)
+      end
+
+      def initialize(client_id, client_secret, redirect_uri)
+        @client_id = client_id
+        @client_secret = client_secret
+        @redirect_uri = redirect_uri
+      end
+
+      def fetch(code, code_verifier)
+        request(
+          :post_form,
+          API_ENDPOTNT,
+          body_with(code, code_verifier),
+          headers
+        )
+      end
+
+      private
+
+      attr_reader :client_id, :client_secret, :redirect_uri
+
+      def body_with(code, code_verifier)
+        {
+          grant_type: GRANT_TYPE,
+          code: code,
+          code_verifier: code_verifier,
+          redirect_uri: redirect_uri
+        }
+      end
+
+      def headers
+        basic_authorization_header(
+          Base64.strict_encode64("#{client_id}:#{client_secret}")
+        )
+      end
+
+      private_constant :API_ENDPOTNT,
+                       :GRANT_TYPE
+    end
+  end
+end

data/lib/twitter_tweet_bot/api/authorization/secure_code.rb

@@ -0,0 +1,77 @@
+require 'base64'
+require 'securerandom'
+require 'openssl'
+
+module TwitterTweetBot
+  module API
+    class Authorization
+      class SecureCode
+        DEFAULT_CHALLENGE_SIZE = 64
+        DEFAULT_CHALLENGE_METHOD = 'S256'.freeze
+        DEFAULT_STATE_SIZE = 32
+
+        class << self
+          def code_verifier(size = DEFAULT_CHALLENGE_SIZE)
+            encode(random_chars(size))
+          end
+
+          def state(size = DEFAULT_STATE_SIZE)
+            encode(random_chars(size))
+          end
+
+          def code_challenge(verifier, challenge_method = DEFAULT_CHALLENGE_METHOD)
+            case challenge_method
+            when 'S256'
+              encode(
+                Base64.urlsafe_encode64(digest_by_sha256(verifier), padding: false)
+              )
+            else # 'plain'
+              verifier
+            end
+          end
+
+          private
+
+          def random_chars(size)
+            SecureRandom.urlsafe_base64(size / 4 * 3, false)
+          end
+
+          def digest_by_sha256(chars)
+            OpenSSL::Digest::SHA256.digest(chars)
+          end
+
+          def encode(chars)
+            chars.encode(Encoding::UTF_8)
+          end
+        end
+
+        def initialize(code_verifier: nil, code_challenge_method: nil, state: nil)
+          @code_verifier = code_verifier
+          @code_challenge_method = code_challenge_method
+          @state = state
+        end
+
+        def code_verifier
+          @code_verifier ||= self.class.code_verifier
+        end
+
+        def code_challenge
+          @code_challenge ||= \
+            self.class.code_challenge(code_verifier, code_challenge_method)
+        end
+
+        def code_challenge_method
+          @code_challenge_method ||= DEFAULT_CHALLENGE_METHOD
+        end
+
+        def state
+          @state ||= self.class.state
+        end
+
+        private_constant :DEFAULT_CHALLENGE_SIZE,
+                         :DEFAULT_CHALLENGE_METHOD,
+                         :DEFAULT_STATE_SIZE
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/api/authorization.rb

@@ -0,0 +1,71 @@
+require 'twitter_tweet_bot/api/authorization/secure_code'
+require 'twitter_tweet_bot/api/http'
+
+module TwitterTweetBot
+  module API
+    class Authorization
+      private_class_method :new
+
+      include HTTP
+
+      AUTH_URL = 'https://twitter.com/i/oauth2/authorize'.freeze
+      RESPONSE_TYPE = 'code'.freeze
+
+      def self.authorization(
+        client_id:,
+        redirect_uri:,
+        scopes:,
+        code_verifier:,
+        code_challenge_method:,
+        state:,
+        **
+      )
+        new(client_id, redirect_uri, scopes)
+          .authorization(code_verifier, code_challenge_method, state)
+      end
+
+      def initialize(client_id, redirect_uri, scopes)
+        @client_id = client_id
+        @redirect_uri = redirect_uri
+        @scopes = scopes
+      end
+
+      def authorization(code_verifier, code_challenge_method, state)
+        secure_code = Authorization::SecureCode.new(
+          code_verifier: code_verifier,
+          code_challenge_method: code_challenge_method,
+          state: state
+        )
+        uri = build_uri(AUTH_URL, build_body(secure_code))
+        return as_hash(uri.to_s, secure_code)
+      end
+
+      private
+
+      attr_reader :client_id, :redirect_uri, :scopes
+
+      def build_body(secure_code)
+        {
+          response_type: RESPONSE_TYPE,
+          redirect_uri: redirect_uri,
+          client_id: client_id,
+          scope: scopes.join(' '),
+          code_challenge: secure_code.code_challenge,
+          code_challenge_method: secure_code.code_challenge_method,
+          state: secure_code.state
+        }
+      end
+
+      def as_hash(url, secure_code)
+        {
+          url: url,
+          code_verifier: secure_code.code_verifier,
+          state: secure_code.state
+        }
+      end
+
+      private_constant :AUTH_URL,
+                       :RESPONSE_TYPE
+    end
+  end
+end

data/lib/twitter_tweet_bot/api/http/base.rb

@@ -0,0 +1,17 @@
+require 'net/http'
+
+module TwitterTweetBot
+  module API
+    module HTTP
+      module Base
+        def perform_request(uri, request)
+          Net::HTTP.start(
+            uri.host, uri.port, use_ssl: uri.scheme == 'https'
+          ) do |http|
+            http.request(request)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/api/http/error.rb

@@ -0,0 +1,24 @@
+module TwitterTweetBot
+  module API
+    module HTTP
+      module Error
+        class RequestFaild < StandardError
+          attr_reader :code, :body
+
+          def initialize(code, body)
+            @code = code
+            @body = body
+          end
+
+          def inspect
+            "#<#{self.class} #{code} #{body}>"
+          end
+        end
+
+        def request_error!(code, body)
+          raise RequestFaild.new(code, body)
+        end
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/api/http/get.rb

@@ -0,0 +1,28 @@
+require 'uri'
+require 'net/http'
+require 'twitter_tweet_bot/api/http/base'
+
+module TwitterTweetBot
+  module API
+    module HTTP
+      module Get
+        include Base
+
+        def request_get(url, body, headers = {})
+          uri = build_uri(url, body)
+          perform_request(
+            uri, Net::HTTP::Get.new(uri, headers)
+          )
+        end
+
+        private
+
+        def build_uri(url, body)
+          URI.parse(url).tap do |uri|
+            uri.query = URI.encode_www_form(body)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/api/http/headers.rb

@@ -0,0 +1,21 @@
+require 'uri'
+require 'net/http'
+
+module TwitterTweetBot
+  module API
+    module HTTP
+      module Headers
+        BASIC_AUTHORIZATION = 'Basic %<credentials>s'.freeze
+        BEARER_AUTHORIZATION = 'Bearer %<credentials>s'.freeze
+
+        def basic_authorization_header(credentials)
+          { authorization: format(BASIC_AUTHORIZATION, credentials: credentials) }
+        end
+
+        def bearer_authorization_header(credentials)
+          { authorization: format(BEARER_AUTHORIZATION, credentials: credentials) }
+        end
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/api/http/post.rb

@@ -0,0 +1,46 @@
+require 'uri'
+require 'net/http'
+require 'json'
+require 'twitter_tweet_bot/api/http/base'
+
+module TwitterTweetBot
+  module API
+    module HTTP
+      module Post
+        include Base
+
+        JSON_CONTENT_TYPE = 'application/json'.freeze
+        URLENCODED_CONTENT_TYPE = 'application/x-www-form-urlencoded; charset=UTF-8'.freeze
+
+        def request_post_form(url, body, headers = {})
+          request_post(
+            url,
+            URI.encode_www_form(body),
+            headers.merge('content-type' => URLENCODED_CONTENT_TYPE)
+          )
+        end
+
+        def request_post_json(url, body, headers = {})
+          request_post(
+            url,
+            body.to_json,
+            headers.merge('content-type' => JSON_CONTENT_TYPE)
+          )
+        end
+
+        private
+
+        def request_post(url, body, headers)
+          uri = URI.parse(url)
+          perform_request(
+            uri,
+            Net::HTTP::Post.new(uri.path, headers).tap { |req| req.body = body }
+          )
+        end
+
+        private_constant :JSON_CONTENT_TYPE,
+                        :URLENCODED_CONTENT_TYPE
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/api/http.rb

@@ -0,0 +1,31 @@
+require 'twitter_tweet_bot/api/http/error'
+require 'twitter_tweet_bot/api/http/headers'
+require 'twitter_tweet_bot/api/http/get'
+require 'twitter_tweet_bot/api/http/post'
+
+module TwitterTweetBot
+  module API
+    module HTTP
+      include Error
+      include Headers
+      include Get
+      include Post
+
+      def request(method, url, body, headers)
+        response = send("request_#{method}", url, body, headers)
+        success_or_fail!(response)
+      end
+
+      private
+
+      def success_or_fail!(response)
+        case response
+        when Net::HTTPSuccess, Net::HTTPRedirection
+          response.body
+        else
+          request_error!(response.code, response.body)
+        end
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/api/refresh_token.rb

@@ -0,0 +1,55 @@
+require 'base64'
+require 'twitter_tweet_bot/api/http'
+
+module TwitterTweetBot
+  module API
+    class RefreshToken
+      private_class_method :new
+
+      include HTTP
+
+      API_ENDPOTNT = 'https://api.twitter.com/2/oauth2/token'.freeze
+      GRANT_TYPE = 'refresh_token'.freeze
+
+      def self.fetch(client_id:, client_secret:, refresh_token:, **)
+        new(client_id, client_secret)
+          .fetch(refresh_token)
+      end
+
+      def initialize(client_id, client_secret)
+        @client_id = client_id
+        @client_secret = client_secret
+      end
+
+      def fetch(refresh_token)
+        request(
+          :post_form,
+          API_ENDPOTNT,
+          body_with(refresh_token),
+          headers
+        )
+      end
+
+      private
+
+      attr_reader :client_id, :client_secret
+
+      def body_with(refresh_token)
+        {
+          grant_type: GRANT_TYPE,
+          refresh_token: refresh_token,
+          client_id: client_id
+        }
+      end
+
+      def headers
+        basic_authorization_header(
+          Base64.strict_encode64("#{client_id}:#{client_secret}")
+        )
+      end
+
+      private_constant :API_ENDPOTNT,
+                       :GRANT_TYPE
+    end
+  end
+end

data/lib/twitter_tweet_bot/api/tweet.rb

@@ -0,0 +1,36 @@
+require 'twitter_tweet_bot/api/http'
+
+module TwitterTweetBot
+  module API
+    class Tweet
+      private_class_method :new
+
+      include HTTP
+
+      API_ENDPOTNT = 'https://api.twitter.com/2/tweets'.freeze
+
+      def self.post(access_token:, text:, **)
+        new(access_token).post(text)
+      end
+
+      def initialize(access_token)
+        @access_token = access_token
+      end
+
+      def post(text)
+        request(
+          :post_json,
+          API_ENDPOTNT,
+          { text: text },
+          bearer_authorization_header(access_token)
+        )
+      end
+
+      private
+
+      attr_accessor :access_token
+
+      private_constant :API_ENDPOTNT
+    end
+  end
+end

data/lib/twitter_tweet_bot/api/users_me.rb

@@ -0,0 +1,36 @@
+require 'twitter_tweet_bot/api/http'
+
+module TwitterTweetBot
+  module API
+    class UsersMe
+      private_class_method :new
+
+      include HTTP
+
+      API_ENDPOTNT = 'https://api.twitter.com/2/users/me'.freeze
+
+      def self.fetch(access_token:, fields:, **)
+        new(access_token).fetch(fields)
+      end
+
+      def initialize(access_token)
+        @access_token = access_token
+      end
+
+      def fetch(fields)
+        request(
+          :get,
+          API_ENDPOTNT,
+          fields,
+          bearer_authorization_header(access_token)
+        )
+      end
+
+      private
+
+      attr_accessor :access_token
+
+      private_constant :API_ENDPOTNT
+    end
+  end
+end

data/lib/twitter_tweet_bot/api.rb

@@ -0,0 +1,5 @@
+require 'twitter_tweet_bot/api/access_token'
+require 'twitter_tweet_bot/api/authorization'
+require 'twitter_tweet_bot/api/refresh_token'
+require 'twitter_tweet_bot/api/tweet'
+require 'twitter_tweet_bot/api/users_me'

data/lib/twitter_tweet_bot/cache/caching.rb

@@ -0,0 +1,32 @@
+module TwitterTweetBot
+  module Cache
+    module Caching
+      def cache
+        config.cache
+      end
+
+      def with_cache(&block)
+        current_cache = read_cache
+        result = yield(current_cache)
+        write_cache(current_cache, result)
+
+        result
+      end
+
+      private
+
+      def read_cache
+        cache.read || {}
+      end
+
+      def write_cache(current, value)
+        cache.write(current.merge(**to_cache_object(value)))
+      end
+
+      def to_cache_object(object)
+        return {} unless object.respond_to?(:to_cache)
+        object.to_cache
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/cache/client_ext.rb

@@ -0,0 +1,29 @@
+require 'twitter_tweet_bot/cache/caching'
+
+module TwitterTweetBot
+  module Cache
+    module ClientExt
+      include Caching
+
+      def authorization(*)
+        with_cache { super }
+      end
+
+      def fetch_token(*args)
+        with_cache { |cache| super(*args, cache[:code_verifier]) }
+      end
+
+      def refresh_token
+        with_cache { |cache| super(cache[:refresh_token]) }
+      end
+
+      def post_tweet(*args)
+        with_cache { |cache| super(cache[:access_token], *args) }
+      end
+
+      def users_me(*args)
+        with_cache { |cache| super(cache[:access_token], *args) }
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/cache/configuration_ext.rb

@@ -0,0 +1,18 @@
+require 'twitter_tweet_bot/cache/store'
+
+module TwitterTweetBot
+  module Cache
+    module ConfigrationExt
+      attr_accessor :cache_provider, :cache
+
+      def initialize(cache_provider: nil, **kwargs)
+        @cache_provider = cache_provider
+        super(**kwargs)
+      end
+
+      def cache
+        @cache ||= Store.new(name, cache_provider)
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/cache/entity_ext/authorization.rb

@@ -0,0 +1,16 @@
+require 'twitter_tweet_bot/cache/entity_ext/base'
+
+module TwitterTweetBot
+  module Cache
+    module EntityExt
+      module Authorization
+        include Base
+
+        act_as_cache_entity(
+          :code_verifier,
+          :state
+        )
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/cache/entity_ext/base.rb

@@ -0,0 +1,31 @@
+require 'active_support/concern'
+require 'active_support/core_ext/module/attribute_accessors'
+
+module TwitterTweetBot
+  module Cache
+    module EntityExt
+      module Base
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def act_as_cache_entity(*cache_fields)
+            mattr_reader :cache_fields,
+                         default: cache_fields
+          end
+        end
+
+        def to_cache
+          cache_fields.reduce({}) do |hash, cache_field|
+            next hash unless respond_to?(cache_field)
+
+            value = send(cache_field)
+            next hash if value.nil?
+            hash[cache_field] = value
+
+            hash
+          end
+        end
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/cache/entity_ext/token.rb

@@ -0,0 +1,16 @@
+require 'twitter_tweet_bot/cache/entity_ext/base'
+
+module TwitterTweetBot
+  module Cache
+    module EntityExt
+      module Token
+        include Base
+
+        act_as_cache_entity(
+          :access_token,
+          :refresh_token
+        )
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/cache/entity_ext.rb

@@ -0,0 +1,2 @@
+require 'twitter_tweet_bot/cache/entity_ext/authorization'
+require 'twitter_tweet_bot/cache/entity_ext/token'

data/lib/twitter_tweet_bot/cache/store.rb

@@ -0,0 +1,41 @@
+require 'json'
+
+module TwitterTweetBot
+  module Cache
+    class Store
+      CACHE_BASE_KEY = 'twitter_tweet_bot'.freeze
+
+      def initialize(name, provider)
+        @name = name
+        @provider = provider
+      end
+
+      def write(value)
+        provider.write(cache_key, serialize_value(value))
+      end
+
+      def read
+        deserialize_value(provider.read(cache_key))
+      end
+
+      private
+
+      attr_reader :name, :provider
+
+      def cache_key
+        File.join(CACHE_BASE_KEY, name.to_s)
+      end
+
+      def serialize_value(value)
+        value.to_json
+      end
+
+      def deserialize_value(value)
+        return {} if value.nil?
+        JSON.parse(value, symbolize_names: true)
+      end
+
+      private_constant :CACHE_BASE_KEY
+    end
+  end
+end

data/lib/twitter_tweet_bot/cache.rb

@@ -0,0 +1,13 @@
+require 'twitter_tweet_bot'
+
+require 'twitter_tweet_bot/cache/client_ext'
+require 'twitter_tweet_bot/cache/configuration_ext'
+require 'twitter_tweet_bot/cache/entity_ext'
+
+module TwitterTweetBot
+  Client.prepend(Cache::ClientExt)
+  Configration.prepend(Cache::ConfigrationExt)
+
+  Entity::Authorization.include(Cache::EntityExt::Authorization)
+  Entity::Token.include(Cache::EntityExt::Token)
+end

data/lib/twitter_tweet_bot/client/api.rb

@@ -0,0 +1,50 @@
+require 'twitter_tweet_bot/api'
+
+module TwitterTweetBot
+  class Client
+    module API
+      def authorization(code_verifier = nil, code_challenge_method = nil, state = nil)
+        TwitterTweetBot::API::Authorization.authorization(
+          **params_with_config(
+            code_verifier: code_verifier,
+            code_challenge_method: code_challenge_method,
+            state: state
+          )
+        )
+      end
+
+      def fetch_token(code, code_verifier)
+        TwitterTweetBot::API::AccessToken.fetch(
+          **params_with_config(
+            code: code,
+            code_verifier: code_verifier
+          )
+        )
+      end
+
+      def refresh_token(refresh_token)
+        TwitterTweetBot::API::RefreshToken.fetch(
+          **params_with_config(refresh_token: refresh_token)
+        )
+      end
+
+      def post_tweet(access_token, text)
+        TwitterTweetBot::API::Tweet.post(
+          **params_with_config(access_token: access_token, text: text)
+        )
+      end
+
+      def users_me(access_token, fields = {})
+        TwitterTweetBot::API::UsersMe.fetch(
+          **params_with_config(access_token: access_token, fields: fields)
+        )
+      end
+
+      private
+
+      def params_with_config(**params)
+        config.to_hash.merge(**params)
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/client/entity.rb

@@ -0,0 +1,38 @@
+require 'json'
+require 'twitter_tweet_bot/entity'
+
+module TwitterTweetBot
+  class Client
+    module Entity
+      def authorization(*)
+        with_entity(TwitterTweetBot::Entity::Authorization) { super }
+      end
+
+      def fetch_token(*)
+        with_entity(TwitterTweetBot::Entity::Token) { parse_json(super) }
+      end
+
+      def refresh_token(*)
+        with_entity(TwitterTweetBot::Entity::Token) { parse_json(super) }
+      end
+
+      def post_tweet(*)
+        with_entity(TwitterTweetBot::Entity::Tweet) { parse_json(super) }
+      end
+
+      def users_me(*)
+        with_entity(TwitterTweetBot::Entity::User) { parse_json(super) }
+      end
+
+      private
+
+      def with_entity(entity_klass, &block)
+        entity_klass.new(yield)
+      end
+
+      def parse_json(body)
+        JSON.parse(body, symbolize_names: true)
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/client.rb

@@ -0,0 +1,17 @@
+require 'twitter_tweet_bot/client/api'
+require 'twitter_tweet_bot/client/entity'
+
+module TwitterTweetBot
+  class Client
+    include API
+    include Entity
+
+    def initialize(config)
+      @config = config
+    end
+
+    private
+
+    attr_accessor :config
+  end
+end

data/lib/twitter_tweet_bot/configration.rb

@@ -0,0 +1,32 @@
+module TwitterTweetBot
+  class Configration
+    attr_accessor :name,
+                  :client_id,
+                  :client_secret,
+                  :redirect_uri,
+                  :scopes
+
+    def initialize(
+      name: nil,
+      client_id: nil,
+      client_secret: nil,
+      redirect_uri: nil,
+      scopes: []
+    )
+      @name = name
+      @client_id = client_id
+      @client_secret = client_secret
+      @redirect_uri = redirect_uri
+      @scopes = scopes
+
+      yield self if block_given?
+    end
+
+    def to_hash
+      instance_variables.reduce({}) do |hash, key|
+        hash[key[1..].to_sym] = instance_variable_get(key)
+        hash
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/entity/authorization.rb

@@ -0,0 +1,15 @@
+require 'twitter_tweet_bot/entity/base'
+
+module TwitterTweetBot
+  module Entity
+    class Authorization
+      include Base
+
+      act_as_entity(
+        :url,
+        :code_verifier,
+        :state
+      )
+    end
+  end
+end

data/lib/twitter_tweet_bot/entity/base.rb

@@ -0,0 +1,32 @@
+require 'active_support/concern'
+require 'active_support/core_ext/class/attribute'
+
+module TwitterTweetBot
+  module Entity
+    module Base
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def act_as_entity(*fields)
+          class_attribute :fields,
+                          instance_writer: false,
+                          default: fields
+
+          attr_reader(*fields)
+        end
+      end
+
+      def initialize(json)
+        set_fields!(Hash(json))
+      end
+
+      private
+
+      def set_fields!(hash)
+        fields.each do |field|
+          instance_variable_set(:"@#{field}", hash[field])
+        end
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/entity/token.rb

@@ -0,0 +1,17 @@
+require 'twitter_tweet_bot/entity/base'
+
+module TwitterTweetBot
+  module Entity
+    class Token
+      include Base
+
+      act_as_entity(
+        :token_type,
+        :expires_in,
+        :access_token,
+        :refresh_token,
+        :scope
+      )
+    end
+  end
+end

data/lib/twitter_tweet_bot/entity/tweet.rb

@@ -0,0 +1,19 @@
+require 'twitter_tweet_bot/entity/base'
+
+module TwitterTweetBot
+  module Entity
+    class Tweet
+      include Base
+
+      act_as_entity(
+        :id,
+        :text,
+        :edit_history_tweet_ids
+      )
+
+      def initialize(data)
+        super Hash(data)[:data]
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/entity/user.rb

@@ -0,0 +1,20 @@
+
+require 'twitter_tweet_bot/entity/base'
+
+module TwitterTweetBot
+  module Entity
+    class User
+      include Base
+
+      act_as_entity(
+        :id,
+        :name,
+        :username
+      )
+
+      def initialize(data)
+        super Hash(data)[:data]
+      end
+    end
+  end
+end

data/lib/twitter_tweet_bot/entity.rb

@@ -0,0 +1,4 @@
+require 'twitter_tweet_bot/entity/authorization'
+require 'twitter_tweet_bot/entity/token'
+require 'twitter_tweet_bot/entity/tweet'
+require 'twitter_tweet_bot/entity/user'

data/lib/twitter_tweet_bot/version.rb

@@ -0,0 +1,3 @@
+module TwitterTweetBot
+  VERSION = '1.0.0'.freeze
+end

data/lib/twitter_tweet_bot.rb

@@ -0,0 +1,35 @@
+require 'twitter_tweet_bot/client'
+require 'twitter_tweet_bot/configration'
+require 'twitter_tweet_bot/version'
+
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/module/delegation'
+
+module TwitterTweetBot
+  NoConfigrationError = Class.new(StandardError).freeze
+
+  mattr_accessor :default_config
+
+  class << self
+    def configure(&block)
+      self.default_config = Configration.new(&block)
+    end
+
+    def client(config = nil)
+      Client.new(config || default_config!)
+    end
+
+    delegate :authorization,
+             :fetch_token,
+             :refresh_token,
+             :post_tweet,
+             :users_me,
+             to: :client
+
+    private
+
+    def default_config!
+      default_config or raise NoConfigrationError
+    end
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: twitter_tweet_bot
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- SongCastle
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+description: Ruby implementation for Twitter client, using V2 API and OAuth 2.0.
+email: "-"
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/twitter_tweet_bot.rb
+- lib/twitter_tweet_bot/api.rb
+- lib/twitter_tweet_bot/api/access_token.rb
+- lib/twitter_tweet_bot/api/authorization.rb
+- lib/twitter_tweet_bot/api/authorization/secure_code.rb
+- lib/twitter_tweet_bot/api/http.rb
+- lib/twitter_tweet_bot/api/http/base.rb
+- lib/twitter_tweet_bot/api/http/error.rb
+- lib/twitter_tweet_bot/api/http/get.rb
+- lib/twitter_tweet_bot/api/http/headers.rb
+- lib/twitter_tweet_bot/api/http/post.rb
+- lib/twitter_tweet_bot/api/refresh_token.rb
+- lib/twitter_tweet_bot/api/tweet.rb
+- lib/twitter_tweet_bot/api/users_me.rb
+- lib/twitter_tweet_bot/cache.rb
+- lib/twitter_tweet_bot/cache/caching.rb
+- lib/twitter_tweet_bot/cache/client_ext.rb
+- lib/twitter_tweet_bot/cache/configuration_ext.rb
+- lib/twitter_tweet_bot/cache/entity_ext.rb
+- lib/twitter_tweet_bot/cache/entity_ext/authorization.rb
+- lib/twitter_tweet_bot/cache/entity_ext/base.rb
+- lib/twitter_tweet_bot/cache/entity_ext/token.rb
+- lib/twitter_tweet_bot/cache/store.rb
+- lib/twitter_tweet_bot/client.rb
+- lib/twitter_tweet_bot/client/api.rb
+- lib/twitter_tweet_bot/client/entity.rb
+- lib/twitter_tweet_bot/configration.rb
+- lib/twitter_tweet_bot/entity.rb
+- lib/twitter_tweet_bot/entity/authorization.rb
+- lib/twitter_tweet_bot/entity/base.rb
+- lib/twitter_tweet_bot/entity/token.rb
+- lib/twitter_tweet_bot/entity/tweet.rb
+- lib/twitter_tweet_bot/entity/user.rb
+- lib/twitter_tweet_bot/version.rb
+homepage: https://github.com/SongCastle/twitter_tweet_bot
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Ruby implementation for Twitter twetting client
+test_files: []