lolcommits 0.13.1 → 0.14.0

data/lib/lolcommits/capturer/capture_linux_video.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Lolcommits
+  class CaptureLinuxVideo < Capturer
+    def capture
+      system_call "ffmpeg -nostats -v quiet -y -f video4linux2 -video_size 640x480 -i #{capture_device_string} -t #{capture_duration} \"#{capture_path}\" > /dev/null"
+    end
+
+    private
+
+    def capture_device_string
+      capture_device || Dir.glob('/dev/video*').first
+    end
+  end
+end

data/lib/lolcommits/capturer/capture_mac.rb

@@ -2,19 +2,14 @@
 
 module Lolcommits
   class CaptureMac < Capturer
-    def capture_device_string
-      @capture_device.nil? ? nil : "-d \"#{@capture_device}\""
+    def capture
+      system_call "#{executable_path} -q \"#{capture_path}\" -w #{capture_delay} #{capture_device_string}"
     end
 
-    def capture
-      # TODO: check we have a webcam we can capture from first. See issue #219
-      # operating laptop in clamshell (lid closed) from 2nd desktop screen,
-      # needs to better handle  the capturer (imagesnap, videosnap
-      # CommandCam, mplayer) return code or check with an option before
-      # attempting capture. Alt solution is puttin in prompt mode option :(
-      call_str = "#{executable_path} -q \"#{snapshot_location}\" -w #{capture_delay} #{capture_device_string}"
-      debug "Capturer: making system call for #{call_str}"
-      system(call_str)
+    private
+
+    def capture_device_string
+      capture_device.nil? ? '' : "-d \"#{capture_device}\""
     end
 
     def executable_path

data/lib/lolcommits/capturer/capture_mac_video.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Lolcommits
+  class CaptureMacVideo < Capturer
+    def capture
+      system_call "#{executable_path} -p 640x480 #{capture_device_string}#{capture_delay_string}-t #{capture_duration} --no-audio \"#{capture_path}\" > /dev/null"
+    end
+
+    private
+
+    def capture_device_string
+      "-d \"#{capture_device}\" " if capture_device
+    end
+
+    def capture_delay_string
+      "-w \"#{capture_delay}\" " if capture_delay.positive?
+    end
+
+    def executable_path
+      File.join(Configuration::LOLCOMMITS_ROOT, 'vendor', 'ext', 'videosnap', 'videosnap')
+    end
+  end
+end

data/lib/lolcommits/capturer/capture_windows.rb

@@ -3,19 +3,24 @@
 module Lolcommits
   class CaptureWindows < Capturer
     def capture
-      # DirectShow takes a while to show... at least for me anyway
-      delaycmd = ' /delay 3000'
-      if capture_delay > 0
-        # CommandCam delay is in milliseconds
-        delaycmd = " /delay #{capture_delay * 1000}"
-      end
-
-      _stdin, stdout, _stderr = Open3.popen3("#{executable_path} /filename #{snapshot_location}#{delaycmd}")
+      _stdin, stdout, _stderr = Open3.popen3("#{executable_path} /filename #{capture_path}#{delay_arg}")
 
-      # looks like we still need to read the output for something to happen
+      # need to read the output for something to happen
       stdout.read
     end
 
+    private
+
+    def delay_arg
+      # CommandCam delay is in milliseconds
+      if capture_delay.positive?
+        " /delay #{capture_delay * 1000}"
+      else
+        # DirectShow takes a while to show, default to 3 sec delay
+        ' /delay 3000'
+      end
+    end
+
     def executable_path
       File.join(Configuration::LOLCOMMITS_ROOT, 'vendor', 'ext', 'CommandCam', 'CommandCam.exe')
     end

