jekyll-twitter-plugin 1.3.1 → 1.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0a8e002d1ba46fca2b0d5afc36bb1b8cedc61573
-  data.tar.gz: eeb08ca5c7b025a7fc3c201fa8d583e0cb4c4e33
+  metadata.gz: eb81bd5f03311d7ea54536c4ae9b66a4958a0581
+  data.tar.gz: 8718758139ec729d224592a725e406e3fd18e795
 SHA512:
-  metadata.gz: d503778f0ae4b8751cd4931c1d02e0b15e9d297edcf99e36fba66e6f21ff523287e71a109bbe0f0e3961e9889e94d075d21e2012d566c79d2ff0b856f6d202f7
-  data.tar.gz: 341256c1974e2ac78ba5cd78d39dd3aee63c88695d9314dc84ded6ff77c6724541ee8993d61c88af2118a57e140310d5d35fad427296d9c09e19e194c7de7461
+  metadata.gz: 32e14f43bd34316445f6ac38eeb685b4fc5fa554a765022df00febfd45c8d153f4864144e95163e6f03e0fd6c4c46abf99a4bbd999715df4bf04c1c90fc683c0
+  data.tar.gz: a7a19a137770446e06eda37ee35ce540f880962d6e1f380b71ee8405d2602fdb2b49b7f803aed58e657eea5cda83acca6fa09bd64fd21f428dd1fe527243a708

data/.gitignore

@@ -8,6 +8,7 @@
 /test/tmp/
 /test/version_tmp/
 /tmp/
+.byebug_history
 
 ## Specific to RubyMotion:
 .dat*
@@ -32,3 +33,8 @@ Gemfile.lock
 
 # unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
 .rvmrc
+
+# App specific
+.env
+output_test.html
+.tweet-cache

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.rubocop.yml

@@ -0,0 +1,16 @@
+LineLength:
+  Enabled: false
+
+StringLiterals:
+  EnforcedStyle: double_quotes
+  Enabled: true
+
+Documentation:
+  Enabled: false
+
+Style/FileName:
+  Exclude:
+    - 'lib/jekyll-twitter-plugin.rb'
+
+Lint/AssignmentInCondition:
+  Enabled: false

data/.travis.yml

@@ -0,0 +1,17 @@
+language: ruby
+cache: bundler
+sudo: false
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.2.0
+  - 2.3.0
+  - ruby-head
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+script: 'bundle exec rspec'
+notifications:
+  email:
+    - false

data/Gemfile

@@ -1,4 +1,5 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
+source "https://rubygems.org"
 
 # Specify your gem's dependencies in jekyll-twitter-plugin.gemspec
 gemspec

data/README.md

@@ -2,6 +2,7 @@
 
 A Liquid tag plugin for Jekyll that renders Tweets 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)
 
 
@@ -9,16 +10,17 @@ A Liquid tag plugin for Jekyll that renders Tweets from Twitter API.
 
 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).
 
