wgif 0.0.1.pre

data/lib/wgif/gif_maker.rb

@@ -0,0 +1,19 @@
+require 'RMagick'
+
+module WGif
+  class GifMaker
+    def make_gif(frames_dir, filename, dimensions)
+      image = Magick::ImageList.new(*frames_dir)
+      resize(image, dimensions)
+      image.coalesce
+      image.optimize_layers Magick::OptimizeLayer
+      image.write(filename)
+    end
+
+    def resize(image, dimensions)
+      image.each do |frame|
+        frame.change_geometry(dimensions) { |cols, rows, img| img.resize!(cols, rows) }
+      end
+    end
+  end
+end

data/lib/wgif/installer.rb

@@ -0,0 +1,34 @@
+module WGif
+  class Installer
+
+    DEPENDENCIES = [['ffmpeg', 'ffmpeg'], ['imagemagick', 'convert']]
+
+    def run
+      if homebrew_installed?
+        DEPENDENCIES.each do |dependency, binary|
+          install(dependency, binary)
+        end
+      else
+        puts "WGif can't find Homebrew. Visit http://brew.sh/ to get it."
+        Kernel.exit 0
+      end
+    end
+
+    def homebrew_installed?
+      Kernel.system 'brew info > /dev/null'
+    end
+
+    def install(dependency, binary)
+      unless installed?(binary)
+        puts "Installing #{dependency}..."
+        Kernel.system "brew install #{dependency} > /dev/null"
+        puts "Successfully installed #{dependency}."
+      end
+    end
+
+    def installed?(binary)
+      Kernel.system "which #{binary} > /dev/null"
+    end
+
+  end
+end

data/lib/wgif/version.rb

@@ -0,0 +1,3 @@
+module WGif
+  VERSION = "0.0.1.pre"
+end

data/lib/wgif/video.rb

@@ -0,0 +1,58 @@
+require 'streamio-ffmpeg'
+require 'fileutils'
+
+module WGif
+  class Video
+    attr_accessor :name, :clip, :logger
+
+    def initialize name, filepath
+      @name = name
+      @clip = FFMPEG::Movie.new(filepath)
+      FileUtils.mkdir_p "/tmp/wgif/"
+      @logger = Logger.new("/tmp/wgif/#{name}.log")
+      FFMPEG.logger = @logger
+    end
+
+    def trim start_timestamp, duration
+      options = {
+        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)
+      WGif::Video.new "#{@name}-clip", "/tmp/wgif/#{@name}-clip.mov"
+    end
+
+    def to_frames(options={})
+      make_frame_dir
+      if options[:frames]
+        framerate = options[:frames] / @clip.duration
+      else
+        framerate = 24
+      end
+      transcode(@clip, "/tmp/wgif/frames/\%2d.png", "-vf fps=#{framerate}")
+      open_frame_dir
+    end
+
+    private
+
+    def make_frame_dir
+      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")
+    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"
+      end
+    end
+
+  end
+end

data/lib/wgif/video_cache.rb

@@ -0,0 +1,18 @@
+require 'pathname'
+
+module WGif
+  class VideoCache
+
+    def initialize
+      @cache = {}
+    end
+
+    def get(video_id)
+      path = "/tmp/wgif/#{video_id}"
+      if Pathname.new(path).exist?
+        WGif::Video.new(video_id, path)
+      end
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rspec'
+require 'simplecov'
+
+if ENV['COVERAGE'] == 'true'
+  SimpleCov.start do
+    add_filter '/spec/'
+  end
+end