data/lib/lolcommits/capturer/capture_windows_video.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Lolcommits
+  class CaptureWindowsVideo < Capturer
+    def capture
+      return unless capture_device_string
+
+      system_call "ffmpeg -v quiet -y -f dshow -i video=\"#{capture_device_string}\" -video_size 640x480 -t #{capture_duration} \"#{capture_path}\" > NUL"
+    end
+
+    private
+
+    def capture_device_string
+      capture_device || device_names.first
+    end
+
+    def ffpmeg_list_devices_cmd
+      'ffmpeg -list_devices true -f dshow -i dummy 2>&1'
+    end
+
+    # inspired by this code from @rdp http://tinyurl.com/y7t276bh
+    def device_names
+      @device_names ||= begin
+        names      = []
+        cmd_output = ''
+        count      = 0
+        while cmd_output.empty? || !cmd_output.split('DirectShow')[2]
+          cmd_output = system_call(ffpmeg_list_devices_cmd, true)
+          count += 1
+          raise 'failed to find a video capture device with ffmpeg -list_devices' if count == 5
+
+          sleep 0.1
+        end
+        cmd_output.gsub!("\r\n", "\n")
+        video = cmd_output.split('DirectShow')[1]
+
+        video.lines.map do |line|
+          names << Regexp.last_match(1) if line =~ /"(.+)"\n/
+        end
+
+        debug "found #{names.length} video devices: #{names.join(', ')}"
+        names
+      end
+    end
+  end
+end

data/lib/lolcommits/cli/fatals.rb

@@ -59,7 +59,7 @@ module Lolcommits
       # If we are not in a git repo, we can't do git related things!
       # Die with an informative error message in that case.
       def self.die_if_not_vcs_repo!
-        debug 'Checking for valid vcs repo'
+        debug 'Checking for valid VCS repo'
         current = File.expand_path('.')
         parent = File.dirname(current)
         while current != parent

data/lib/lolcommits/cli/launcher.rb

@@ -10,7 +10,7 @@ module Lolcommits
     # Right now this is mostly just a wrapper for Launchy, in case we want
     # to factor out it's dependency later or swap it out.
     class Launcher
-      def self.open_image(path)
+      def self.open_file(path)
         open_with_launchy(path)
       end
 

data/lib/lolcommits/cli/timelapse_gif.rb

@@ -7,9 +7,9 @@ module Lolcommits
   module CLI
     # Creates an animated timeline GIF of lolcommits history.
     class TimelapseGif
-      # param config [Lolcommits::Configuration]
-      def initialize(config)
-        @configuration = config
+      # param loldir [String] path to loldir
+      def initialize(loldir)
+        self.loldir = loldir
       end
 
       # Runs the history timeline animator task thingy
@@ -17,11 +17,11 @@ module Lolcommits
       def run(args = nil)
         case args
         when 'today'
-          lolimages = @configuration.jpg_images_today
-          filename  = "#{Date.today}.gif"
+          lolimages = jpg_images_today
+          filename  = Date.today.to_s
         else
-          lolimages = @configuration.jpg_images
-          filename  = 'archive.gif'
+          lolimages = jpg_images
+          filename  = "all-until-#{Time.now.strftime('%d-%b-%Y--%Hh%Mm%Ss')}"
         end
 
         if lolimages.empty?
@@ -29,14 +29,30 @@ module Lolcommits
           exit 1
         end
 
-        puts '*** Generating animated gif.'
+        puts '*** Generating animated timelapse gif.'
 
-        gif = MiniMagick::Image.new File.join @configuration.archivedir, filename
+        gif = MiniMagick::Image.new(File.join(timelapses_dir_path, "#{filename}.gif"))
+        gif.run_command('convert', *['-delay', '50', '-loop', '0', lolimages, gif.path].flatten)
 
-        # This is for ruby 1.8.7, *lolimages just doesn't work with ruby 187
-        gif.run_command('convert', *['-delay', '50', '-loop', '0', lolimages, gif.path.to_s].flatten)
+        puts "*** Done, generated at #{gif.path}"
+      end
+
+      private
+
+      attr_accessor :loldir
+
+      def jpg_images
+        Dir.glob(File.join(loldir, '*.jpg')).sort_by { |f| File.mtime(f) }
+      end
+
+      def jpg_images_today
+        jpg_images.select { |f| Date.parse(File.mtime(f).to_s) == Date.today }
+      end
 
-        puts "*** #{gif.path} generated."
+      def timelapses_dir_path
+        dir = File.join(loldir, 'timelapses')
+        FileUtils.mkdir_p(dir)
+        dir
       end
     end
   end

data/lib/lolcommits/configuration.rb