-It is based on the original Jekyll Tweet Tag from [scottwb](https://github.com/scottwb/jekyll-tweet-tag) which has not been updated since Twitter updated their API to require certain preconditions. This version uses the excellent [Twitter gem](https://github.com/sferik/twitter) to make requests and handle authentication.
+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.
 
-This plugin replaces the broken plugin mentioned above and uses a different tag name and API - this is by design so that the two plugins can be used, if the original gets fixed.
+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.
 
 
 ### Features
 
 The plugin supports the following features:
 
-* Installed via Rubygems
+* 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.
 
@@ -27,10 +29,12 @@ The plugin supports the following features:
 
 * Twitter oauth credentials - Most Twitter api functions now require authentication. Set up your [application](https://dev.twitter.com/apps/new) and get the credentials.
 
+
 ### Usage
 
 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`.
 
+
 #### Require gem
 
 Install the gem, add it to your Gemfile;
@@ -45,8 +49,11 @@ 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.
+
 Just download the source file into your `_plugins` directory, e.g.
 
 ```bash
@@ -55,6 +62,7 @@ $ mkdir -p _plugins && cd _plugins
 $ wget https://raw.githubusercontent.com/rob-murray/jekyll-twitter-plugin/master/lib/jekyll-twitter-plugin.rb
 ```
 
+
 #### Credentials
 
 Your Twitter application authentication credentials are private - do not distribute these!
@@ -80,8 +88,11 @@ environment variables.
 
 ```bash
 $ export TWITTER_CONSUMER_KEY=foo etc.
+# Or given a file .env with the keys and secrets
+$ export $(cat .env | xargs)
 ```
 
+
 #### Plugin tag usage
 
 To use the plugin, in your source content use the tag `twitter` and then pass additional parameters to the plugin.
@@ -90,27 +101,41 @@ To use the plugin, in your source content use the tag `twitter` and then pass ad
 {% plugin_type api_type *params %}
 ```
 
-* `plugin_type` - Either `twitter` or `twitternocache`.
-* `api_type` - The Twitter API to use, check below for supported APIs.
-* `*params` - Parameters for the API separated by spaces. Refer below and to respective Twitter API documentation for available parameters.
+| 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. |
+
+* Required arguments depend on the API used.
+
 
 ### Supported Twitter APIs
 
 The following Twitter APIs are supported.
 
-#### Oembed
+
+#### Oembed - Default
 
 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.
 
+This API requires the `status_url` parameter, all others are optional.
+
 ```liquid
+# With api_type specified
 {% twitter oembed status_url *options %}
+# 'oembed' autoselected by default
+{% twitter status_url *options %}
 
-# Example
+# 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' %}
 ```
 
+
 ### Output
 
 As with the original plugin, all content will be rendered inside a div with the classes 'embed' and 'twitter'
@@ -129,6 +154,7 @@ If the Twitter client receives one of `Twitter::Error::NotFound, Twitter::Error:
 
 > There was a '{error name}' error fetching Tweet '{Tweet status url}'
 
+
 ### 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.
@@ -145,12 +171,20 @@ It is possible to disable caching by using the specific `twitternocache` tag.
 
 ```
 
+
 ### 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 may have to be dropped if the one file gets too overwhelming.
+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.
 
 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:
+
+```ruby
+$ ruby spec/integration_tests.rb
+```
+
+
 ### License
 
 This project is available for use under the MIT software license.

data/Rakefile

@@ -1 +1,2 @@
-require 'bundler/gem_tasks'
+# frozen_string_literal: true
+require "bundler/gem_tasks"

data/jekyll-twitter-plugin.gemspec

@@ -1,23 +1,26 @@
 # coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
+# frozen_string_literal: true
+lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
 Gem::Specification.new do |spec|
-  spec.name          = 'jekyll-twitter-plugin'
-  spec.version       = '1.3.1'
-  spec.authors       = ['Rob Murray']
-  spec.email         = ['robmurray17@gmail.com']
-  spec.summary       = 'A Liquid tag plugin for Jekyll that renders Tweets from Twitter API'
-  spec.homepage      = 'https://github.com/rob-murray/jekyll-twitter-plugin'
-  spec.license       = 'MIT'
+  spec.name          = "jekyll-twitter-plugin"
+  spec.version       = "1.4.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.homepage      = "https://github.com/rob-murray/jekyll-twitter-plugin"
+  spec.license       = "MIT"
+  spec.required_ruby_version = ">= 1.9.3"
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ['lib']
+  spec.require_paths = ["lib"]
 
-  spec.add_development_dependency 'bundler', '~> 1.7'
-  spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'pry-byebug'
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "byebug" if RUBY_VERSION >= "2.0"
 
-  spec.add_dependency 'twitter', '~> 5.11'
+  spec.add_dependency "twitter", "~> 5.16"
 end

data/lib/jekyll-twitter-plugin.rb

@@ -1,14 +1,26 @@
-require 'twitter'
+# frozen_string_literal: true
+require "fileutils"
+require "twitter"
 
 ##
 # 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."
+
   class FileCache
     def initialize(path)
-      @cache_folder   = File.expand_path path
+      @cache_folder = File.expand_path path
       FileUtils.mkdir_p @cache_folder
     end
 
@@ -21,7 +33,7 @@ module TwitterJekyll
       file_to_write = cache_file(cache_filename(key))
       data_to_write = JSON.generate data.to_h
 
-      File.open(file_to_write, 'w') do |f|
+      File.open(file_to_write, "w") do |f|
         f.write(data_to_write)
       end
     end
@@ -38,6 +50,8 @@ module TwitterJekyll
   end
 
   class NullCache
+    def initialize(*_args); end
+
     def read(_key); end
 
     def write(_key, _data); end
@@ -52,7 +66,7 @@ module TwitterJekyll
   end
 
   class TwitterApi
-    ERRORS_TO_IGNORE = [Twitter::Error::NotFound, Twitter::Error::Forbidden]
+    ERRORS_TO_IGNORE = [Twitter::Error::NotFound, Twitter::Error::Forbidden].freeze
 
     attr_reader :error
 
@@ -62,12 +76,12 @@ module TwitterJekyll
       parse_args(params)
     end
 
+    def fetch; end
+
     private
 
     def id_from_status_url(url)
-      if url.to_s =~ /([^\/]+$)/
-        Regexp.last_match[1]
-      end
+      Regexp.last_match[1] if url.to_s =~ %r{([^\/]+$)}
     end
 
     def find_tweet(id)
@@ -81,17 +95,13 @@ module TwitterJekyll
 
     def parse_args(args)
       @params ||= begin
-        params = {}
-        args.each do |arg|
-          k, v = arg.split('=').map(&:strip)
+        args.each_with_object({}) do |arg, params|
+          k, v = arg.split("=").map(&:strip)
           if k && v
-            if v =~ /^'(.*)'$/
-              v = Regexp.last_match[1]
-            end
+            v = Regexp.last_match[1] if v =~ /^'(.*)'$/
             params[k] = v
           end
         end
-        params
       end
     end
 
@@ -118,17 +128,13 @@ module TwitterJekyll
     private
 
     def key
-      '%s-%s' % [@status_url, @params.to_s]
+      format("%s-%s", @status_url, @params.to_s)
     end
   end
 
-  class UnknownTypeClient
-    include TwitterJekyll::Cacheable
-
-    def fetch; end
-  end
-
   class ErrorResponse
+    attr_reader :error
+
     def initialize(error)
       @error = error
     end
@@ -143,18 +149,22 @@ module TwitterJekyll
   end
 
   class TwitterTag < Liquid::Tag
-    ERROR_BODY_TEXT = '<p>Tweet could not be processed</p>'
+    ERROR_BODY_TEXT   = "<p>Tweet could not be processed</p>"
+    DEFAULT_API_TYPE  = "oembed"
+
+    attr_writer :cache # for testing
 
     def initialize(_name, params, _tokens)
       super
-      @cache    = FileCache.new('./.tweet-cache')
-      args      = params.split(/\s+/).map(&:strip)
-      @api_type = args.shift
-      @params   = args
+      @api_type, @params = parse_params(params)
+    end
+
+    def self.cache_klass
+      FileCache
     end
 
     def render(context)
-      secrets = extract_twitter_secrets_from_context(context) || extract_twitter_secrets_from_env
+      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)
@@ -163,38 +173,48 @@ module TwitterJekyll
 
     private
 
-    def html_output_for(response)
-      body = ERROR_BODY_TEXT
+    def cache
+      @cache ||= self.class.cache_klass.new("./.tweet-cache")
+    end
 
-      if response
-        body = response.html || body
-      end
+    def html_output_for(response)
+      body = (response.html if response) || ERROR_BODY_TEXT
 
       "<div class='embed twitter'>#{body}</div>"
     end
 
     def live_response(api_client)
       if response = api_client.fetch
-        @cache.write(api_client.cache_key, response)
+        cache.write(api_client.cache_key, response)
         response
       end
     end
 
     def cached_response(api_client)
-      response = @cache.read(api_client.cache_key)
+      response = cache.read(api_client.cache_key)
       OpenStruct.new(response) unless response.nil?
     end
 
-    def create_api_client(api_type, params)
-      klass_name = api_type.capitalize
-      if TwitterJekyll.const_defined?(klass_name)
-        api_client_klass = TwitterJekyll.const_get(klass_name)
-        api_client_klass.new(@twitter_client, params)
+    def parse_params(params)
+      args = params.split(/\s+/).map(&:strip)
+
+      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
-        UnknownTypeClient.new
+        invalid_args!(args)
       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)
