wgif 0.2.0 → 0.3.0

data/lib/wgif/exceptions.rb

@@ -1,27 +1,10 @@
 module WGif
-
-  class InvalidUrlException < Exception
-  end
-
-  class InvalidTimestampException < Exception
-  end
-
-  class InvalidDurationException < Exception
-  end
-
-  class InvalidFramesException < Exception
-  end
-
-  class MissingOutputFileException < Exception
-  end
-
-  class VideoNotFoundException < Exception
-  end
-
-  class ClipEncodingException < Exception
-  end
-
-  class ImgurException < Exception
-  end
-
+  InvalidUrlException        = Class.new(Exception)
+  InvalidTimestampException  = Class.new(Exception)
+  InvalidDurationException   = Class.new(Exception)
+  InvalidFramesException     = Class.new(Exception)
+  MissingOutputFileException = Class.new(Exception)
+  VideoNotFoundException     = Class.new(Exception)
+  ClipEncodingException      = Class.new(Exception)
+  ImgurException             = Class.new(Exception)
 end

data/lib/wgif/gif_maker.rb

@@ -12,7 +12,9 @@ module WGif
 
     def resize(image, dimensions)
       image.each do |frame|
-        frame.change_geometry(dimensions) { |cols, rows, img| img.resize!(cols, rows) }
+        frame.change_geometry(dimensions) do |cols, rows, img|
+          img.resize!(cols, rows)
+        end
       end
     end
   end

data/lib/wgif/installer.rb

@@ -6,7 +6,7 @@ module WGif
 
     def run
       if dependencies_installed?
-        puts "All dependencies are installed. Go make a GIF."
+        puts 'All dependencies are installed. Go make a gif.'
         Kernel.exit 0
       end
       if homebrew_installed?
@@ -21,7 +21,7 @@ module WGif
     end
 
     def dependencies_installed?
-      DEPENDENCIES.map {|_, binary| installed?(binary)}.inject(:&)
+      DEPENDENCIES.map { |_, binary| installed?(binary) }.inject(:&)
     end
 
     def homebrew_installed?
@@ -39,6 +39,5 @@ module WGif
     def installed?(binary)
       Kernel.system "which #{binary} > /dev/null"
     end
-
   end
 end

data/lib/wgif/uploader.rb

@@ -14,10 +14,13 @@ module WGif
     def upload(filename)
       File.open(filename, 'r') do |file|
         response = Typhoeus.post(UPLOAD_ENDPOINT,
-                                 body: {image: file},
+                                 body: { image: file },
                                  headers: auth_header)
-        raise WGif::ImgurException, error_message(response) unless response.success?
-        image_url(response)
+        if response.success?
+          image_url(response)
+        else
+          fail WGif::ImgurException, error_message(response)
+        end
       end
     end
 
@@ -32,7 +35,7 @@ module WGif
     end
 
     def auth_header
-      {Authorization: "Client-ID #{@client_id}"}
+      { Authorization: "Client-ID #{@client_id}" }
     end
   end
 end

data/lib/wgif/version.rb

@@ -1,3 +1,3 @@
 module WGif
-  VERSION = "0.2.0"
+  VERSION = '0.3.0'
 end

data/lib/wgif/video.rb

@@ -5,25 +5,25 @@ module WGif
   class Video
     attr_accessor :name, :clip, :logger
 
-    def initialize name, filepath
+    def initialize(name, filepath)
       @name = name
       @clip = FFMPEG::Movie.new(filepath)
-      FileUtils.mkdir_p "/tmp/wgif/"
+      FileUtils.mkdir_p '/tmp/wgif/'
       @logger = Logger.new("/tmp/wgif/#{name}.log")
       FFMPEG.logger = @logger
     end
 
-    def trim start_timestamp, duration
+    def trim(start_timestamp, duration)
       options = {
-        audio_codec: "copy",
-        video_codec: "copy",
+        audio_codec: 'copy',
+        video_codec: 'copy',
         custom: "-ss #{start_timestamp} -t 00:00:#{'%06.3f' % duration}"
       }
-      trimmed = transcode(@clip, "/tmp/wgif/#{@name}-clip.mov", options)
+      transcode(@clip, "/tmp/wgif/#{@name}-clip.mov", options)
       WGif::Video.new "#{@name}-clip", "/tmp/wgif/#{@name}-clip.mov"
     end
 
-    def to_frames(options={})
+    def to_frames(options = {})
       make_frame_dir
       if options[:frames]
         framerate = options[:frames] / @clip.duration
@@ -37,22 +37,23 @@ module WGif
     private
 
     def make_frame_dir
-      FileUtils.rm Dir.glob("/tmp/wgif/frames/*.png")
-      FileUtils.mkdir_p "/tmp/wgif/frames"
+      FileUtils.rm Dir.glob('/tmp/wgif/frames/*.png')
+      FileUtils.mkdir_p '/tmp/wgif/frames'
     end
 
     def open_frame_dir
-      Dir.glob("/tmp/wgif/frames/*.png")
+      Dir.glob('/tmp/wgif/frames/*.png')
     end
 
     def transcode(clip, file, options)
