jekyll-twitter-plugin 1.4.0 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eb81bd5f03311d7ea54536c4ae9b66a4958a0581
-  data.tar.gz: 8718758139ec729d224592a725e406e3fd18e795
+  metadata.gz: 4c1b655f7a4220868b0d2cd098cba068f4956e68
+  data.tar.gz: a2c010f3a7d65bd5c9fe5e2af53971fa25ca7105
 SHA512:
-  metadata.gz: 32e14f43bd34316445f6ac38eeb685b4fc5fa554a765022df00febfd45c8d153f4864144e95163e6f03e0fd6c4c46abf99a4bbd999715df4bf04c1c90fc683c0
-  data.tar.gz: a7a19a137770446e06eda37ee35ce540f880962d6e1f380b71ee8405d2602fdb2b49b7f803aed58e657eea5cda83acca6fa09bd64fd21f428dd1fe527243a708
+  metadata.gz: 4f83e487aac6acb23ff716b6384914d9f881abdbcddc249418bfa471702b918d5efc39700a943beae3eb1cf37513da84ef7fa2fa41f5a437df150b4e1b8be2f3
+  data.tar.gz: 969e54b10b302987d5a8f40d64a0e545216ff587e68f517bd3b510e2f610453f0cd7afa2109842b98e53dd3825b5efab2b0747c983b2e08759c58db807779914

data/.rubocop.yml

@@ -14,3 +14,7 @@ Style/FileName:
 
 Lint/AssignmentInCondition:
   Enabled: false
+
+AllCops:
+  Exclude:
+    - 'spec/integration_tests.rb'

data/.travis.yml

@@ -2,7 +2,6 @@ language: ruby
 cache: bundler
 sudo: false
 rvm:
-  - 1.9.3
   - 2.0.0
   - 2.1.0
   - 2.2.0

data/README.md

@@ -1,36 +1,61 @@
-## jekyll-twitter-plugin
+<img alt="Screenshot embedded tweet" src="https://raw.githubusercontent.com/rob-murray/jekyll-twitter-plugin/master/media/embedded-tweet.png" align="right" />
 