+    end
+
     def create_twitter_rest_client(secrets)
       @twitter_client = Twitter::REST::Client.new do |config|
         config.consumer_key        = secrets.consumer_key
@@ -204,29 +224,43 @@ module TwitterJekyll
       end
     end
 
-    TwitterSecrets = Struct.new(:consumer_key, :consumer_secret, :access_token, :access_token_secret)
+    def find_secrets!(context)
+      extract_twitter_secrets_from_context(context) || extract_twitter_secrets_from_env || missing_keys!
+    end
 
     def extract_twitter_secrets_from_context(context)
-      TwitterSecrets.new(context.registers[:site].config['twitter']['consumer_key'], context.registers[:site].config['twitter']['consumer_secret'], context.registers[:site].config['twitter']['access_token'], context.registers[:site].config['twitter']['access_token_secret']) if context_has_twitter_secrets?(context)
-    end
+      twitter_secrets = context.registers[:site].config.fetch("twitter", {})
+      return unless store_has_keys?(twitter_secrets, CONTEXT_API_KEYS)
 
-    def context_has_twitter_secrets?(context)
-      twitter_secrets = context.registers[:site].config['twitter'] || {}
-      ['consumer_key', 'consumer_secret', 'access_token', 'access_token_secret'].all? {|s| twitter_secrets.key?(s)}
+      TwitterSecrets.build(twitter_secrets, CONTEXT_API_KEYS)
     end
 
     def extract_twitter_secrets_from_env