-      begin
-        clip.transcode(file, options)
-      rescue FFMPEG::Error => error
-        raise WGif::ClipEncodingException unless error.message.include? "no output file created"
-        raise WGif::ClipEncodingException if error.message.include? "Invalid data found when processing input"
+      clip.transcode(file, options)
+    rescue FFMPEG::Error => error
+      unless error.message.include? 'no output file created'
+        raise WGif::ClipEncodingException
+      end
+      if error.message.include? 'Invalid data found when processing input'
+        raise WGif::ClipEncodingException
       end
     end
-
   end
 end

data/lib/wgif/video_cache.rb

@@ -9,10 +9,7 @@ module WGif
 
     def get(video_id)
       path = "/tmp/wgif/#{video_id}"
-      if Pathname.new(path).exist?
-        WGif::Video.new(video_id, path)
-      end
+      WGif::Video.new(video_id, path) if Pathname.new(path).exist?
     end
-
   end
 end

data/spec/integration/empty_image_list_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+require 'wgif/cli'
+
+describe 'empty image list bug', integration: true do
+  it 'throws an empty image list error' do
+    args =  ['https://www.youtube.com/watch?v=deFDlB8RiNg',
+             'fish_grease.gif',
+             '--start',
+             '00:00:13',
+             '-d',
+             '3',
+             '-f',
+             '20',
+             '--width',
+             '350']
+    WGif::CLI.new.make_gif(args)
+  end
+end

data/spec/spec_helper.rb

@@ -1,5 +1,8 @@
 require 'rspec'
 require 'simplecov'
+require 'codeclimate-test-reporter'
+
+CodeClimate::TestReporter.start
 
 if ENV['COVERAGE'] == 'true'
   SimpleCov.start do

data/spec/unit/wgif/argument_parser_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+require 'wgif/argument_parser'
+
+describe WGif::ArgumentParser do
+  let(:parser) { described_class.new }
+
+  it 'parses a URL from command line args' do
+    args = parser.parse_args ['http://example.com']
+    args[:url].should eq('http://example.com')
+  end
+
+  it 'starts at 0s by default' do
+    args = parser.parse_args ['http://example.com']
+    args[:trim_from].should eq('00:00:00')
+  end
+
+  it 'trims parserps to 1s by default' do
+    args = parser.parse_args ['http://example.com']
+    args[:duration].should eq(1)
+  end
+
+  it 'parses the short frame count option' do
+    options = parser.parse_options ['-f', '40']
+    options[:frames].should eq(40)
+  end
+
+  it 'parses the long frame count option' do
+    options = parser.parse_options ['--frames', '40']
+    options[:frames].should eq(40)
+  end
+
+  it 'parses the short start time option' do
+    options = parser.parse_options ['-s', '00:00:05']
+    options[:trim_from].should eq('00:00:05')
+  end
+
+  it 'parses the long start time option' do
+    options = parser.parse_options ['--start', '00:00:05']
+    options[:trim_from].should eq('00:00:05')
+  end
+
+  it 'parses the short duration option' do
+    options = parser.parse_options ['-d', '1.43']
+    options[:duration].should eq(1.43)
+  end
+
+  it 'parses the long duration option' do
+    options = parser.parse_options ['--duration', '5.3']
+    options[:duration].should eq(5.3)
+  end
+
+  it 'parses the short dimensions option' do
+    options = parser.parse_options ['-w', '400']
+    expect(options[:dimensions]).to eq('400')
+  end
+
+  it 'parses the long dimensions option' do
+    options = parser.parse_options ['--width', '300']
+    expect(options[:dimensions]).to eq('300')
+  end
+
+  it 'parses the short upload option' do
+    options = parser.parse_options ['-u']
+    expect(options[:upload]).to eq(true)
+  end
+
+  it 'parses the long upload option' do
+    options = parser.parse_options ['--upload']
+    expect(options[:upload]).to eq(true)
+  end
+
+  it 'parses the short preview option' do
+    options = parser.parse_options ['-p']
+    expect(options[:preview]).to eq(true)
+  end
+
+  it 'parses the long preview option' do
+    options = parser.parse_options ['--preview']
+    expect(options[:preview]).to eq(true)
+  end
+
+  it 'handles args in wacky order' do
+    args = parser.parse_args([
+      '-d',
+      '1.5',
+      '--upload',
+      'http://example.com',
+      '--frames',
+      '60',
+      '-p',
+      'my-great-gif.gif',
+      '-s',
+      '00:00:05'
+    ])
+
+    expect(args).to eq(url: 'http://example.com',
+                       trim_from: '00:00:05',
+                       duration: 1.5,
+                       frames: 60,
+                       output: 'my-great-gif.gif',
+                       dimensions: '480',
+                       upload: true,
+                       preview: true)
+  end
+
+  context 'validating args' do
+
+    it 'checks for a missing output file' do
+      args = parser.parse_args(['http://example.com'])
+      expect { parser.validate_args args }
+        .to raise_error(WGif::MissingOutputFileException)
+    end
+
+    it 'checks for an invalid URL' do
+      args = parser.parse_args(['crazy nonsense', 'output.gif'])
+      expect { parser.validate_args args }
+        .to raise_error(WGif::InvalidUrlException)
+    end
+
+    it 'checks for an invalid timestamp' do
+      args = parser.parse_args([
+        'http://lol.wut',
+        'output.gif',
+        '-s',
+        'rofl'
+      ])
+      expect { parser.validate_args args }
+        .to raise_error(WGif::InvalidTimestampException)
+    end
+
+    it 'returns true when args are OK' do
+      args = parser.parse_args([
+        'https://crazynonsense.info',
+        'output.gif'
+      ])
+      expect { parser.validate_args args }.not_to raise_error
+    end
+  end
+
+  it 'parses and validates' do
+    expect { parser.parse(['http://lol.wut']) }
+      .to raise_error(WGif::MissingOutputFileException)
+  end
+
+  it 'returns parsed arguments' do
+    args = parser.parse(['http://lol.wut', 'out.gif'])
+    expect(args).to eq({dimensions: '480',
+                        duration: 1.0,
+                        output: 'out.gif',
+                        trim_from: '00:00:00',
+                        url: 'http://lol.wut'})
+  end
+end