-A Liquid tag plugin for Jekyll that renders Tweets from Twitter API.
+# jekyll-twitter-plugin
+
+A Liquid tag plugin for Jekyll blogging engine that embeds Tweets, Timelines and more from Twitter API.
 
 [![Build Status](https://travis-ci.org/rob-murray/jekyll-twitter-plugin.svg?branch=master)](https://travis-ci.org/rob-murray/jekyll-twitter-plugin)
 [![Gem Version](https://badge.fury.io/rb/jekyll-twitter-plugin.svg)](http://badge.fury.io/rb/jekyll-twitter-plugin)
 
+---
 
-### Description
 
-A Liquid tag plugin for [Jekyll](http://jekyllrb.com/) that enables Twitter content to be used in any content served by Jekyll, content is fetched from the [Twitter API](https://dev.twitter.com/home).
+## Description
 
-It is based on the original [Jekyll Tweet Tag](https://github.com/scottwb/jekyll-tweet-tag) from [scottwb](https://github.com/scottwb/) which has not been updated since Twitter changed their API to require certain preconditions. This version uses the excellent [Twitter gem](https://github.com/sferik/twitter) to make requests and handle authentication.
+**jekyll-twitter-plugin** is a Liquid tag plugin for [Jekyll](http://jekyllrb.com/) that enables Twitter content to be used in any pages generated by Jekyll, content is fetched from the [Twitter Publish platform](https://publish.twitter.com).
 
-This plugin replaces the broken [Jekyll Tweet Tag](https://github.com/scottwb/jekyll-tweet-tag) plugin mentioned above and uses a different tag name and API - this is by design so that the two plugins can be separated and you can be certain which plugin is being used. You can also install this plugin via Rubygems and require it in your Jekyll `_config.yml` file. You can use *ENV* variables or `_config.yml` file for your Twitter API secret keys.
+The [Publish platform](https://publish.twitter.com) allows Twitter users to curate content for display outside of Twitter, you can display many different types of content with the familiar Twitter styling. We use this API and allow any customisation of the content that is accepted by the Twitter publish platform.
 
+> You can now embed any Twitter content in your Jekyll powered blog!
 
-### Features
+### Here are a few examples
 
-The plugin supports the following features:
+#### Tweet
 
-* Installed via Rubygems.
-* Twitter API secrets read from *ENV* vars or `_config.yml` file.
-* [Oembed](#oembed) - Embed a Tweet in familiar Twitter styling.
-* [Caching](#caching) - Twitter API responses can be cached to avoid hitting request limits.
+An example of a Tweet - `{% twitter https://twitter.com/rubygems/status/518821243320287232 %}`
+
+![Embedded tweet](https://raw.githubusercontent.com/rob-murray/jekyll-twitter-plugin/master/media/embedded-tweet.png "Screenshot of embedded tweet")
+
+#### Timeline
+
+An example of a Timeline - `{% twitter https://twitter.com/jekyllrb maxwidth=500 limit=5 %}`
+
+![Embedded timeline](https://raw.githubusercontent.com/rob-murray/jekyll-twitter-plugin/master/media/embedded-timeline.png "Screenshot of embedded timeline")
+
+#### Grid Timeline
+
+An example of a Grid Timeline - `{% twitter https://twitter.com/TwitterDev/timelines/539487832448843776 limit=5 widget_type=grid maxwidth=500 %}`
+
+![Embedded Grid Timeline](https://raw.githubusercontent.com/rob-murray/jekyll-twitter-plugin/master/media/embedded-grid.png "Screenshot of embedded Grid Timeline")
 
+#### Moment
 
-### Requirements
+An example of a Moment - `{% twitter https://twitter.com/i/moments/650667182356082688 maxwidth=500 %}`
 
-* Twitter oauth credentials - Most Twitter api functions now require authentication. Set up your [application](https://dev.twitter.com/apps/new) and get the credentials.
+![Embedded moment](https://raw.githubusercontent.com/rob-murray/jekyll-twitter-plugin/master/media/embedded-moment.png "Screenshot of embedded moment")
 
 
-### Usage
+### Features
+
+The plugin supports the following features:
+
+* Installed via Rubygems.
+* [Customisation](#customisation) - All customisation options passed to Twitter API.
+* [Authentication](#authentication) - No authentication required!
+* [Caching](#caching) - Twitter API responses can be cached to speed up builds.
+
+
+## Getting Started
 
 As mentioned by [Jekyll's documentation](http://jekyllrb.com/docs/plugins/#installing-a-plugin) you have two options; manually import the source file or require the plugin as a `gem`.
 
@@ -49,7 +74,6 @@ Add the `jekyll-twitter-plugin` to your site `_config.yml` file for Jekyll to im
 gems: ['jekyll-twitter-plugin']
 ```
 
-
 #### Manual import
 
 > Note: this is deprecated and support will be removed in a later version.
@@ -63,86 +87,65 @@ $ wget https://raw.githubusercontent.com/rob-murray/jekyll-twitter-plugin/master
 ```
 
 
-#### Credentials
+#### Plugin tag usage
 
-Your Twitter application authentication credentials are private - do not distribute these!
+To use the plugin, in your source content use the tag `twitter` and then pass additional options to the plugin, these are passed to the API.
 
-You can set the authentication variables by adding them to `_config.yml`.
+```liquid
+{% plugin_type twitter_url *options %}
 
-```yaml
-# _config.yml
-twitter:
-  consumer_key: asdf
-  consumer_secret: asdf
-  access_token: asdf
-  access_token_secret: asdf
+# Example for timeline of the **jekyllrb** user with a maximum of 5 Tweets and with a width of 500px
+{% twitter https://twitter.com/jekyllrb maxwidth=500 limit=5 %}
 ```
 
-If the authentication variables are not present in `_config.yml` they can be gathered from
-environment variables.
+| Argument | Required? | Description |
+|---|---|---|
+| `plugin_type` | Yes | Either `twitter` or `twitternocache` (same as `twitter` but does not cache api responses) |
+| `twitter_url` | Yes | The Twitter URL to use, check below for supported URLs. |
+| `*options` | No | Parameters for the API separated by spaces. Refer below and to respective Twitter API documentation for available parameters. |
 
-* TWITTER_CONSUMER_KEY
-* TWITTER_CONSUMER_SECRET
-* TWITTER_ACCESS_TOKEN
-* TWITTER_ACCESS_TOKEN_SECRET
 
-```bash
-$ export TWITTER_CONSUMER_KEY=foo etc.
-# Or given a file .env with the keys and secrets
-$ export $(cat .env | xargs)
-```
+### Supported Twitter URLs
 
+The Twitter URLs that are supported depends on Twitter, we pass the url and all parameters to the API - check [Twitter Publish platform](https://publish.twitter.com) for availability. Here is documentation for some common types:
 
-#### Plugin tag usage
+##### Tweet:
 
-To use the plugin, in your source content use the tag `twitter` and then pass additional parameters to the plugin.
+* [https://dev.twitter.com/web/overview](https://dev.twitter.com/web/overview)
+* [https://dev.twitter.com/web/embedded-tweets/parameters](https://dev.twitter.com/web/embedded-tweets/parameters)
 
-```liquid
-{% plugin_type api_type *params %}
-```
+##### Timeline:
 
-| Argument | Required? | Description |
-|---|---|---|
-| `plugin_type` | Yes | Either `twitter` or `twitternocache` (same as `twitter` but does not cache api responses) |
-| `api_type` | No - defaults to **oembed** | The Twitter API to use, check below for supported APIs. |
-| `*params` | Yes* | Parameters for the API separated by spaces. Refer below and to respective Twitter API documentation for available parameters. |
+* [https://dev.twitter.com/web/embedded-timelines/oembed](https://dev.twitter.com/web/embedded-timelines/oembed)
 
-* Required arguments depend on the API used.
+##### Moments:
 
+* [https://dev.twitter.com/web/embedded-moments/oembed](https://dev.twitter.com/web/embedded-moments/oembed)
 
-### Supported Twitter APIs
+### Customisation
 
-The following Twitter APIs are supported.
+All pairs of options and values after the URL are passed to the API, the parameters must be in pairs with the option as the key: `option=value`.
 
+For exampled if you wanted to limit the width of the embedded content then the API supports a `maxwidth` option so you could construct the tag as below to limit it to a value of 500 (pixels).
 
-#### Oembed - Default
+```liquid
+{% twitter https://twitter.com/jekyllrb maxwidth=500 %}
+```
 
-The [oembed](https://dev.twitter.com/rest/reference/get/statuses/oembed) API returns html snippet to embed in your app, this will be rendered in the familiar Twitter style.
+### Authentication
 
-This API requires the `status_url` parameter, all others are optional.
+The API does not require any authentication.
 
-```liquid
-# With api_type specified
-{% twitter oembed status_url *options %}
-# 'oembed' autoselected by default
-{% twitter status_url *options %}
-
-# Basic example
-{% twitter oembed https://twitter.com/rubygems/status/518821243320287232 %}
-# Oembed default example
-{% twitter https://twitter.com/rubygems/status/518821243320287232 %}
-# With options
-{% twitter oembed https://twitter.com/rubygems/status/518821243320287232 align='right' width='350' %}
-```
+> Previous version of this library used an API that required API keys (TWITTER_CONSUMER_KEY TWITTER_CONSUMER_SECRET TWITTER_ACCESS_TOKEN TWITTER_ACCESS_TOKEN_SECRET). We now print a warning if these are detected as a reminder that you can safely remove them.
 
 
 ### Output
 
-As with the original plugin, all content will be rendered inside a div with the classes 'embed' and 'twitter'
+All content will be rendered inside a div with the class `jekyll-twitter-plugin`.
 
 ```html
-<div class='embed twitter'>
-    -- content --
+<div class='jekyll-twitter-plugin'>
+    -- content from API --
 </div>
 ```
 
@@ -150,42 +153,49 @@ If something goes wrong then a basic error message will be displayed;
 
 > Tweet could not be processed
 
-If the Twitter client receives one of `Twitter::Error::NotFound, Twitter::Error::Forbidden` errors, this suggests the Tweet is protected or deleted and the following error will be displayed and cached so that it is not fetched again, and again. If the Tweet is restored then simply delete the cached response from `.tweet-cache` directory and build again.
-
-> There was a '{error name}' error fetching Tweet '{Tweet status url}'
+If we receive an error from the API then a message will be cached and rendered something like this below. If its a 404 then this suggests the Tweet is protected or deleted and it is not fetched again, and again. If the Tweet is restored then simply delete the cached response from `.tweet-cache` directory and build again.
 
+```html
+<div class='jekyll-twitter-plugin'>
+    <p>There was a '{error name}' error fetching Tweet '{Tweet status url}'</p>
+</div>
+```
 
 ### Caching
 
-Twitter API responses can be cached to speed up Jekyll site builds and avoid going over API limits. The reponses will be cached in a directory within your Jekyll project called `.tweet-cache`, ensure that this is not commit to source control.
+Twitter API responses can be cached to speed up Jekyll site builds. The reponses will be cached in a directory within your Jekyll project called `.tweet-cache`, this should not be committed to source control.
 
-Caching is enabled by default.
+Caching is enabled by using the `twitter` tag.
 
 It is possible to disable caching by using the specific `twitternocache` tag.
 
 ```liquid
-{% twitternocache oembed status_url *options %}
+{% twitternocache twitter_url *options %}
 
 # Example
-{% twitternocache oembed https://twitter.com/rubygems/status/518821243320287232 %}
+{% twitternocache https://twitter.com/rubygems/status/518821243320287232 %}
 
 ```
 
 
 ### Contributions
 
-I've tried hard to keep all classes and code in the one `lib/jekyll-twitter-plugin.rb` file so that people can just grab this file and include in their Jekyll `_plugins` directory if they do not want to use the Gem. This will be dropped in a later version.
+I've tried hard to keep all code in the one `lib/jekyll-twitter-plugin.rb` file so that people can just grab this file and include in their Jekyll `_plugins` directory if they do not want to install with Rubygems. This will be dropped in a later version.
 
 Please use the GitHub pull-request mechanism to submit contributions.
 
-There is a quick integration test in `spec/integration_tests.rb` that needs API keys and will use the public api and output a file `output_test.html`. Run this with the following command:
+There is a quick integration test in `spec/integration_tests.rb` that will use the **jekyll-twitter-plugin** public api and output a file `output_test.html`. Run this with the following command:
 
 ```ruby
-$ ruby spec/integration_tests.rb
+$ ruby spec/integration_tests.rb && open output_test.html
 ```
 
 
-### License
+## Versioning
+
+We use [SemVer](http://semver.org/) for versioning. For the versions available, see the [tags on this repository](https://github.com/rob-murray/jekyll-twitter-plugin/tags).
+
+
+## License
 
-This project is available for use under the MIT software license.
-See LICENSE
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details

data/jekyll-twitter-plugin.gemspec

@@ -5,13 +5,13 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
   spec.name          = "jekyll-twitter-plugin"
-  spec.version       = "1.4.0"
+  spec.version       = "2.0.0"
   spec.authors       = ["Rob Murray"]
   spec.email         = ["robmurray17@gmail.com"]
-  spec.summary       = "A Liquid tag plugin for Jekyll that renders Tweets from Twitter API"
+  spec.summary       = "A Liquid tag plugin for Jekyll blogging engine that embeds Tweets, Timelines and more from Twitter API."
   spec.homepage      = "https://github.com/rob-murray/jekyll-twitter-plugin"
   spec.license       = "MIT"
-  spec.required_ruby_version = ">= 1.9.3"
+  spec.required_ruby_version = ">= 2.0.0"
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
@@ -19,8 +19,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "webmock"
   spec.add_development_dependency "byebug" if RUBY_VERSION >= "2.0"
-
-  spec.add_dependency "twitter", "~> 5.16"
 end

data/lib/jekyll-twitter-plugin.rb

@@ -1,23 +1,26 @@
 # frozen_string_literal: true
 require "fileutils"
-require "twitter"
+require "net/http"
+require "uri"
+require "ostruct"
+require "json"
+require "digest"
 
 ##
 # A Liquid tag plugin for Jekyll that renders Tweets from Twitter API.
 # https://github.com/rob-murray/jekyll-twitter-plugin
 #
 module TwitterJekyll
-  MissingApiKeyError = Class.new(StandardError)
-  TwitterSecrets = Struct.new(:consumer_key, :consumer_secret, :access_token, :access_token_secret) do
-    def self.build(source, keys)
-      new(*source.values_at(*keys))
-    end
-  end
-  CONTEXT_API_KEYS    = %w(consumer_key consumer_secret access_token access_token_secret).freeze
-  ENV_API_KEYS        = %w(TWITTER_CONSUMER_KEY TWITTER_CONSUMER_SECRET TWITTER_ACCESS_TOKEN TWITTER_ACCESS_TOKEN_SECRET).freeze
-  TWITTER_STATUS_URL  = %r{\Ahttps?://twitter\.com/(:#!\/)?\w+/status(es)?/\d+}i
-  REFER_TO_README     = "Please see 'https://github.com/rob-murray/jekyll-twitter-plugin' for usage."
-
+  # TODO: remove after deprecation cycle
+  CONTEXT_API_KEYS  = %w(consumer_key consumer_secret access_token access_token_secret).freeze
+  ENV_API_KEYS      = %w(TWITTER_CONSUMER_KEY TWITTER_CONSUMER_SECRET TWITTER_ACCESS_TOKEN TWITTER_ACCESS_TOKEN_SECRET).freeze
+  REFER_TO_README   = "Please see 'https://github.com/rob-murray/jekyll-twitter-plugin' for usage.".freeze
+  LIBRARY_VERSION   = "jekyll-twitter-plugin-v2.0.0".freeze
+  REQUEST_HEADERS   = { "User-Agent" => LIBRARY_VERSION }.freeze
+
+  # Cache class that writes to filesystem
+  # TODO: Do i really need to cache?
+  # @api private
   class FileCache
     def initialize(path)
       @cache_folder = File.expand_path path
@@ -49,6 +52,8 @@ module TwitterJekyll
     end
   end
 
+  # Cache class that does nothing
+  # @api private
   class NullCache
     def initialize(*_args); end
 
@@ -57,117 +62,104 @@ module TwitterJekyll
     def write(_key, _data); end
   end
 
-  module Cacheable
-    def cache_key
-      Digest::MD5.hexdigest("#{self.class.name}-#{key}")
-    end
-
-    def key; end
-  end
-
-  class TwitterApi
-    ERRORS_TO_IGNORE = [Twitter::Error::NotFound, Twitter::Error::Forbidden].freeze
+  # Wrapper around an API
+  # @api private
+  class ApiClient
+    # Perform API request; return hash with html content
+    def fetch(api_request)
+      uri = api_request.to_uri
+      response = Net::HTTP.start(uri.host, use_ssl: api_request.ssl?) do |http|
+        http.read_timeout = 5
+        http.open_timeout = 5
+        http.get uri.request_uri, REQUEST_HEADERS
+      end
 
-    attr_reader :error
+      handle_response(api_request, response)
 
-    def initialize(client, params)
-      @client = client
-      @status_url = params.shift
-      parse_args(params)
+    rescue Timeout::Error => e
+      ErrorResponse.new(api_request, e.class.name).to_h
     end
 
-    def fetch; end
-
     private
 
-    def id_from_status_url(url)
-      Regexp.last_match[1] if url.to_s =~ %r{([^\/]+$)}
-    end
-
-    def find_tweet(id)
-      return unless id
-
-      @client.status(id.to_i)
-    rescue *ERRORS_TO_IGNORE => e
-      @error = create_error(e)
-      return nil
+    def handle_response(api_request, response)
+      case response
+      when Net::HTTPSuccess
+        JSON.parse(response.body)
+      else
+        ErrorResponse.new(api_request, response.message).to_h
+      end
     end
+  end
 
-    def parse_args(args)
-      @params ||= begin
-        args.each_with_object({}) do |arg, params|
-          k, v = arg.split("=").map(&:strip)
-          if k && v
-            v = Regexp.last_match[1] if v =~ /^'(.*)'$/
-            params[k] = v
-          end
-        end
-      end
+  # @api private
+  ErrorResponse = Struct.new(:request, :message) do
+    def html
+      "<p>There was a '#{message}' error fetching URL: '#{request.entity_url}'</p>"
     end
 
-    def create_error(exception)
-      ErrorResponse.new("There was a '#{exception.class.name}' error fetching Tweet '#{@status_url}'")
+    def to_h
+      { html: html }
     end
   end
 
-  class Oembed < TwitterApi
-    include TwitterJekyll::Cacheable
+  # Holds the URI were going to request with any parameters
+  # @api private
+  ApiRequest = Struct.new(:entity_url, :params) do
+    TWITTER_API_URL = "https://publish.twitter.com/oembed".freeze
 
-    def fetch
-      tweet_id = id_from_status_url(@status_url)
+    # Always;
+    def ssl?
+      true
+    end
 
-      if tweet = find_tweet(tweet_id)
-        # To work around a 'bug' in the Twitter gem modifying our hash we pass in
-        # a copy otherwise our cache key is altered.
-        @client.oembed tweet, @params.dup
-      else
-        error
+    # Return a URI for Twitter API with query params
+    def to_uri
+      URI.parse(TWITTER_API_URL).tap do |uri|
+        uri.query = URI.encode_www_form url_params
       end
     end
 
-    private
-
-    def key
-      format("%s-%s", @status_url, @params.to_s)
+    # A cache key applicable to the current request with params
+    def cache_key
+      Digest::MD5.hexdigest("#{self.class.name}-#{unique_request_key}")
     end
-  end
-
-  class ErrorResponse
-    attr_reader :error
 
-    def initialize(error)
-      @error = error
-    end
+    private
 
-    def html
-      "<p>#{@error}</p>"
+    def url_params
+      params.merge(url: entity_url)
     end
 
-    def to_h
-      { html: html }
+    def unique_request_key
+      format("%s-%s", entity_url, params.to_s)
     end
   end
 
+  # Class to respond to Jekyll tag; entry point to library
+  # @api public
   class TwitterTag < Liquid::Tag
-    ERROR_BODY_TEXT   = "<p>Tweet could not be processed</p>"
-    DEFAULT_API_TYPE  = "oembed"
+    ERROR_BODY_TEXT = "<p>Tweet could not be processed</p>".freeze
+    OEMBED_ARG      = "oembed".freeze
 
     attr_writer :cache # for testing
 
     def initialize(_name, params, _tokens)
       super
-      @api_type, @params = parse_params(params)
+      @api_request = parse_params(params)
     end
 
+    # Class that implements caching strategy
+    # @api private
     def self.cache_klass
       FileCache
     end
 
+    # Return html string for Jekyll engine
+    # @api public
     def render(context)
-      secrets = find_secrets!(context)
-      create_twitter_rest_client(secrets)
-      api_client = create_api_client(@api_type, @params)
-      response = cached_response(api_client) || live_response(api_client)
+      api_secrets_deprecation_warning(context) # TODO: remove after deprecation cycle
+      response = cached_response || live_response
       html_output_for(response)
     end
 
@@ -177,84 +169,112 @@ module TwitterJekyll
       @cache ||= self.class.cache_klass.new("./.tweet-cache")
     end
 
+    def api_client
+      @api_client ||= ApiClient.new
+    end
+
+    # Return Twitter response or error html
+    # @api private
     def html_output_for(response)
       body = (response.html if response) || ERROR_BODY_TEXT
 
-      "<div class='embed twitter'>#{body}</div>"
+      "<div class='jekyll-twitter-plugin'>#{body}</div>"
     end
 
-    def live_response(api_client)
-      if response = api_client.fetch
-        cache.write(api_client.cache_key, response)
-        response
+    # Return response from API and write to cache
+    # @api private
+    def live_response
+      if response = api_client.fetch(@api_request)
+        cache.write(@api_request.cache_key, response)
+        build_response(response)
       end
     end
 
-    def cached_response(api_client)
-      response = cache.read(api_client.cache_key)
-      OpenStruct.new(response) unless response.nil?
+    # Return response cache if present, otherwise nil
+    # @api private
+    def cached_response
+      response = cache.read(@api_request.cache_key)
+      build_response(response) unless response.nil?
     end
 
+    # Return an `ApiRequest` with the url and arguments
+    # @api private
     def parse_params(params)
       args = params.split(/\s+/).map(&:strip)
+      invalid_args!(args) unless args.any?
 
-      case args[0]
-      when DEFAULT_API_TYPE
-        api_type, *api_args = args
-        [api_type, api_args]
-      when TWITTER_STATUS_URL
-        [DEFAULT_API_TYPE, args]
-      else
-        invalid_args!(args)
+      if args[0].to_s == OEMBED_ARG # TODO: remove after deprecation cycle
+        arguments_deprecation_warning(args)
+        args.shift
       end
-    end
 
-    def create_api_client(api_type, params)
-      klass_name = api_type.capitalize
-      api_client_klass = TwitterJekyll.const_get(klass_name)
-      api_client_klass.new(@twitter_client, params)
+      url, *api_args = args
+      ApiRequest.new(url, parse_args(api_args))
     end
 
-    def create_twitter_rest_client(secrets)
-      @twitter_client = Twitter::REST::Client.new do |config|
-        config.consumer_key        = secrets.consumer_key
-        config.consumer_secret     = secrets.consumer_secret
-        config.access_token        = secrets.access_token
-        config.access_token_secret = secrets.access_token_secret
+    # Transform 'a=b x=y' tag arguments into { "a" => "b", "x" => "y" }
+    # @api private
+    def parse_args(args)
+      args.each_with_object({}) do |arg, params|
+        k, v = arg.split("=").map(&:strip)
+        if k && v
+          v = Regexp.last_match[1] if v =~ /^'(.*)'$/
+          params[k] = v
+        end
       end
     end
 
-    def find_secrets!(context)
-      extract_twitter_secrets_from_context(context) || extract_twitter_secrets_from_env || missing_keys!
+    # Format a response hash
+    # @api private
+    def build_response(h)
+      OpenStruct.new(h)
+    end
+
+    # TODO: remove after deprecation cycle
+    def arguments_deprecation_warning(args)
+      warn "#{LIBRARY_VERSION}: Passing '#{OEMBED_ARG}' as the first argument is not required anymore. This will result in an error in future versions.\nCalled with #{args.inspect}"
     end
 
-    def extract_twitter_secrets_from_context(context)
+    # TODO: remove after deprecation cycle
+    def api_secrets_deprecation_warning(context)
+      warn_if_twitter_secrets_in_context(context) || warn_if_twitter_secrets_in_env
+    end
+
+    # TODO: remove after deprecation cycle
+    def warn_if_twitter_secrets_in_context(context)
       twitter_secrets = context.registers[:site].config.fetch("twitter", {})
       return unless store_has_keys?(twitter_secrets, CONTEXT_API_KEYS)
 
-      TwitterSecrets.build(twitter_secrets, CONTEXT_API_KEYS)
+      warn_secrets_in_project("Jekyll _config.yml")
     end
 
-    def extract_twitter_secrets_from_env
+    # TODO: remove after deprecation cycle
+    def warn_if_twitter_secrets_in_env
       return unless store_has_keys?(ENV, ENV_API_KEYS)
 
-      TwitterSecrets.build(ENV, ENV_API_KEYS)
+      warn_secrets_in_project("ENV")
     end
 
-    def store_has_keys?(store, keys)
-      keys.all? { |required_key| store.key?(required_key) }
+    # TODO: remove after deprecation cycle
+    def warn_secrets_in_project(source)
+      warn "#{LIBRARY_VERSION}: Found Twitter API keys in #{source}, this library does not require these keys anymore. You can remove these keys, if used for another library then ignore this message."
     end
 
-    def missing_keys!
-      raise MissingApiKeyError, "Twitter API keys not found. You can specify these in Jekyll config or ENV. #{REFER_TO_README}"
+    # TODO: remove after deprecation cycle
+    def store_has_keys?(store, keys)
+      keys.all? { |required_key| store.key?(required_key) }
     end
 
+    # Raise error for invalid arguments
+    # @api private
     def invalid_args!(arguments)
       formatted_args = Array(arguments).join(" ")
       raise ArgumentError, "Invalid arguments '#{formatted_args}' passed to 'jekyll-twitter-plugin'. #{REFER_TO_README}"
     end
   end
 
+  # Specialization of TwitterTag without any caching
+  # @api public
   class TwitterTagNoCache < TwitterTag
     def self.cache_klass
       NullCache