cutcut 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 75111491536a777f1518aa51a025c2bb87356ef9
+  data.tar.gz: 70b2fc148ed07dd389e27c39e68f0d8d1e0fedab
+SHA512:
+  metadata.gz: 4ac1b04f0962ae62ddca62be5cce326a5c8de92500cc842244ae7c760ade07494aae97dcb582202ec76eb5422b72a834dd68b91cbe43d2449e5fcc29162dc037
+  data.tar.gz: 539a48f89ff804c4372005a62e41b9e2e2a5eb5d6752f508415d51cf8bd66a1887005eb0736f272a8f578b8aade8cf97f4b8dd950bbabbbd537297b460531307

data/.gitignore

@@ -0,0 +1,15 @@
+*~
+coverage/*
+*.sqlite3
+.bundle
+rdoc/*
+pkg
+log
+test/tmp/*
+spec/tmp/*
+spec/fixtures/*.MP4
+spec/fixtures/*.jpg
+spec/fixtures/*.png
+dummy
+*.gem
+Gemfile.lock

data/.rubocop.yml

@@ -0,0 +1,2 @@
+Metrics/LineLength:
+  Max: 500

data/CHANGELOG.md

@@ -0,0 +1,30 @@
+Changelog
+=========
+
+Version 1.1.0 (March 17, 2016)
+-----------------------------
+
+* Add Timelapse support
+* Add --copy-metadata option
+* Add --scale option
+* Add --timelapse-fps option
+
+Version 1.0.0 (February 11, 2016)
+-----------------------------
+
+* Use hash options on initialize
+* Add `speec` to convert method
+
+Version 0.0.2 (February 8, 2016)
+-----------------------------
+
+* Remove Gemfile.lock
+* Add basename and fps to extract_screenshots
+* Add `media.cut`
+
+Version 0.0.1 (February 5, 2016)
+-----------------------------
+
+* Add Media model
+* Add convert media action
+* Add extract_screenshot action

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,17 @@
+guard :rspec, cmd: 'bundle exec rspec' do
+  require 'guard/rspec/dsl'
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+end
+
+guard :rubocop do
+  watch(/.+\.rb$/)
+  watch(%r{(?:.+/)?\.rubocop\.yml$}) { |m| File.dirname(m[0]) }
+end

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Jhimy Fernandes Villar.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+# cutcut
+
+Trim/Cut/Screenshot videos
+
+# Usage
+
+```
+  gem install cutcut git: git@github.com:stjhimy/cutcut.git
+```
+
+```ruby
+  media = CutCut::Media.new(input: 'path_to_file.mp4')
+  media.convert(scale: '1280:720')
+  media.convert(scale: '1280:720', copy_metadata: true)
+  media.extract_screenshots
+  media.cut(start: '00:00', time: 10)
+
+  timelapse = CutCut::Timelapse.new(input: 'path_to_folder')
+  media.convert(scale: '1280:720')
+  media.convert(scale: '1280:720', fps: 60)
+```
+
+```
+cutcut --help
+Usage: cutcut [options]
+        --convert                    Convert all videos in a folder
+        --copy-metadata              Copy original video metadata
+        --scale                      SCALE_RESOLUTION
+        --timelapse-fps FPS          Timelapse FPS
+        --extract-screenshots NUMBER Screenshots per second
+```
+
+## License
+
+MIT License. Copyright 2016 Jhimy Fernandes Villar.

data/bin/cutcut

@@ -0,0 +1,41 @@
+#!/usr/bin/env ruby
+
+require 'cutcut'
+require 'optparse'
+require 'ruby-progressbar'
+
+options = {}
+OptionParser.new do |opt|
+  opt.on('--convert', 'Convert all videos in a folder') { options[:convert] = true }
+  opt.on('--copy-metadata', 'Copy original video metadata') { options[:copy_metadata] = true }
+  opt.on('--scale', 'SCALE_RESOLUTION') { |e| options[:scale] = e }
+  opt.on('--timelapse-fps FPS', 'Timelapse FPS') { |e| options[:timelapse_fps] = e }
+  opt.on('--extract-screenshots NUMBER', 'Screenshots per second') { |e| options[:extract_screenshots] = e }
+end.parse!
+
+pwd = ENV['PWD']
+options[:input_dir] ||= pwd
+options[:copy_metadata] ||= false
+
+files = Dir[File.join(options[:input_dir], '/*.mp4')]
+folders = Dir.glob(File.join(options[:input_dir], '/*')).select { |e| File.directory?(e) }
+progressbar = ProgressBar.create(title: 'Converting', starting_at: 0, total: files.count + folders.count)
+
+puts "#{files.count + folders.count} files found"
+
+files.each do |file|
+  media = CutCut::Media.new(input: file)
+  scale = options[:scale] || '1920:1080'
+  media.convert(copy_metadata: options[:copy_metadata], scale: scale)
+  media.extract_screenshots(fps: options[:extract_screenshots], copy_metadata: true) if options[:extract_screenshots]
+  progressbar.increment
+end
+
+folders.each do |folder|
+  timelapse = CutCut::Timelapse.new(input: folder, output: File.join(options[:input_dir], File.basename(folder) + '.mp4'))
+  scale = options[:scale] || '1920:1080'
+  timelapse.convert(fps: options[:timelapse_fps] || 30, scale: scale)
+  progressbar.increment
+end
+
+puts "\n Finished!"

data/cutcut.gemspec

@@ -0,0 +1,24 @@
+Gem::Specification.new do |s|
+  s.name        = 'cutcut'
+  s.authors     = ['Jhimy Fernandes Villar']
+  s.email       = ['stjhimy@gmail.com']
+  s.homepage    = 'http://github.com/stjhimy/cutcut'
+  s.license     = 'MIT'
+  s.summary     = 'Trim/Cut/Screenshot videos'
+  s.description = 'CLI for working with videos'
+  s.version     = '1.1.0'
+
+  s.executables   = ['cutcut']
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ['lib']
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+
+  s.add_dependency 'activesupport',               '~> 4.2'
+  s.add_dependency 'mini_exiftool',               '~> 2.5'
+  s.add_dependency 'ruby-progressbar',            '~> 1.7'
+
+  s.add_development_dependency 'guard',           '~> 2.13'
+  s.add_development_dependency 'guard-rspec',     '~> 4.6'
+  s.add_development_dependency 'guard-rubocop',   '~> 1.2'
+  s.add_development_dependency 'rspec',           '~> 3.4'
+end

data/lib/cutcut/base.rb

@@ -0,0 +1,26 @@
+module CutCut
+  # Base
+  class Base
+    attr_reader :input, :output
+
+    def initialize(options = {})
+      @input = options.delete(:input)
+      @output = options.delete(:output)
+    end
+
+    def original_date_time
+      exif = MiniExiftool.new(@input)
+      exif.date_time_original || exif.create_date || exif.modify_date
+    end
+
+    private
+
+    def execute_ffmpeg_command(options = {})
+      system("ffmpeg #{options[:raw_options].try(:[], :input)} \
+             -i #{options.delete(:input) || @input} \
+             #{options[:raw_options].try(:[], :output)} \
+             #{options.delete(:output) || @output} \
+             -y > /dev/null 2>&1")
+    end
+  end
+end

data/lib/cutcut/helpers.rb

@@ -0,0 +1,20 @@
+module CutCut
+  # Helpers
+  class Helpers
+    def self.longest_common_substring(*strings)
+      short = strings.min_by(&:length)
+      max = short.length
+      max.downto(0) do |len|
+        0.upto(max - len) do |start|
+          substr = short[start, len]
+          return substr if strings.all? { |str| str.include? substr }
+        end
+      end
+    end
+
+    def self.copy_metadata(origin, target)
+      exif = MiniExiftool.new(target)
+      exif.copy_tags_from(origin, '*')
+    end
+  end
+end

data/lib/cutcut/media.rb

@@ -0,0 +1,64 @@
+module CutCut
+  # Media
+  class Media < Base
+    attr_reader :output_path
+
+    def initialize(options = {})
+      @input = options.delete(:input)
+      @output = options.delete(:output)
+      @output_path = options.delete(:output_path) || File.dirname(@input)
+    end
+
+    def convert(options = {})
+      scale = options[:scale]
+      speed = "-filter:v \"setpts=#{options[:speed]}*PTS\"" if options[:speed]
+      copy_metadata = options[:copy_metadata] || false
+
+      output = options[:output] || @output || File.join(@output_path, '__' + File.basename(@input))
+      raw_options = "-movflags +faststart -vf scale=#{scale} -c:v libx264 -crf 20 -preset ultrafast  #{speed}"
+      execute_ffmpeg_command(input: @input, output: output, raw_options: { output: raw_options })
+
+      Helpers.copy_metadata(@input, output) if copy_metadata
+      output
+    end
+
+    def extract_screenshots(options = {})
+      fps = options[:fps] || 1
+      basename = options[:basename] || File.basename(@input, '.MP4') + '_screenshot'
+      copy_metadata = options[:copy_metadata]
+
+      execute_ffmpeg_command(
+        input: @input,
+        output: "#{output_path}/#{basename}%d.jpg",
+        raw_options: { output: "-vf fps=#{fps}" }
+      )
+
+      copy_metadata_to_screenshots(basename, fps) if copy_metadata
+    end
+
+    def cut(options = {})
+      starts_at = options[:start] || '00:00'
+      time = options[:time] || 1
+      output = options[:output] || "#{File.basename(@input, '.MP4')}_#{starts_at}.mp4"
+
+      execute_ffmpeg_command(
+        input: @input,
+        output: "#{output_path}/#{output}",
+        raw_options: { output: "-ss #{starts_at} -t #{time}" }
+      )
+    end
+
+    def copy_metadata_to_screenshots(basename, fps)
+      Dir.glob("#{output_path}/#{basename}*.jpg").sort.each do |file|
+        seconds = screenshot_basename_time(basename, file, fps)
+        exif = MiniExiftool.new(file)
+        exif.create_date = original_date_time + seconds.seconds
+        exif.save
+      end
+    end
+
+    def screenshot_basename_time(basename, file, fps)
+      (1.0 / fps.to_f) * File.basename(file, '.jpg').gsub(basename, '').to_i - (1.0 / fps.to_f)
+    end
+  end
+end

data/lib/cutcut/timelapse.rb

@@ -0,0 +1,42 @@
+module CutCut
+  # Media
+  class Timelapse < Base
+    def files
+      Dir.glob(File.join(input, '*.JPG'))
+    end
+
+    def basenames
+      files.map { |e| File.basename(e, '.JPG').to_s }
+    end
+
+    def common_substring
+      Helpers.longest_common_substring(*basenames)
+    end
+
+    def start_number
+      basenames.first.gsub(common_substring, '')
+    end
+
+    def input_basename
+      common_substring + "%#{start_number.chars.count}d.JPG"
+    end
+
+    def original_date_time
+      exif = MiniExiftool.new(files.first)
+      exif.date_time_original || exif.create_date || exif.modify_date
+    end
+
+    def convert(options = {})
+      fps = options[:fps] || 30
+      execute_ffmpeg_command(input: File.join(@input, input_basename), output: @output,
+                             raw_options: {
+                               input: "-f image2  -start_number #{start_number} -framerate #{fps}",
+                               output: '-c:v libx264 -r 30 -vf scale=-1:1080 -crf 23 -preset ultrafast -pix_fmt yuv420p'
+                             }
+                            )
+
+      Helpers.copy_metadata(files.first, @output)
+      @output
+    end
+  end
+end

data/lib/cutcut.rb

@@ -0,0 +1,6 @@
+require 'active_support/all'
+require 'cutcut/base'
+require 'cutcut/helpers'
+require 'cutcut/timelapse'
+require 'cutcut/media'
+require 'mini_exiftool'

data/spec/cutcut/base_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe CutCut::Base do
+  before(:all) do
+    system("rm -rf #{File.join(File.dirname(__FILE__), '../fixtures/*.MP4')}")
+    system("rm -rf #{File.join(File.dirname(__FILE__), '../fixtures/*.mp4')}")
+    system("cp #{File.join(File.dirname(__FILE__), '../fixtures/example')} #{File.join(File.dirname(__FILE__), '../fixtures/example.MP4')}")
+  end
+
+  it 'has input and output' do
+    base = CutCut::Base.new(input: 'input', output: 'output')
+    expect(base.input).to eq('input')
+    expect(base.output).to eq('output')
+  end
+
+  it 'has original_date_time' do
+    base = CutCut::Base.new(input: File.join(File.dirname(__FILE__), '../fixtures/example.MP4'), output: 'output')
+    expect(base.original_date_time).to eq('2016-01-25 20:15:35 -0200')
+  end
+end

data/spec/cutcut/helpers_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe CutCut::Helpers do
+  it 'return longest comon string' do
+    expect(CutCut::Helpers.longest_common_substring('foobar', 'foo')).to eq('foo')
+  end
+end

data/spec/cutcut/media_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe CutCut::Media do
+  let(:media) do
+    CutCut::Media.new(input: File.join(File.dirname(__FILE__), '../fixtures/example.MP4'))
+  end
+
+  describe 'initialize' do
+    it 'initialize accessors' do
+      expect(media.input).to_not eq(nil)
+      expect(media.output).to eq(nil)
+      expect(media.output_path).to_not eq(nil)
+    end
+
+    it 'return create_date tag' do
+      expect(media.original_date_time).to eq('2016-01-25 20:15:35 -0200')
+    end
+  end
+
+  describe 'convert' do
+    it 'convert media' do
+      expect(File.exist?(media.convert(scale: '1920:1080'))).to eq true
+    end
+
+    it 'copy metadata' do
+      source = MiniExiftool.new(media.input)
+      target = MiniExiftool.new(media.convert(scale: '1920:1080', copy_metadata: true))
+      expect(source.create_date).to eq(target.create_date)
+    end
+  end
+
+  describe 'cut' do
+    it 'cut the video' do
+      media.cut(starts_at: '00:00', time: '0.5')
+      expect(File.exist?(File.join(File.dirname(__FILE__), '../fixtures/example_00:00.mp4'))).to eq(true)
+    end
+  end
+
+  describe 'extract_screenshots' do
+    it 'default file to _screenshot' do
+      expect(Dir.glob(File.join(File.dirname(__FILE__), '../fixtures/*_screenshot*.jpg')).count).to eq(0)
+      media.extract_screenshots(copy_metadata: false)
+      expect(Dir.glob(File.join(File.dirname(__FILE__), '../fixtures/*_screenshot*.jpg')).count).to eq(2)
+    end
+
+    it 'allow to save screenshots with a basename' do
+      expect(Dir.glob(File.join(File.dirname(__FILE__), '../fixtures/out*.jpg')).count).to eq(0)
+      media.extract_screenshots(basename: 'out', copy_metadata: false)
+      expect(Dir.glob(File.join(File.dirname(__FILE__), '../fixtures/out*.jpg')).count).to eq(2)
+    end
+
+    it 'extract screenshots based on fps' do
+      media.extract_screenshots(fps: 3, copy_metadata: false)
+      files = Dir.glob(File.join(File.dirname(__FILE__), '../fixtures/*_screenshot*.jpg'))
+      expect(files.count).to eq(4)
+    end
+
+    it 'copy_metadata' do
+      media.extract_screenshots(copy_metadata: true)
+      files = Dir.glob(File.join(File.dirname(__FILE__), '../fixtures/*_screenshot*.jpg'))
+      files.each do |file|
+        expect(MiniExiftool.new(file).create_date).to be >= media.original_date_time
+      end
+    end
+  end
+end

data/spec/cutcut/timelapse_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe CutCut::Timelapse do
+  let(:timelapse) do
+    CutCut::Timelapse.new(
+      input: File.join(File.dirname(__FILE__), '../fixtures/timelapse/'),
+      output: File.join(File.dirname(__FILE__), '../fixtures/timelapse.mp4')
+    )
+  end
+
+  it 'has input and output' do
+    expect(timelapse.input).to_not eq(nil)
+    expect(timelapse.output).to_not eq(nil)
+  end
+
+  it 'return list of files' do
+    expect(timelapse.files.count).to eq(2)
+    timelapse.start_number
+  end
+
+  it 'return list of file basenames' do
+    expect(timelapse.basenames.count).to eq(2)
+    expect(timelapse.basenames.first).to eq('G0023026')
+  end
+
+  it 'return start_number based on first file name' do
+    expect(timelapse.start_number).to eq('6')
+  end
+
+  it 'return input_basename based on common string and start_number' do
+    expect(timelapse.input_basename).to eq('G002302%1d.JPG')
+  end
+
+  it 'should convert and create timelapse' do
+    expect(File.exist?(timelapse.output)).to eq false
+    expect(File.exist?(timelapse.convert(fps: '1'))).to eq true
+    expect(MiniExiftool.new(timelapse.output).duration).to eq('1.03 s')
+  end
+
+  it 'has original_date_time and copy from first file' do
+    expect(timelapse.original_date_time).to eq(MiniExiftool.new(timelapse.output).date_time_original)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'rubygems'
+require 'bundler/setup'
+
+require 'cutcut'
+
+RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
+
+  config.before(:all) do
+    system("rm -rf #{File.join(File.dirname(__FILE__), '/fixtures/*.MP4')}")
+    system("rm -rf #{File.join(File.dirname(__FILE__), '/fixtures/*.mp4')}")
+    system("cp #{File.join(File.dirname(__FILE__), '/fixtures/example')} #{File.join(File.dirname(__FILE__), '/fixtures/example.MP4')}")
+  end
+
+  config.before(:each) do
+    %w(jpg JPG png PNG).each do |extension|
+      system("rm -rf #{File.join(File.dirname(__FILE__), '/fixtures/*.' + extension)}")
+    end
+  end
+
+  config.after(:all) do
+    %w(jpg JPG png PNG mp4 MP4).each do |extension|
+      system("rm -rf #{File.join(File.dirname(__FILE__), '/fixtures/*.' + extension)}")
+    end
+  end
+end

metadata

@@ -0,0 +1,173 @@
+--- !ruby/object:Gem::Specification
+name: cutcut
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Jhimy Fernandes Villar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: mini_exiftool
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.5'
+- !ruby/object:Gem::Dependency
+  name: ruby-progressbar
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.13'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.6'
+- !ruby/object:Gem::Dependency
+  name: guard-rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+description: CLI for working with videos
+email:
+- stjhimy@gmail.com
+executables:
+- cutcut
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- CHANGELOG.md
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- bin/cutcut
+- cutcut.gemspec
+- lib/cutcut.rb
+- lib/cutcut/base.rb
+- lib/cutcut/helpers.rb
+- lib/cutcut/media.rb
+- lib/cutcut/timelapse.rb
+- spec/cutcut/base_spec.rb
+- spec/cutcut/helpers_spec.rb
+- spec/cutcut/media_spec.rb
+- spec/cutcut/timelapse_spec.rb
+- spec/fixtures/example
+- spec/fixtures/timelapse/G0023026.JPG
+- spec/fixtures/timelapse/G0023027.JPG
+- spec/spec_helper.rb
+homepage: http://github.com/stjhimy/cutcut
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: Trim/Cut/Screenshot videos
+test_files:
+- spec/cutcut/base_spec.rb
+- spec/cutcut/helpers_spec.rb
+- spec/cutcut/media_spec.rb
+- spec/cutcut/timelapse_spec.rb
+- spec/fixtures/example
+- spec/fixtures/timelapse/G0023026.JPG
+- spec/fixtures/timelapse/G0023027.JPG
+- spec/spec_helper.rb