-      TwitterSecrets.new(ENV.fetch('TWITTER_CONSUMER_KEY'), ENV.fetch('TWITTER_CONSUMER_SECRET'), ENV.fetch('TWITTER_ACCESS_TOKEN'), ENV.fetch('TWITTER_ACCESS_TOKEN_SECRET'))
+      return unless store_has_keys?(ENV, ENV_API_KEYS)
+
+      TwitterSecrets.build(ENV, ENV_API_KEYS)
+    end
+
+    def store_has_keys?(store, keys)
+      keys.all? { |required_key| store.key?(required_key) }
+    end
+
+    def missing_keys!
+      raise MissingApiKeyError, "Twitter API keys not found. You can specify these in Jekyll config or ENV. #{REFER_TO_README}"
+    end
+
+    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
 
   class TwitterTagNoCache < TwitterTag
-    def initialize(_tag_name, _text, _token)
-      super
-      @cache = NullCache.new
+    def self.cache_klass
+      NullCache
     end
   end
 end
 
-Liquid::Template.register_tag('twitter', TwitterJekyll::TwitterTag)
-Liquid::Template.register_tag('twitternocache', TwitterJekyll::TwitterTagNoCache)
+Liquid::Template.register_tag("twitter", TwitterJekyll::TwitterTag)
+Liquid::Template.register_tag("twitternocache", TwitterJekyll::TwitterTagNoCache)

