screengif 0.0.1

data/.gitignore

@@ -0,0 +1,10 @@
+.bundle/
+vendor/
+Gemfile.lock
+
+output
+build
+*.gem
+
+*.swp
+*.swo

data/DEVNOTES.md

@@ -0,0 +1,54 @@
+screengif dev notes
+===================
+
+## Building the gem
+
+See [vagrant-vbox-manage/DEVNOTES.md](https://github.com/dergachev/vagrant-vbox-snapshot/blob/master/DEVNOTES.md)
+
+```
+gem build screengif.gemspec
+gem install screengif-0.0.1.gem
+screengif -i=demo.mov -o demo5.gif
+```
+
+### Related solutions
+
+* http://freezeframe.chrisantonellis.com/ (js library to freeze/play gifs)
+* http://askubuntu.com/questions/107726/how-to-create-animated-gif-images-of-a-screencast
+
+### RMagick
+
+* http://railscasts.com/episodes/374-image-manipulation?view=asciicast
+* http://ruby.bastardsbook.com/chapters/image-manipulation/
+* https://github.com/markandrus/imgswiss/blob/master/pipeline.rb (ffmpeg -> imagemagick via rmagick -> gif)
+
+* http://www.imagemagick.org/RMagick/doc/info.html#format
+* http://www.imagemagick.org/RMagick/doc/draw.html#rectangle
+* http://www.imagemagick.org/RMagick/doc/constants.html#GravityType
+* http://www.simplesystems.org/RMagick/doc/optequiv.html
+* http://www.imagemagick.org/RMagick/doc/ilist.html
+* http://www.imagemagick.org/RMagick/doc/clip_path.rb.html (define_clip_path example)
+
+### Imagemagick
+
+* http://www.imagemagick.org/Usage/draw/
+* http://www.imagemagick.org/Usage/anim_opt/
+* http://www.imagemagick.org/Usage/transform/#fx
+* http://www.imagemagick.org/Usage/layers/
+* http://www.imagemagick.org/script/command-line-options.php#delete
+* http://www.imagemagick.org/script/fx.php
+* http://www.imagemagick.org/script/escape.php
+* http://www.imagemagick.org/Usage/annotating/#watermarking
+* http://www.imagemagick.org/Usage/anim_mods/#frame_mod
+* http://www.ioncannon.net/linux/81/5-imagemagick-command-line-examples-part-1/
+
+## Bash guides
+
+* http://andreinc.net/2011/09/04/bash-scripting-best-practice/
+* http://stackoverflow.com/questions/242538/unix-shell-script-find-out-which-directory-the-script-file-resides
+
+## Ruby guides
+
+* TODO: implement tests; see https://github.com/pgericson/progress_bar/blob/master/test/arguments_test.rb
+* TODO: look at mixlib-{shellout,cli,logger}; https://github.com/opscode/mixlib-shellout
+* TODO: look at https://github.com/bitboxer/simple_progressbar/blob/master/lib/simple_progressbar.rb

data/Dockerfile

@@ -0,0 +1,28 @@
+FROM ubuntu:14.04
+
+# If host is running squid-deb-proxy on port 8000, populate /etc/apt/apt.conf.d/30proxy
+# By default, squid-deb-proxy 403s unknown sources, so apt shouldn't proxy ppa.launchpad.net
+RUN route -n | awk '/^0.0.0.0/ {print $2}' > /tmp/host_ip.txt
+RUN echo "HEAD /" | nc `cat /tmp/host_ip.txt` 8000 | grep squid-deb-proxy \
+  && (echo "Acquire::http::Proxy \"http://$(cat /tmp/host_ip.txt):8000\";" > /etc/apt/apt.conf.d/30proxy) \
+  && (echo "Acquire::http::Proxy::ppa.launchpad.net DIRECT;" >> /etc/apt/apt.conf.d/30proxy) \
+  || echo "No squid-deb-proxy detected on docker host"
+
+RUN apt-get update
+
+RUN apt-get install -y imagemagick
+RUN apt-get install -y libmagickwand-dev
+RUN apt-get install -y gifsicle 
+RUN apt-get -y install ruby1.9.1 ruby1.9.1-dev 
+RUN apt-get install -y build-essential curl git vim
+
+RUN apt-get install -y python-software-properties software-properties-common
+RUN add-apt-repository ppa:mc3man/trusty-media
+RUN apt-get update
+RUN apt-get -y install ffmpeg
+
+RUN gem install bundler --no-rdoc --no-ri
+ADD Gemfile /tmp/Gemfile
+RUN cd /tmp; bundle install
+
+WORKDIR /srv/screengif

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gem 'rmagick'

data/Makefile

@@ -0,0 +1,20 @@
+build:
+	docker build -t dergachev/screengif .
+
+cmd=/bin/bash
+docker-run:
+	docker run -t -i \
+		-v `pwd`:/srv/screengif \
+		dergachev/screengif \
+		/bin/bash -c "umask 002; $(cmd) $(args)"
+
+docker-bash:
+	$(MAKE) docker-run cmd="/bin/bash"
+
+docker-convert:
+	$(MAKE) docker-run cmd="bin/screengif" args="$(args)"
+
+docker-shell:
+	$(MAKE) docker-run cmd="/bin/bash"
+
+.PHONY: build docker-run docker-convert docker-shell

data/README.md

@@ -0,0 +1,111 @@
+# Screengif
+
+A commandline tool to convert SCREENCAST.mov into ANIMATED.gif
+
+Here's what happens when you apply it to [demo.mov](https://raw.github.com/dergachev/screengif/master/demo.mov)
+
+<img src="https://raw.github.com/dergachev/screengif/master/demo.gif" width="400" />
+
+## Usage
+
+```
+screengif.rb - Convert your screencast into a gif.
+Usage:
+	screengif.rb [options] [--input FILENAME.mov] [--output OUTPUTFILE.gif]
+Examples:
+	./screengif.rb --input demo.mov --output out.gif
+	cat somefile.gif | ./screengif.rb --progressbar --framerate 10 --delay 50 --delay-last 5 > out.gif
+
+Specific options:
+    -i, --input FILENAME.mov         Use ffmpeg to convert FILENAME.mov into PPM image stream and process results.
+                                     If missing, will process PPM or GIF image stream from STDIN.
+    -o, --output FILENAME.gif        Output resulting GIF data to FILENAME.gif. (defaults to STDOUT).
+    -p, --progressbar                Overlay progress bar on the animation.
+    -d, --delay MS                   Animation frame delay, in tens of ms. (default: 10)
+        --delay-last MS              Animation frame delay of last frame, in tens of ms. (default: 50)
+    -r, --framerate FPS              Specify amount of frames per second to keep. (default: 5)
+    -w, --max-width PIXELS           Output image max width, in pixels.
+        --max-height PIXELS          Output image max height, in pixels.
+        --no-contrast                Skip increasing contrast using imagemagick.
+    -f, --fuzz PERCENT               Imagemagick fuzz factor for color reduction. (default: 5%)
+        --no-coalesce                Skip Magick::ImageList#coalesce() if input doesn't need it.
+        --no-gifsicle                Prevent filter the output through gifsicle. Greatly increases output file size.
+    -h, --help                       Show this message
+    -v, --verbose                    Verbose output
+        --version                    Show version
+```
+
+## Installation
+
+### Under Docker
+
+If you have docker running, this is the quickest way to get
+started with screengif:
+
+```
+git clone git@github.com:dergachev/screengif.git
+cd screengif
+
+make build      # or alternatively, 'docker pull dergachev/screengif'
+
+make docker-convert args="-i demo.mov -o demo-docker.gif"
+
+# input files must be relative to cloned screengif repo
+cp /path/to/myMovie.mov .
+
+make docker-convert args="-i myMovie.mov -o myMovie.gif"
+```
+
+See Dockerfile and Makefile for how it works.
+
+### With Vagrant
+
+If you have Vagrant and Virtualbox already installed, this is both faster and cleaner than downloading and compiling all the dependencies in OS X. To install, simply do the following:
+
+```
+vagrant up
+```
+
+The easiest way to use it is to copy your image to screengif project directory (shared in the VM under /vagrant), and run the following:
+
+```
+cp ~/screencast.mov ./screencast.mov
+vagrant ssh -- '/vagrant/screengif.rb --input /vagrant/screencast.mov --output /vagrant/output/screencast.gif'
+ls ./output/screencast.gif # should exist!
+
+# when finished, destroy the VM
+vagrant destroy -f
+```
+
+### On OSX, with homebrew
+
+The following works with OS X and homebrew, assuming you have ruby 1.9.2+:
+
+You may need to install brew-cask: https://github.com/phinze/homebrew-cask
+
+```bash
+git clone https://github.com/dergachev/screengif.git
+cd screengif
+
+# x-quartz is a dependency for gifsicle, no longer installed starting on 10.8
+brew cask install xquartz 
+open /opt/homebrew-cask/Caskroom/xquartz/2.7.7/XQuartz.pkg # runs the XQuartz installer
+
+brew install ffmpeg imagemagick gifsicle
+gem install rmagick
+```
+
+## Tips
+
+See https://gist.github.com/dergachev/4627207#os-x-screencast-to-animated-gif
+for a guide on how to use Quicktime Player to record a screencast on OS X.  
+Keep in mind that other tools (like Screenflow) produce better video quality.
+
+If you install [dropbox-screenshots](https://github.com/dergachev/dropbox-screenshots),
+the following will automatically upload your new gif to Dropbox: 
+
+    cp out.gif ~/Dropbox/Public/screenshots
+
+## Resources
+
+See [DEVNOTES](https://github.com/dergachev/screengif/blob/master/DEVNOTES.md)

data/Vagrantfile

@@ -0,0 +1,27 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+Vagrant.configure("2") do |config|
+  config.vm.box = "precise64"
+
+  # config.vm.provision :shell, :inline => "apt-get install -y vim curl git"
+
+  config.vm.provision :shell, :inline => <<-EOH
+    apt-get update
+    apt-get install -y ffmpeg gifsicle imagemagick libmagickwand-dev
+    apt-get -y install ruby1.9.1 ruby1.9.1-dev 
+    gem install bundler --no-rdoc --no-ri
+    cd /vagrant
+    bundle install
+  EOH
+
+  # test that everything is installed correctly by generating ./output/demo.gif
+  config.vm.provision :shell, :inline => <<-EOH
+    cd /vagrant
+    test -f ./output/demo.gif && exit 0 # ensures this script runs just once
+    echo "Testing deployment by converting ./demo.mov to ./output/demo.gif"
+    mkdir -p ./output
+    # vagrant colors stderr red (undesirable), so redirect it to stdout
+    ./screengif.rb --input demo.mov --output ./output/demo.gif 2>&1
+  EOH
+end

data/bin/screengif

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+# when run as gem, $0 is /usr/local/bin/screengif not this file
+if $0 == __FILE__
+  $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+end
+
+require 'screengif'
+
+Screengif::start

data/lib/screengif.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+
+require 'RMagick'
+include Magick
+
+require 'screengif/draw_progressbar.rb'
+require 'screengif/options.rb'
+require 'screengif/util.rb'
+
+module Screengif
+  def self.call_ffmpeg(input_file, options, verbose)
+    ffmpeg_loglevel = verbose ? 'verbose' : 'warning'
+    if options.framerate
+      ffmpeg_framerate = "-r #{options.framerate}"
+    end
+
+    if options.max_width || options.max_height
+      options.max_width ||= "-1"
+      options.max_height ||= "-1"
+      ffmpeg_resize = "-vf scale=#{options.max_width}:#{options.max_height} -sws_flags lanczos"
+    end
+    # TODO: error handling
+    return `ffmpeg -i '#{input_file}' -loglevel #{ffmpeg_loglevel} #{ffmpeg_framerate} #{ffmpeg_resize} -f image2pipe -vcodec ppm - `
+  end
+
+  def self.call_gifsicle(data)
+    $stderr.puts "Filtering output through gifsicle" if $verbose
+    # TODO: error handling
+    result = ''
+    # popen is for system calls that require setting STDIN
+    IO.popen('gifsicle --loop --optimize=3 --multifile -', 'r+') do |f|
+      f.write(data)
+      f.close_write
+      result = f.read
+    end
+    return result
+  end
+
+  def self.handle_input(input_file, options, optionparser)
+    if (input_file)
+      $stderr.puts "Running ffmpeg with #{input_file}" if $verbose
+      input = Screengif::call_ffmpeg(input_file, options, $verbose)
+    elsif !$stdin.tty? # we are being piped to
+      $stderr.puts "Reading input from STDIN." if $verbose
+      input = STDIN.read
+    else
+      $stderr.puts "No input file available."
+      puts optionparser
+      exit 1
+    end
+    return input
+  end
+
+  def self.handle_output(output_file, output, optionparser)
+    if (output_file)
+      File.open(output_file, 'w') do |f|
+        f.puts output
+      end
+    elsif !STDOUT.tty?
+      $stderr.puts "Sending output to STDOUT" if $verbose
+      puts output
+    else
+      $stderr.puts "Error: No output destination available."
+      puts optionparser
+      exit 1
+    end
+  end
+
+  def self.start
+    options,optionparser = Screengif::Options.parse(ARGV)
+    $startTime = Time.now
+
+    input = handle_input(options.input_file, options, optionparser)
+    canvas = ImageList.new.from_blob(input)
+
+    if (!options.no_coalesce)
+      $stderr.puts "Beginning imagemagick coalescing..." if $verbose
+      canvas = canvas.coalesce()
+      $stderr.puts "Coalescing completed" if $verbose
+    end
+
+    statusPrinter = Screengif::StatusPrinter.new($stderr)
+    canvas.each_with_index do |img,index|
+      statusPrinter.printText("Processing image: #{index+1}/#{canvas.length}")
+      img.delay = (index + 1  == canvas.length) ? options.delay_last : options.delay
+      img.format = 'GIF'
+
+      if options.fuzz.to_i > 0
+        # when run as a gem, setting img.fuzz="5%" throws a wierd error; so we do this instead
+        #   img.fuzz = "#{img.fuzz}%"
+        img.fuzz = QuantumRange * options.fuzz.to_i / 100.0
+      end
+      unless options.nocontrast
+        img = img.contrast(true)
+        img = img.white_threshold(QuantumRange * 0.99)
+        # img = img.level(QuantumRange * 0.05, QuantumRange * 0.95)
+      end
+      Screengif::DrawProgressbar.draw(img, (index.to_f+1)/canvas.length) if (options.progressbar)
+      canvas[index] = img
+    end
+    statusPrinter.done
+
+    # see http://stackoverflow.com/questions/958681/how-to-deal-with-memory-leaks-in-rmagick-in-ruby
+    GC.start
+
+    # Reduce down to 256 colors (as required by GIF), disable dithering (equivalent to +dither)
+    $stderr.puts "Beginning quantization... (takes a while)" if $verbose
+    canvas = canvas.quantize(256, RGBColorspace, NoDitherMethod)
+    $stderr.puts "Quantization completed." if $verbose
+
+    $stderr.puts "Beginning rmagick OptimizePlusLayer..." if $verbose
+    canvas = canvas.optimize_layers(OptimizePlusLayer)
+    $stderr.puts "Beginning rmagick OptimizeTransLayer..." if $verbose
+    canvas = canvas.optimize_layers(OptimizeTransLayer)
+
+    $stderr.puts "Rmagick processing completed. Outputting results..." if $verbose
+    output = canvas.to_blob 
+
+    GC.start
+
+    output = Screengif::call_gifsicle(output) unless (options.no_gifsicle) 
+
+    handle_output(options.output_file, output, optionparser)
+    Screengif::ConversionStats.print(options.input_file, options.output_file, input, output)
+  end
+end

data/lib/screengif/draw_progressbar.rb

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+module Screengif
+  class DrawProgressbar
+    def self.draw(img,ratio)
+      wid = img.columns() - 3
+      ht = img.rows() - 3 
+      rectWid = 60
+      rectHt = 20
+
+      progressbar = Draw.new
+
+      progressbar
+        .fill('white')
+        .stroke('black')
+        .draw(img)
+        .rectangle(wid-rectWid,ht-rectHt,wid,ht) 
+      progressbar
+        .fill('black')
+        .pointsize(12)
+        .stroke('transparent')
+        .font_weight(BoldWeight)
+        .gravity(NorthWestGravity)
+        .text(wid-rectWid+4,ht-rectHt+5,"screengif")
+      progressbar 
+        .fill('black')
+        .stroke('transparent')
+        .rectangle(wid-rectWid,ht-rectHt,wid-rectWid*(1-ratio),ht) 
+      progressbar.draw(img)
+
+      maskedDraw = Draw.new
+      maskedDraw.define_clip_path('clip') {
+        maskedDraw
+          .rectangle(wid-rectWid,ht-rectHt,wid-rectWid*(1-ratio),ht)
+      }
+      maskedDraw.push
+      maskedDraw.clip_path('clip')
+      maskedDraw
+        .fill('white')
+        .pointsize(12)
+        .stroke('transparent')
+        .font_weight(BoldWeight)
+        .gravity(NorthWestGravity)
+        .text(wid-rectWid+4,ht-rectHt+5,"screengif")
+      maskedDraw.pop
+      maskedDraw.draw(img)
+    end
+  end
+end

data/lib/screengif/options.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'ostruct'
+require 'pp'
+
+$verbose = false
+
+module Screengif
+  class Options
+    def self.parse(args)
+      options = OpenStruct.new
+
+      options.framerate = 5
+      options.delay = 10
+      options.delay_last = 50
+      options.no_coalesce = false
+      options.progressbar = false
+      options.input_file = nil
+      options.output_file = nil
+      options.no_gifsicle = false
+      options.fuzz = 5
+
+      # options.ffmpeg_inputfile = nil
+
+      optionparser = OptionParser.new do |opts|
+        opts.banner = "screengif.rb - Convert your screencast into a gif.\n" +
+          "Usage:\n" + 
+            "\tscreengif.rb [options] [--input FILENAME.mov] [--output OUTPUTFILE.gif]\n" +
+          "Examples:\n" +
+            "\t./screengif.rb --input demo.mov --output out.gif\n" +
+            "\tcat somefile.gif | ./screengif.rb --progressbar --framerate 10 --delay 50 --delay-last 5 > out.gif\n"
+
+        opts.separator ""
+        opts.separator "Specific options:"
+
+        opts.on("-i", "--input FILENAME.mov", "Use ffmpeg to convert FILENAME.mov into PPM image stream and process results.", 
+                "If missing, will process PPM or GIF image stream from STDIN.") do |filename|
+          if (File.exists?(filename))
+            options.input_file = filename
+            options.no_coalesce = true # ffmpeg's ppm output is already coalesced
+          else
+            $stderr.puts "Unable to open filename: #{filename}"
+            puts opts
+            exit 1
+          end
+        end
+        opts.on("-o", "--output FILENAME.gif", "Output resulting GIF data to FILENAME.gif. (defaults to STDOUT).") do |filename|
+          options.output_file  = filename
+        end
+
+        opts.on("-d", "--delay MS", Integer, "Animation frame delay, in tens of ms. (default: 10)") do |tens_of_ms|
+          options.delay = tens_of_ms.to_i
+        end
+
+        opts.on("-p", "--progressbar", "Overlay progress bar on the animation.") do
+          options.progressbar = true
+        end
+
+        opts.on("-d", "--delay MS", Integer, "Animation frame delay, in tens of ms. (default: 10)") do |tens_of_ms|
+          options.delay = tens_of_ms.to_i
+        end
+
+        opts.on("--delay-last MS", Integer, "Animation frame delay of last frame, in tens of ms. (default: 50)") do |tens_of_ms|
+          options.delay_last = tens_of_ms.to_i
+        end
+
+        opts.on("-r", "--framerate FPS", Integer, "Specify amount of frames per second to keep. (default: 5)") do |fps|
+          options.framerate = fps.to_i
+        end
+
+        opts.on("-w", "--max-width PIXELS", Integer, "Output image max width, in pixels.") do |pixels|
+          options.max_width = pixels.to_i
+        end
+
+        opts.on("--max-height PIXELS", Integer, "Output image max height, in pixels.") do |pixels|
+          options.max_height = pixels.to_i
+        end
+
+        opts.on("--no-contrast", "Skip increasing contrast using imagemagick.") do
+          options.nocontrast = true
+        end
+
+        opts.on("-f", "--fuzz PERCENT", Integer, "Imagemagick fuzz factor for color reduction. (default: 5%)") do |fuzz|
+          options.fuzz = fuzz.to_i
+        end
+
+        opts.on("--no-coalesce", "Skip Magick::ImageList#coalesce() if input doesn't need it.") do
+          options.no_coalesce = true
+        end
+
+        opts.on("--no-gifsicle", "Prevent filter the output through gifsicle. Greatly increases output file size.") do
+          options.no_gifsicle = true
+        end
+
+        # Boilerplate
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+        opts.on_tail("-v", "--verbose", "Verbose output") do
+          $verbose = true
+        end
+        opts.on_tail("--version", "Show version") do
+          puts "0.1"
+          exit
+        end
+      end
+      optionparser.parse!(args)
+      return options, optionparser
+    end
+  end
+end

data/lib/screengif/util.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby 
+
+
+module Screengif
+  class StatusPrinter
+    # inspired by http://stackoverflow.com/a/6679572/9621
+    def initialize(stream)
+      @previous_size = 0
+      @stream = stream || $stdout
+    end
+
+    def printText(text)
+      if @previous_size > 0
+        @stream.print "\033[#{@previous_size}D"
+        @stream.print(" " * @previous_size) 
+        @stream.print "\033[#{@previous_size}D"
+      end
+      @stream.print text
+      @stream.flush
+      @previous_size = text.gsub(/\e\[\d+m/,"").size
+    end
+
+    def done()
+      @previous_size = 0
+      @stream.print "\n"
+    end
+  end
+
+  class ConversionStats
+    def self.print(input_file, output_file, input, output)
+      $stderr.puts "Conversion completed in #{Time.now - $startTime} seconds."
+      if input_file # ffmpeg
+        #   Duration: 00:00:04.28, start: 0.010333, bitrate: 11225 kb/s
+        duration = (`ffmpeg -i '#{input_file}' 2>&1 | grep Duration`).gsub(/^.*Duration:\s*([^,]+),.*$/, '\1').gsub("\n",'')
+
+        input_filesize = `ls -lh '#{input_file}' | awk '{print $5}'`.gsub("\n",'')
+        $stderr.puts "Input: #{input_file} (#{duration}, #{input_filesize})"
+      else # piped input
+        input_contentsize = (input.bytesize.to_f / 2**10).to_i().to_s + "K"
+        $stderr.puts "Input: STDIN (#{input_contentsize})"
+      end
+      if output_file
+        output_filesize = `ls -lh '#{output_file}' | awk '{print $5}'`.gsub("\n",'')
+        $stderr.puts "Output: '#{output_file}' (#{output_filesize})"
+      else # piped output
+        output_contentsize = (output.bytesize.to_f / 2**10).to_i().to_s + "K"
+        $stderr.puts "Output: STDOUT (#{output_contentsize})"
+      end
+    end
+  end
+end

data/screengif.gemspec

@@ -0,0 +1,21 @@
+$:.unshift File.expand_path('../lib', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = "screengif"
+  spec.version       = "0.0.1"
+  spec.authors       = "Alex Dergachev"
+  spec.email         = "alex@evolvingweb.ca"
+  spec.summary       = 'Script to convert mov files to animated gifs.'
+  spec.description   = 'Wrapper on ffmpeg and imagemagick to convert .mov to .gif'
+  spec.homepage      = 'https://github.com/dergachev/screengif'
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.bindir        = 'bin'
+  spec.executables   = 'screengif'
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_path  = 'lib'
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification
+name: screengif
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Alex Dergachev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Wrapper on ffmpeg and imagemagick to convert .mov to .gif
+email: alex@evolvingweb.ca
+executables:
+- screengif
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- DEVNOTES.md
+- Dockerfile
+- Gemfile
+- Makefile
+- README.md
+- Vagrantfile
+- bin/screengif
+- demo.gif
+- demo.mov
+- lib/screengif.rb
+- lib/screengif/draw_progressbar.rb
+- lib/screengif/options.rb
+- lib/screengif/util.rb
+- screengif.gemspec
+homepage: https://github.com/dergachev/screengif
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Script to convert mov files to animated gifs.
+test_files: []