@@ -38,34 +38,12 @@ module Lolcommits
       @loldir = Configuration.loldir_for(basename)
     end
 
-    def archivedir
-      dir = File.join(loldir, 'archive')
-      FileUtils.mkdir_p dir unless File.directory? dir
-      dir
+    def sha_path(sha, ext)
+      File.join loldir, "#{sha}.#{ext}"
     end
 
-    def jpg_images
-      Dir.glob(File.join(loldir, '*.jpg')).sort_by { |f| File.mtime(f) }
-    end
-
-    def jpg_images_today
-      jpg_images.select { |f| Date.parse(File.mtime(f).to_s) == Date.today }
-    end
-
-    def raw_image(image_file_type = 'jpg')
-      File.join loldir, "tmp_snapshot.#{image_file_type}"
-    end
-
-    def main_image(commit_sha, image_file_type = 'jpg')
-      File.join loldir, "#{commit_sha}.#{image_file_type}"
-    end
-
-    def video_loc
-      File.join(loldir, 'tmp_video.mov')
-    end
-
-    def frames_loc
-      File.join(loldir, 'tmp_frames')
+    def capture_path(ext = 'jpg')
+      File.join loldir, "raw_capture.#{ext}"
     end
 
     def list_plugins

data/lib/lolcommits/platform.rb

@@ -11,11 +11,11 @@ module Lolcommits
       if ENV['LOLCOMMITS_CAPTURER']
         const_get(ENV['LOLCOMMITS_CAPTURER'])
       elsif platform_mac?
-        animate ? CaptureMacAnimated : CaptureMac
+        animate ? CaptureMacVideo : CaptureMac
       elsif platform_linux?
-        animate ? CaptureLinuxAnimated : CaptureLinux
+        animate ? CaptureLinuxVideo : CaptureLinux
       elsif platform_windows?
-        animate ? CaptureWindowsAnimated : CaptureWindows
+        animate ? CaptureWindowsVideo : CaptureWindows
       elsif platform_cygwin?
         CaptureCygwin
       else
@@ -123,7 +123,7 @@ module Lolcommits
       # TODO: handle other platforms here (linux/windows) e.g with ffmpeg -list_devices
       return unless Platform.platform_mac?
 
-      capturer = Lolcommits::CaptureMacAnimated.new
+      capturer = Lolcommits::CaptureMacVideo.new
       `#{capturer.executable_path} -l`
     end
   end

data/lib/lolcommits/plugin/base.rb

@@ -76,13 +76,13 @@ module Lolcommits
       # uniform puts and print for plugins
       # dont puts or print if the runner wants to be silent (stealth mode)
       def puts(*args)
-        return if runner && runner.capture_stealth
+        return if runner&.capture_stealth
 
         super(*args)
       end
 
       def print(*args)
-        return if runner && runner.capture_stealth
+        return if runner&.capture_stealth
 
         super(*args)
       end

data/lib/lolcommits/plugin/configuration_helper.rb

@@ -31,7 +31,7 @@ module Lolcommits
       # value is returned.
       def prompt_autocomplete_hash(prompt, items, name: 'name', value: 'value', suggest_words: 5)
         words = items.map { |item| item[name] }.sort
-        puts "e.g. #{words.take(suggest_words).join(', ')}" if suggest_words > 0
+        puts "e.g. #{words.take(suggest_words).join(', ')}" if suggest_words.positive?
         completed_input = gets_autocomplete(prompt, words)
         items.find { |item| item[name] == completed_input }[value]
       end

data/lib/lolcommits/runner.rb

@@ -1,126 +1,195 @@
 # frozen_string_literal: true
 
 require 'lolcommits/platform'
+require 'lolcommits/animated_gif'
 
 module Lolcommits
   class Runner
-    attr_accessor :capture_delay, :capture_stealth, :capture_device, :message,
-                  :sha, :snapshot_loc, :main_image, :config, :vcs_info,
-                  :capture_animate
+    attr_accessor :capture_delay, :capture_stealth, :capture_device,
+                  :capture_duration, :capture_path, :capture_video,
+                  :capture_gif, :sha, :message, :config, :vcs_info,
+                  :lolcommit_path, :lolcommit_gif_path
 
     def initialize(attributes = {})
       attributes.each do |attr, val|
         send("#{attr}=", val)
       end
 