data/spec/integration_tests.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+# Basic integration example - run code to produce html output
+#
+# * Requires .env populated with valid Twitter API creds.
+#
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require_relative "./support/jekyll_template"
+require "jekyll-twitter-plugin"
+require "erb"
+
+OUTPUT_FILENAME = "output_test.html"
+OPTIONS = [
+  "oembed https://twitter.com/rubygems/status/518821243320287232",
+  "oembed https://twitter.com/rubygems/status/518821243320287232 align='right' width='350'",
+  "https://twitter.com/rubygems/status/518821243320287232",
+  "oembed https://twitter.com/rubygems/status/missing"
+].freeze
+
+COLOUR_MAP = {
+  red: 31,
+  green: 32,
+  yellow: 33,
+  blue: 34
+}.freeze
+
+def say_with_colour(text, colour_name)
+  colour_code = COLOUR_MAP.fetch(colour_name)
+  puts "\e[#{colour_code}m#{text}\e[0m"
+end
+
+class TwitterRenderer
+  Context = Struct.new(:registers)
+  Site = Struct.new(:config)
+
+  def initialize(options)
+    @options = options
+    @jekyll_context = Context.new(site: Site.new({}))
+  end
+
+  def render
+    ERB.new(template)
+       .result(binding)
+       .gsub!("src=\"//", "src=\"https://")
+  end
+
+  private
+
+  attr_reader :options, :jekyll_context
+
+  def render_twitter_tag(params)
+    say_with_colour "Fetching with params: #{params}", :yellow
+    TwitterJekyll::TwitterTag.new(nil, params, nil).render(jekyll_context)
+  end
+
+  def template
+    <<~HTML
+      <html>
+        <body>
+        <h1>jekyll-twitter-plugin output tests</h1>
+        <% options.each do |option| %>
+          <h3><%= option %></h3>
+          <%= render_twitter_tag(option) %>
+          <hr>
+        <% end %>
+        </body>
+      </html>
+    HTML
+  end
+end
+
+def main
+  rederer = TwitterRenderer.new(OPTIONS)
+  File.open(OUTPUT_FILENAME, "w") do |f|
+    f.write rederer.render
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  say_with_colour "Running integration tests...", :red
+  main
+  say_with_colour "Created file: #{OUTPUT_FILENAME}", :green
+end

data/spec/oembed_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+RSpec.describe TwitterJekyll::Oembed do
+  let(:api_client) { double("Twitter::REST::Client") }
+  let(:status_response) { double }
+  subject { described_class.new(api_client, params) }
+
+  describe "parsing status id" do
+    let(:params) { ["https://twitter.com/twitter_user/status/12345"] }
+
+    it "parses the status id from the tweet url correctly" do
+      status_response = double
+      allow(Twitter::REST::Client).to receive(:new).and_return(api_client)
+
+      expect(api_client).to receive(:status).with(12_345).and_return(status_response)
+      expect(api_client).to receive(:oembed).with(status_response, {}).and_return("")
+      subject.fetch
+    end
+  end
+
+  describe "parsing options" do
+    context "with extra options" do
+      let(:params) { ["https://twitter.com/twitter_user/status/12345", "align='right'", "width='350'"] }
+
+      it "passes to api" do
+        allow(Twitter::REST::Client).to receive(:new).and_return(api_client)
+        allow(api_client).to receive(:status).with(12_345).and_return(status_response)
+
+        expect(api_client).to receive(:oembed).with(status_response, "align" => "right", "width" => "350").and_return("")
+        subject.fetch
+      end
+    end
+
+    context "with an invalid option" do
+      let(:params) { ["https://twitter.com/twitter_user/status/12345", "align=", "width='350'"] }
+
+      it "ignores param" do
+        allow(Twitter::REST::Client).to receive(:new).and_return(api_client)
+        allow(api_client).to receive(:status).with(12_345).and_return(status_response)
+
+        expect(api_client).to receive(:oembed).with(status_response, "width" => "350").and_return("")
+        subject.fetch
+      end
+    end
+  end
+
+  describe "#fetch" do
+    let(:params) { ["https://twitter.com/twitter_user/status/12345"] }
+
+    it "returns response from api" do
+      allow(Twitter::REST::Client).to receive(:new).and_return(api_client)
+      allow(api_client).to receive(:status).with(12_345).and_return(status_response)
+
+      expect(api_client).to receive(:oembed).with(status_response, {}).and_return("api response")
+      expect(subject.fetch).to eq "api response"
+    end
+
+    context "when status is not found" do
+      it "returns error" do
+        allow(Twitter::REST::Client).to receive(:new).and_return(api_client)
+        allow(api_client).to receive(:status).with(12_345).and_raise(Twitter::Error::NotFound)
+
+        expect(api_client).not_to receive(:oembed)
+        result = subject.fetch
+        expect(result).to be_a(TwitterJekyll::ErrorResponse)
+        expect(result.error).to eq "There was a 'Twitter::Error::NotFound' error fetching Tweet 'https://twitter.com/twitter_user/status/12345'"
+      end
+    end
+  end
+
+  describe "#cache_key" do
+    context "with no params" do
+      let(:params) { ["https://twitter.com/twitter_user/status/12345"] }
+
+      it "matches on status url" do
+        oembed_1 = TwitterJekyll::Oembed.new(api_client, params.dup)
+        oembed_2 = TwitterJekyll::Oembed.new(api_client, params.dup)
+
+        expect(
+          oembed_1.cache_key == oembed_2.cache_key
+        ).to be true
+      end
+    end
+
+    context "with params" do
+      let(:params_1) { ["https://twitter.com/twitter_user/status/12345", "align='right'"] }
+      let(:params_2) { ["https://twitter.com/twitter_user/status/12345", "align='left'"] }
+
+      it "matches on keys and values" do
+        oembed_1 = TwitterJekyll::Oembed.new(api_client, params_1.dup)
+        oembed_2 = TwitterJekyll::Oembed.new(api_client, params_2.dup)
+        oembed_3 = TwitterJekyll::Oembed.new(api_client, params_1.dup)
+
+        expect(
+          oembed_1.cache_key == oembed_2.cache_key
+        ).to be false
+
+        expect(
+          oembed_1.cache_key == oembed_3.cache_key
+        ).to be true
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+require "support/jekyll_template"
+require "support/shared_contexts"
+require "jekyll-twitter-plugin"
+require "byebug" if RUBY_VERSION >= "2.0"
+
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.expect_with :rspec do |expectations|
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  config.mock_with :rspec do |mocks|
+    mocks.verify_partial_doubles = true
+  end
+
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+  config.filter_run_when_matching :focus
+  config.disable_monkey_patching!
+  config.warnings = true
+  config.default_formatter = "doc" if config.files_to_run.one?
+
+  config.order = :random
+  Kernel.srand config.seed
+end