data/spec/unit/wgif/cli_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+require 'wgif/cli'
+
+describe WGif::CLI do
+  let(:cli) { described_class.new }
+
+  context 'error handling' do
+
+    before do
+      @mock_stdout = StringIO.new
+      @real_stdout, $stdout = $stdout, @mock_stdout
+    end
+
+    after do
+      $stdout = @real_stdout
+    end
+
+    def expect_help_with_message(out, message)
+      expect(out).to include(message)
+      expect(out)
+        .to include('Usage: wgif [YouTube URL] [output file] [options]')
+      cli.argument_parser.argument_summary.each do |help_info|
+        expect(out).to include(help_info)
+      end
+      expect(out).to include('Example:')
+    end
+
+    it 'catches invalid URLs' do
+      WGif::ArgumentParser.any_instance.stub(:parse)
+        .and_raise(WGif::InvalidUrlException)
+      expect { cli.make_gif([]) }.to raise_error(SystemExit)
+      message = 'That looks like an invalid URL. Check the syntax.'
+      expect_help_with_message(@mock_stdout.string, message)
+    end
+
+    it 'catches invalid timestamps' do
+      WGif::ArgumentParser.any_instance.stub(:parse)
+        .and_raise(WGif::InvalidTimestampException)
+      expect { cli.make_gif([]) }.to raise_error(SystemExit)
+      message = 'That looks like an invalid timestamp. Check the syntax.'
+      expect_help_with_message(@mock_stdout.string, message)
+    end
+
+    it 'catches missing output args' do
+      WGif::ArgumentParser.any_instance.stub(:parse)
+        .and_raise(WGif::MissingOutputFileException)
+      expect { cli.make_gif([]) }.to raise_error(SystemExit)
+      message = 'Please specify an output file.'
+      expect_help_with_message(@mock_stdout.string, message)
+    end
+
+    it 'catches missing videos' do
+      WGif::ArgumentParser.any_instance.stub(:parse)
+        .and_raise(WGif::VideoNotFoundException)
+      expect { cli.make_gif([]) }.to raise_error(SystemExit)
+      message = "WGif can't find a valid YouTube video at that URL."
+      expect_help_with_message(@mock_stdout.string, message)
+    end
+
+    it 'catches encoding exceptions' do
+      WGif::ArgumentParser.any_instance.stub(:parse)
+        .and_raise(WGif::ClipEncodingException)
+      expect { cli.make_gif([]) }.to raise_error(SystemExit)
+      message = 'WGif encountered an error transcoding the video.'
+      expect_help_with_message(@mock_stdout.string, message)
+    end
+
+    it 'catches upload errors' do
+      WGif::ArgumentParser.any_instance.stub(:parse)
+        .and_raise(WGif::ImgurException, 'Imgur error')
+      expect { cli.make_gif([]) }.to raise_error(SystemExit)
+      expect_help_with_message(@mock_stdout.string, 'Imgur error')
+    end
+
+    it 'raises SystemExit when thrown' do
+      WGif::ArgumentParser.any_instance.stub(:parse).and_raise(SystemExit)
+      expect { cli.make_gif([]) }.to raise_error(SystemExit)
+    end
+
+    it 'Prints the backtrace for all other exceptions' do
+      exception = StandardError.new 'crazy error'
+      WGif::ArgumentParser.any_instance.stub(:parse).and_raise(exception)
+      expect { cli.make_gif([]) }.to raise_error(SystemExit)
+      message = 'Something went wrong creating your GIF. The details:'
+      expect_help_with_message(@mock_stdout.string, message)
+      expect(@mock_stdout.string).to include('Please open an issue')
+      expect(@mock_stdout.string).to include("#{exception}")
+      expect(@mock_stdout.string).to include(exception.backtrace.join("\n"))
+    end
+
+    it 'prints help information' do
+      expect { cli.make_gif(['-h']) }.to raise_error(SystemExit)
+      cli.argument_parser.argument_summary.each do |help_info|
+        expect(@mock_stdout.string).to include(help_info)
+      end
+    end
+  end
+end