-      return unless sha.nil? || message.nil?
-
       if GitInfo.repo_root?
         self.vcs_info = GitInfo.new
       elsif MercurialInfo.repo_root?
         self.vcs_info = MercurialInfo.new
-      else
-        raise('Unknown VCS')
       end
 
-      self.sha     = vcs_info.sha if sha.nil?
-      self.message = vcs_info.message if message.nil?
-    end
+      self.sha = sha || vcs_info.sha
+      self.message = message || vcs_info.message
 
-    def execute_plugins_for(hook)
-      debug "#{self.class}: running all enabled plugin hooks for #{hook}"
-      enabled_plugins.each do |plugin|
-        if plugin.valid_configuration?
-          plugin.send("run_#{hook}")
-        else
-          puts "Warning: skipping plugin #{plugin.name} (invalid configuration, fix with: lolcommits --config -p #{plugin.name})"
-        end
-      end
+      self.capture_path       = config.capture_path(lolcommit_ext)
+      self.lolcommit_path     = config.sha_path(sha, lolcommit_ext)
+      self.lolcommit_gif_path = config.sha_path(sha, 'gif') if capture_gif
     end
 
-    # wrap run to handle things that should happen before and after
-    # this used to be handled with ActiveSupport::Callbacks, but
-    # now we're just using a simple procedural list
     def run
-      # do plugins that need to happen before capture
       execute_plugins_for(:pre_capture)
 
-      # do main capture to snapshot_loc
+      # main capture
       run_capture
 
-      # check capture succeded, file must exist
-      if File.exist?(snapshot_loc)
-        ## resize snapshot first
-        resize_snapshot!
+      # capture must exist to run post capture methods
+      unless File.exist?(capture_path)
+        raise 'failed to capture any image or video!'
+      end
+
+      run_post_capture
+      run_capture_ready
+    rescue StandardError => e
+      debug("#{e.class}: #{e.message}")
+      exit 1
+    ensure
+      debug 'running cleanup'
+      FileUtils.rm_f(capture_path)
+    end
 
-        # execute post_capture plugins, use to alter the capture
-        execute_plugins_for(:post_capture)
+    # return MiniMagick overlay png for manipulation (or create one)
+    def overlay
+      @overlay ||= begin
+        source_path = capture_image? ? lolcommit_path : capture_path
+        unless File.exist?(source_path)
+          raise "too early to overlay, capture doesn't exist yet"
+        end
 
-        # execute capture_ready plugins, capture is ready for export/sharing
-        execute_plugins_for(:capture_ready)
+        base = MiniMagick::Image.open(source_path)
+        png_tempfile = MiniMagick::Utilities.tempfile('.png')
+        debug("creating a new empty overlay png for lolcommit (#{base.dimensions.join('x')})")
 
-        # clean away any tmp files
-        cleanup!
-      else
-        debug 'Runner: failed to capture a snapshot'
-        exit 1
+        MiniMagick::Tool::Convert.new do |i|
+          i.size "#{base.width}x#{base.height}"
+          i.xc 'transparent'
+          i << png_tempfile.path
+        end
+
+        MiniMagick::Image.open(png_tempfile.path)
+      end
+    end
+
+    # backward compatibility with earlier plugin releases
+    # remove this when all plugins target 0.14+
+    def main_image
+      capture_gif ? lolcommit_gif_path : lolcommit_path
+    end
+
+    private
+
+    def execute_plugins_for(hook)
+      debug "running all enabled #{hook} plugin hooks"
+      enabled_plugins.each do |plugin|
+        if plugin.valid_configuration?
+          plugin.send("run_#{hook}")
+        else
+          puts "Warning: skipping plugin #{plugin.name} (invalid configuration, fix with: lolcommits --config -p #{plugin.name})"
+        end
       end
     end
 
-    # the main capture
+    def capture_image?
+      capture_duration.zero?
+    end
+
     def run_capture
       puts '*** Preserving this moment in history.' unless capture_stealth