data/spec/support/jekyll_template.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+# Hack ...or stub Liquid classes and methods used in plugin
+module Liquid
+  class Tag
+    def initialize(*_); end
+  end
+
+  class Template
+    def self.register_tag(*_); end
+  end
+end

data/spec/support/shared_contexts.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+RSpec.shared_context "without cached response" do
+  let(:cache) { null_cache }
+
+  before do
+    subject.cache = cache
+  end
+
+  def null_cache
+    double("TwitterJekyll::NullCache", read: nil, write: nil)
+  end
+end
+
+RSpec.shared_context "with any oembed request and response" do
+  let(:options) { "oembed https://twitter.com/twitter_user/status/12345" }
+  let(:response) { OpenStruct.new(html: "<p>tweet html</p>") }
+
+  before do
+    allow(api_client).to receive(:oembed).and_return(response)
+  end
+end

data/spec/twitter_tag_spec.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+RSpec.describe TwitterJekyll::TwitterTag do
+  let(:context) { double.as_null_object }
+  let(:options) { "" }
+  subject { described_class.new(nil, options, nil) }
+
+  describe "output from oembed request" do
+    let(:api_response_hash) do
+      {
+        "url" => "https://twitter.com/twitter_user/status/12345",
+        "author_name" => "twitter user",
+        "author_url" => "https://twitter.com/twitter_user",
+        "html" => "<p>tweet html</p>",
+        "width" => 550,
+        "height" => nil,
+        "type" => "rich",
+        "cache_age" => "3153600000",
+        "provider_name" => "Twitter",
+        "provider_url" => "https://twitter.com",
+        "version" => "1.0"
+      }
+    end
+    let(:options) { "oembed https://twitter.com/twitter_user/status/12345" }
+
+    context "with cached response" do
+      let(:cache) { double("TwitterJekyll::FileCache") }
+      before do
+        subject.cache = cache
+      end
+
+      it "renders response from cache" do
+        allow(Twitter::REST::Client).to receive(:new).and_return(double.as_null_object)
+        expect(cache).to receive(:read).with(an_instance_of(String)).and_return(api_response_hash)
+
+        output = subject.render(context)
+        expect_output_to_match_tag_content(output, api_response_hash.fetch("html"))
+      end
+    end
+
+    context "without cached response" do
+      let(:cache) { double("TwitterJekyll::FileCache") }
+      let(:response) { build_response_object(api_response_hash) }
+      before do
+        subject.cache = cache
+        allow(cache).to receive(:read).with(an_instance_of(String)).and_return(nil)
+      end
+
+      context "with successful api request" do
+        it "renders response from api and writes to cache" do
+          api_client = double("Twitter::REST::Client", status: double)
+          allow(Twitter::REST::Client).to receive(:new).and_return(api_client)
+
+          expect(api_client).to receive(:oembed).and_return(response)
+          expect(cache).to receive(:write).with(an_instance_of(String), response)
+
+          output = subject.render(context)
+          expect_output_to_match_tag_content(output, api_response_hash.fetch("html"))
+        end
+      end
+
+      context "with a status not found api request" do
+        it "renders response from api and does not write to cache" do
+          api_client = double("Twitter::REST::Client", status: double)
+          allow(Twitter::REST::Client).to receive(:new).and_return(api_client)
+
+          expect(api_client).to receive(:status).and_raise(Twitter::Error::NotFound)
+          expect(cache).not_to receive(:write).with(an_instance_of(String), response)
+
+          output = subject.render(context)
+          expect_output_to_have_error(output, Twitter::Error::NotFound)
+        end
+      end
+
+      context "with a status request not permitted api request" do
+        it "renders response from api and does not write to cache" do
+          api_client = double("Twitter::REST::Client", status: double)
+          allow(Twitter::REST::Client).to receive(:new).and_return(api_client)
+
+          expect(api_client).to receive(:status).and_raise(Twitter::Error::Forbidden)
+          expect(cache).not_to receive(:write).with(an_instance_of(String), response)
+
+          output = subject.render(context)
+          expect_output_to_have_error(output, Twitter::Error::Forbidden)
+        end
+      end
+    end
+  end
+
+  describe "With an invalid request type" do
+    context "without any arguments" do
+      let(:options) { "" }
+
+      it "raises an exception" do
+        expect_to_raise_invalid_args_error(options) do
+          tag = described_class.new(nil, options, nil)
+          tag.render(context)
+        end
+      end
+    end
+
+    context "with an api request type not supported" do
+      let(:options) { "unsupported https://twitter.com/twitter_user/status/12345" }
+
+      it "raises an exception" do
+        expect_to_raise_invalid_args_error(options) do
+          tag = described_class.new(nil, options, nil)
+          tag.render(context)
+        end
+      end
+    end
+
+    context "without an api request type and no valid status url" do
+      let(:options) { "https://anything.com/twitter_user/status/12345" }
+
+      it "raises an exception" do
+        expect_to_raise_invalid_args_error(options) do
+          tag = described_class.new(nil, options, nil)
+          tag.render(context)
+        end
+      end
+    end
+  end
+
+  describe "parsing api request type" do
+    include_context "without cached response"
+    let(:response) { OpenStruct.new(html: "anything") }
+    let(:status) { double }
+
+    context "with oembed requested" do
+      let(:options) { "oembed https://twitter.com/twitter_user/status/12345" }
+
+      it "uses the oembed api" do
+        api_client = double("Twitter::REST::Client", status: status)
+        allow(Twitter::REST::Client).to receive(:new).and_return(api_client)
+
+        expect(api_client).to receive(:oembed).with(status, {}).and_return(response)
+        subject.render(context)
+      end
+    end
+
+    context "without an api request type" do
+      let(:options) { "https://twitter.com/twitter_user/status/12345" }
+
+      it "uses the default oembed api type" do
+        api_client = double("Twitter::REST::Client", status: status)
+        allow(Twitter::REST::Client).to receive(:new).and_return(api_client)
+
+        expect(api_client).to receive(:oembed).with(status, {}).and_return(response)
+        subject.render(context)
+      end
+    end
+  end
+
+  describe "parsing api secrets" do
+    include_context "without cached response"
+    include_context "with any oembed request and response"
+    let(:api_client) { double("Twitter::REST::Client", status: double) }
+    let(:config_builder) { double }
+
+    before do
+      allow(Twitter::REST::Client).to receive(:new).and_yield(config_builder).and_return(api_client)
+    end
+
+    context "with api secrets provided by ENV" do
+      let(:context) { double("context", registers: { site: double(config: {}) }) }
+      before do
+        stub_const("ENV", "TWITTER_CONSUMER_KEY" => "consumer_key",
+                          "TWITTER_CONSUMER_SECRET" => "consumer_secret",
+                          "TWITTER_ACCESS_TOKEN" => "access_token",
+                          "TWITTER_ACCESS_TOKEN_SECRET" => "access_token_secret")
+      end
+
+      it "creates api client correctly" do
+        expect(config_builder).to receive(:consumer_key=).with("consumer_key")
+        expect(config_builder).to receive(:consumer_secret=).with("consumer_secret")
+        expect(config_builder).to receive(:access_token=).with("access_token")
+        expect(config_builder).to receive(:access_token_secret=).with("access_token_secret")
+
+        subject.render(context)
+      end
+    end
+
+    context "with api secrets provided by Jekyll config" do
+      let(:context) do
+        api_secrets = %w(consumer_key consumer_secret access_token access_token_secret)
+                      .each_with_object({}) { |secret, h| h[secret] = secret }
+        double("context", registers:
+          { site: double(config: { "twitter" => api_secrets }) })
+      end
+      before do
+        stub_const("ENV", {})
+      end
+
+      it "creates api client correctly" do
+        expect(config_builder).to receive(:consumer_key=).with("consumer_key")
+        expect(config_builder).to receive(:consumer_secret=).with("consumer_secret")
+        expect(config_builder).to receive(:access_token=).with("access_token")
+        expect(config_builder).to receive(:access_token_secret=).with("access_token_secret")
+
+        subject.render(context)
+      end
+    end
+
+    context "with no api secrets provided" do
+      let(:context) { double("context", registers: { site: double(config: {}) }) }
+      before do
+        stub_const("ENV", {})
+      end
+
+      it "raises an exception" do
+        expect do
+          subject.render(context)
+        end.to raise_error(TwitterJekyll::MissingApiKeyError)
+      end
+    end
+  end
+
+  private
+
+  def expect_output_to_match_tag_content(actual, content)
+    expect(actual).to eq(
+      "<div class='embed twitter'>#{content}</div>"
+    )
+  end
+
+  def expect_output_to_have_error(actual, error, tweet_url = "https://twitter.com/twitter_user/status/12345")
+    expect_output_to_match_tag_content(actual, "<p>There was a '#{error}' error fetching Tweet '#{tweet_url}'</p>")
+  end
+
+  def expect_to_raise_invalid_args_error(options)
+    raise unless block_given?
+
+    message = "Invalid arguments '#{options}' passed to 'jekyll-twitter-plugin'. Please see 'https://github.com/rob-murray/jekyll-twitter-plugin' for usage."
+    expect do
+      yield
+    end.to raise_error(ArgumentError, message)
+  end
+
+  # The twitter gem responds with a struct like object so we do too.
+  def build_response_object(response)
+    OpenStruct.new(response)
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jekyll-twitter-plugin
 version: !ruby/object:Gem::Version