data/spec/wgif/cli_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+require 'wgif/cli'
+
+describe WGif::CLI do
+  let(:cli) { described_class.new }
+
+  it 'parses a URL from command line args' do
+    args = cli.parse_args ["http://example.com"]
+    args[:url].should eq("http://example.com")
+  end
+
+  it 'starts at 0s by default' do
+    args = cli.parse_args ["http://example.com"]
+    args[:trim_from].should eq("00:00:00")
+  end
+
+  it 'trims clips to 1s by default' do
+    args = cli.parse_args ["http://example.com"]
+    args[:duration].should eq(1)
+  end
+
+  it 'parses the short frame count option' do
+    options = cli.parse_options ["-f", "40"]
+    options[:frames].should eq(40)
+  end
+
+  it 'parses the long frame count option' do
+    options = cli.parse_options ["--frames", "40"]
+    options[:frames].should eq(40)
+  end
+
+  it 'parses the short start time option' do
+    options = cli.parse_options ["-s", "00:00:05"]
+    options[:trim_from].should eq("00:00:05")
+  end
+
+  it 'parses the long start time option' do
+    options = cli.parse_options ["--start", "00:00:05"]
+    options[:trim_from].should eq("00:00:05")
+  end
+
+  it 'parses the short duration option' do
+    options = cli.parse_options ["-d", "1.43"]
+    options[:duration].should eq(1.43)
+  end
+
+  it 'parses the long duration option' do
+    options = cli.parse_options ["--duration", "5.3"]
+    options[:duration].should eq(5.3)
+  end
+
+  it 'parses the short dimensions option' do
+    options = cli.parse_options ["-w", "400"]
+    expect(options[:dimensions]).to eq("400")
+  end
+
+  it 'parses the long dimensions option' do
+    options = cli.parse_options ["--width", "300"]
+    expect(options[:dimensions]).to eq("300")
+  end
+
+  it 'handles args in wacky order' do
+    args = cli.parse_args([
+      "-d",
+      "1.5",
+      "http://example.com",
+      "--frames",
+      "60",
+      "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")
+  end
+
+  context 'validating args' do
+
+    it 'checks for a missing output file' do
+      args = cli.parse_args([
+        "http://example.com",
+      ])
+      expect{ cli.validate_args args }.to raise_error(WGif::MissingOutputFileException)
+    end
+
+    it 'checks for an invalid URL' do
+      args = cli.parse_args([
+        "crazy nonsense",
+        "output.gif"
+      ])
+      expect{ cli.validate_args args }.to raise_error(WGif::InvalidUrlException)
+    end
+
+    it 'checks for an invalid timestamp' do
+      args = cli.parse_args([
+        "http://lol.wut",
+        "output.gif",
+        "-s",
+        "rofl"
+      ])
+      expect{ cli.validate_args args }.to raise_error(WGif::InvalidTimestampException)
+    end
+
+    it 'returns true when args are OK' do
+      args = cli.parse_args([
+        "https://crazynonsense.info",
+        "output.gif"
+      ])
+      expect{ cli.validate_args args }.not_to raise_error
+    end
+  end
+
+  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.parser.summarize.each do |help_info|
+        expect(out).to include(help_info)
+      end
+      expect(out).to include('Example:')
+    end
+
+    it 'catches invalid URLs' do
+      OptionParser.any_instance.stub(:parse!).and_raise(WGif::InvalidUrlException)
+      expect{ cli.make_gif([]) }.to raise_error(SystemExit)
+      expect_help_with_message(@mock_stdout.string, 'That looks like an invalid URL. Check the syntax.')
+    end
+
+    it 'catches invalid timestamps' do
+      OptionParser.any_instance.stub(:parse!).and_raise(WGif::InvalidTimestampException)
+      expect{ cli.make_gif([]) }.to raise_error(SystemExit)
+      expect_help_with_message(@mock_stdout.string, 'That looks like an invalid timestamp. Check the syntax.')
+    end
+
+    it 'catches missing output args' do
+      OptionParser.any_instance.stub(:parse!).and_raise(WGif::MissingOutputFileException)
+      expect{ cli.make_gif([]) }.to raise_error(SystemExit)
+      expect_help_with_message(@mock_stdout.string, 'Please specify an output file.')
+    end
+
+    it 'catches missing videos' do
+      OptionParser.any_instance.stub(:parse!).and_raise(WGif::VideoNotFoundException)
+      expect{ cli.make_gif([]) }.to raise_error(SystemExit)
+      expect_help_with_message(@mock_stdout.string, "WGif can't find a valid YouTube video at that URL.")
+    end
+
+    it 'catches encoding exceptions' do
+      OptionParser.any_instance.stub(:parse!).and_raise(WGif::ClipEncodingException)
+      expect{ cli.make_gif([]) }.to raise_error(SystemExit)
+      expect_help_with_message(@mock_stdout.string, "WGif encountered an error transcoding the video.")
+    end
+
+    it 'raises SystemExit when thrown' do
+      OptionParser.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 = Exception.new 'crazy error'
+      OptionParser.any_instance.stub(:parse!).and_raise(exception)
+      expect{ cli.make_gif([]) }.to raise_error(SystemExit)
+      expect_help_with_message(@mock_stdout.string, 'Something went wrong creating your GIF. The details:')
+      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.parser.summarize.each do |help_info|
+        expect(@mock_stdout.string).to include(help_info)
+      end
+    end
+
+  end
+
+end

data/spec/wgif/download_bar_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'wgif/download_bar'
+
+describe WGif::DownloadBar do
+
+  context 'setup' do
+
+    let(:download_bar) { described_class.new }
+    let(:mock_progress_bar) { double(ProgressBar) }
+
+    before do
+      ProgressBar.stub(:create).and_return(mock_progress_bar)
+    end
+
+    it 'creates a ProgressBar with the correct format, smoothing, and size' do
+      progress_bar_params = {
+        format: '==> %p%% |%B|',
+        smoothing: 0.8,
+        total: nil
+      }
+      expect(ProgressBar).to receive(:create).with(progress_bar_params)
+      described_class.new
+    end
+
+    it 'updates the total size' do
+      expect(mock_progress_bar).to receive(:total=).with(500)
+      download_bar.update_total(500)
+    end
+
+    it 'increments the current progress' do
+      expect(mock_progress_bar).to receive(:progress).and_return(1)
+      expect(mock_progress_bar).to receive(:progress=)
+      download_bar.increment_progress(100)
+    end
+
+  end
+
+end

data/spec/wgif/downloader_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'wgif/downloader'
+require 'wgif/video'
+
+describe WGif::Downloader do
+  let(:downloader) { described_class.new }
+  let(:clip_url) { 'http://lol.wut/watch?v=roflcopter' }
+
+  before do
+    FileUtils.rm_rf('/tmp/wgif')
+    download_bar = double(WGif::DownloadBar).as_null_object
+    WGif::DownloadBar.stub(:new).and_return(download_bar)
+  end
+
+  it 'retrieves a YouTube download URL' do
+    ViddlRb.should_receive(:get_urls).with(clip_url).and_return(['clip url'])
+    downloader.video_url(clip_url).should eq('clip url')
+  end
+
+  it 'retrieves a YouTube video ID' do
+    downloader.video_id(clip_url).should eq('roflcopter')
+  end
+
+  it 'throws an error if the video is not found' do
+    ViddlRb.should_receive(:get_urls).with(clip_url).and_return(['http://lol.wut'])
+    expect{ downloader.get_video(clip_url) }.to raise_error(WGif::VideoNotFoundException)
+  end
+
+  it 'extracts a YouTube ID from a URL' do
+    downloader.video_id("https://www.youtube.com/watch?v=tmNXKqeUtJM").should eq("tmNXKqeUtJM")
+  end
+
+  context 'downloading videos' do
+
+    before do
+      ViddlRb.stub(:get_urls).and_return([clip_url])
+      fake_request = double('Typhoeus::Request')
+      fake_response = double('Typhoeus::Response')
+      Typhoeus::Request.should_receive(:new).once.with(clip_url).and_return(fake_request)
+      fake_request.should_receive(:on_headers)
+      fake_request.should_receive(:on_body)
+      fake_request.should_receive(:run).and_return(fake_response)
+      fake_response.should_receive(:response_code).and_return(200)
+    end
+
+    it 'downloads a clip' do
+      video = double(name: 'video')
+      WGif::Video.should_receive(:new).with('roflcopter', "/tmp/wgif/roflcopter").
+        and_return(video)
+      video = downloader.get_video(clip_url)
+    end
+
+    it 'does not download the clip when already cached' do
+      downloader.get_video(clip_url)
+      downloader.get_video(clip_url)
+    end
+  end
+
+  context 'errors' do
+
+    it 'throws an exception when the download URL is not found' do
+      ViddlRb.stub(:get_urls).and_raise(RuntimeError)
+      expect{ downloader.video_url('invalid url') }.to raise_error(WGif::VideoNotFoundException)
+    end
+
+    it 'throws an exception when the download URL is invalid' do
+      expect{ downloader.video_id(nil) }.to raise_error(WGif::InvalidUrlException)
+    end
+
+  end
+
+end