-      self.snapshot_loc = config.raw_image(image_file_type)
-      self.main_image   = config.main_image(sha, image_file_type)
-
-      capturer = Platform.capturer_class(capture_animated?).new(
+      capturer = Platform.capturer_class(!capture_image?).new(
+        capture_path: capture_path,
         capture_device: capture_device,
         capture_delay: capture_delay,
-        snapshot_location: snapshot_loc,
-        video_location: config.video_loc,
-        frames_location: config.frames_loc,
-        animated_duration: capture_animate
+        capture_duration: capture_duration
       )
       capturer.capture
     end
 
-    def capture_animated?
-      capture_animate > 0
-    end
+    def run_post_capture
+      resize_captured_image if capture_image?
 
-    private
+      execute_plugins_for(:post_capture)
 
-    def enabled_plugins
-      @enabled_plugins ||= config.plugin_manager.enabled_plugins_for(self)
+      # apply overlay if present, or cp video to lolcommit_path
+      if @overlay
+        apply_overlay
+      elsif !capture_image?
+        FileUtils.cp(capture_path, lolcommit_path)
+      end
+
+      # optionally create animated gif
+      return unless capture_gif
+
+      AnimatedGif.new.create(
+        video_path: lolcommit_path,
+        output_path: lolcommit_gif_path
+      )
+
+      # done if we are capturing both video and gif
+      return if capture_video
+
+      # remove video and assign var (if only capturing gif)
+      FileUtils.rm_f(lolcommit_path)
+      self.lolcommit_path = lolcommit_gif_path
     end
 
-    def image_file_type
-      capture_animated? ? 'gif' : 'jpg'
+    def run_capture_ready
+      debug "lolcommit_path: #{lolcommit_path}"
+      debug "lolcommit_gif_path: #{lolcommit_gif_path}"
+      execute_plugins_for(:capture_ready)
     end
 
-    def resize_snapshot!
-      debug 'Runner: resizing snapshot'
-      image = MiniMagick::Image.open(snapshot_loc)
-      if image[:width] > 640 || image[:height] > 480
-        # this is hacky resize-to-fill
+    def resize_captured_image
+      image = MiniMagick::Image.open(capture_path)
+
+      if image.width > 640 || image.height > 480
+        debug "resizing raw image (#{image.dimensions.join('x')}) to #{lolcommit_path} (640x480)"
+        # hacky resize to fill bounds
         image.combine_options do |c|
           c.resize '640x480^'
           c.gravity 'center'
           c.extent '640x480'
         end
-        debug "Runner: writing resized image to #{snapshot_loc}"
-        image.write snapshot_loc
+        image.write(lolcommit_path)
+      else
+        debug "no resize needed, copying raw image to #{lolcommit_path} (640x480)"
+        FileUtils.cp(capture_path, lolcommit_path)
       end
-      debug "Runner: copying resized image to #{main_image}"
-      FileUtils.cp(snapshot_loc, main_image)
     end
 
-    def cleanup!
-      debug 'Runner: running cleanup'
-      # clean up the captured image and any other raw assets
-      FileUtils.rm(snapshot_loc)
-      FileUtils.rm_f(config.video_loc)
-      FileUtils.rm_rf(config.frames_loc)
+    def apply_overlay
+      debug 'applying overlay to lolcommit'
+      if capture_image?
+        MiniMagick::Image.open(lolcommit_path).composite(overlay) do |c|
+          c.gravity 'center'
+        end.write(lolcommit_path)
+      else
+        system_call "ffmpeg -v quiet -nostats -i #{capture_path} -i #{overlay.path} \
+          -filter_complex overlay=0:0 \
+          -y #{lolcommit_path}"
+      end
+    end
+
+    def lolcommit_ext
+      if capture_image?
+        'jpg'
+      else
+        'mp4'
+      end
+    end
+
+    def enabled_plugins
+      @enabled_plugins ||= config.plugin_manager.enabled_plugins_for(self)
+    end
+
+    def system_call(call_str, capture_output = false)
+      debug "making system call for \n #{call_str}"
+      capture_output ? `#{call_str}` : system(call_str)
+    end
+
+    def debug(message)
+      super("#{self.class}: #{message}")
     end
   end
 end