-  version: 1.3.1
+  version: 1.4.0
 platform: ruby
 authors:
 - Rob Murray
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-06-05 00:00:00.000000000 Z
+date: 2016-09-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.7'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -39,7 +39,21 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: pry-byebug
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: byebug
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -58,14 +72,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.11'
+        version: '5.16'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '5.11'
+        version: '5.16'
 description: 
 email:
 - robmurray17@gmail.com
@@ -74,12 +88,21 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rspec"
+- ".rubocop.yml"
+- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - jekyll-twitter-plugin.gemspec
 - lib/jekyll-twitter-plugin.rb
+- spec/integration_tests.rb
+- spec/oembed_spec.rb
+- spec/spec_helper.rb
+- spec/support/jekyll_template.rb
+- spec/support/shared_contexts.rb
+- spec/twitter_tag_spec.rb
 homepage: https://github.com/rob-murray/jekyll-twitter-plugin
 licenses:
 - MIT
@@ -92,7 +115,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -100,8 +123,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: A Liquid tag plugin for Jekyll that renders Tweets from Twitter API
-test_files: []
+test_files:
+- spec/integration_tests.rb
+- spec/oembed_spec.rb
+- spec/spec_helper.rb
+- spec/support/jekyll_template.rb
+- spec/support/shared_contexts.rb
+- spec/twitter_tag_spec.rb