cli_chef 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 416dd42c45a904147359ae950761aa5bdfbcdab7bcff5d175ea191f98fe172b2
+  data.tar.gz: 0ea2d4a6b54f39b8861a20028391ebad0b63e8867b8eafddb7131b2b26bbc1c4
+SHA512:
+  metadata.gz: c062117a34fadd35f7cf88d1c0b1e6d3cdc27a871eff561b02a22727e6cae6b3530e9ba50344828fe17b6e7c70c43f697e5c458bd3c52bcf6e73b69ecbc4c548
+  data.tar.gz: 97fb7864b53d18eb8bd7718de21e5a38446c8df2ed5c0b9186f2c9e9981bd4ebf14815431abf63e98c8f0f4459d096b7471d8e1b13db0a5ec3dfe364f1865a2f

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.gem

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.6
+before_install: gem install bundler -v 1.10.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cli_chef.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Brandon
+
+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,77 @@
+# CLIChef
+
+CLI Chef is a simple command line interface wrapper for Ruby. It is made to make writing wrappers an easy and flexible process.
+Basic examples of how to use CLIChef are included in the wrappers directory.
+These are also full functional CLI wrappers for the following apps:
+
+- 7Zip
+- MediaInfo
+- Handbrake
+
+## Installation
+
+
+__Note:__ Currently this gem is not available via RubyGems.
+Once it is the following is how to install it.
+For now, grab it from github.
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'cli_chef'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cli_chef
+
+## Usage
+
+CLI Chef is made up of the following components:
+
+- *Cookbook*: A cookbook is the base wrapper class of CLI Chef. The cookbook handles interaction with the CLI. It stores all possible ingredients. It also contains an exit code map, default application locations and the results of the previously run command.
+- *Ingredient*: An ingredient is essentially a CLI argument. It contains a name for the argument, its flag (if it has one) and its value (again, if it has one). There are many other properties in ingredients that control how it is constructed. For more detailed information, check out the source code or one of the sample wrappers.
+
+### Examples
+
+A few example wrappers comes with this gem. Check them out under the /lib/cli_chef/apps
+directory. They are complete and showcase how easy it is to setup a basic wrapper.
+
+## Pre-Built Wrappers
+
+CLI Chef ships with several pre-made wrappers for 7Zip, HandBrake and MediaInfo. Below is an example of how to include these in your projects.
+
+```ruby
+# NOTE: You do not have to require cli_chef separately as the wrappers will if it is not already loaded.
+require 'cli_chef'
+
+# Load 7Zip
+require 'cli_chef/apps/sevenzip'
+
+# Load HandBrake
+require 'cli_chef/apps/hand_brake'
+
+# Load MediaInfo
+require 'cli_chef/apps/media_info'
+```
+
+_NOTE: For the wrappers to work you must have the CLI executables for each of the above applications installed._
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/cli_chef. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "cli_chef"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/cli_chef.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cli_chef/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cli_chef"
+  spec.version       = CLIChef::VERSION
+  spec.authors       = ["Brandon Black"]
+  spec.email         = ["d2sm10@hotmail.com"]
+
+  spec.summary       = %q{CLI Chef is a simple and quick CLI wrapper framework for Ruby.}
+  spec.description   = %q{CLI Chef makes building command line wrappers easy and simple to incorporate with your Ruby projects.}
+  spec.homepage      = "http://github.com/bblack16/cli-chef"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+
+  spec.add_runtime_dependency 'bblib', '~> 1.0'
+end

data/lib/bblib/bbfiles.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module BBLib
+  def self.scan_files_and_archives(*args)
+    sz = SevenZip.new
+    BBLib.scan_files(*args).flat_map do |file|
+      if archive?(file)
+        sz.list(file).flat_map { |afile, _data| "#{file}//#{afile}" }
+      else
+        file
+      end
+    end
+  end
+
+  ARCHIVE_EXTENSIONS = %w[bz2 bzip2 tbz2 tbz gz gzip tgz tar wim swm xz txz zip zipx jar xpi odt ods
+                          docx xlsx epub apm ar a deb lib arj cab chm chw chi chq msi msp doc xls ppt cpio
+                          cramfs dmg ext ext2 ext3 ext4 img fat img hfs hfsx hxs hxi hxr hxq hxw lit ihex
+                          iso img lzh lha lzma mbr mslz mub nsis ntfs img mbr rar r00 rpm ppmd qcow qcow2
+                          qcow2c 001 squashfs udf iso img scap uefif vdi vhd vmdk wim esd xar pkg z taz ].freeze
+
+  def self.archive?(file)
+    ARCHIVE_EXTENSIONS.any? { |ext| file.to_s.end_with?(".#{ext}") }
+  end
+end

data/lib/cli_chef.rb

@@ -0,0 +1,4 @@
+require 'bblib' unless defined?(BBLib)
+require 'open3'
+
+require_relative 'cli_chef/cli_chef'

data/lib/cli_chef/apps/hand_brake.rb

@@ -0,0 +1,149 @@
+require 'cli_chef' unless defined?(CLIChef::VERSION)
+require_relative 'hand_brake/hand_brake_job'
+
+class HandBrake < CLIChef::Cookbook
+
+  self.description = 'HandBrake is a tool for converting video from nearly any format to a selection of modern, widely supported codecs.'
+  self.default_job_class = HandBrakeJob
+
+  def help
+    run!(help: nil).body
+  end
+
+  def version
+    run!(version: nil).body.scan(/(?<=HandBrake\s)\d+\.\d+\.\d+/i).first
+  end
+
+  def encode(input, output, opts = {})
+    run(opts.merge(input: input, output: output)) do |line, stream, job|
+      job.task_count  = line.scan(/(?<=of )\d+/).first.to_i
+      job.task        = line.scan(/\d+(?= of)/).first.to_i
+      job.fps         = line.scan(/\d+\.\d+(?= fps)/).first.to_f
+      job.average_fps = line.scan(/(?<=avg )\d+\.\d+(?= fps)/).first.to_f
+      job.eta         = line.scan(/(?<=ETA ).*?(?=\))/).first.parse_duration rescue nil
+      percent         = line.scan(/\d+\.\d+(?= %)/).first.to_f
+      if line.include?('Encode done!')
+        percent = 100.0
+      elsif job.task_count > 2 && percent > 0
+        percent /= job.task_count
+        percent += 50 * job.task
+      end
+      job.percent = percent unless percent < job.percent.to_i
+    end
+  end
+
+  add_exit_codes(
+    { code: 0, description: 'Clean exit' },
+    { code: 1, description: 'Cancelled', error: true },
+    { code: 2, description: 'Invalid Input', error: true },
+    { code: 3, description: 'Initialization Error', error: true },
+    { code: 4, description: 'Unknown Error', error: true }
+  )
+
+  add_default_locations(
+    'handbrakecli.exe',
+    'hanbrakecli',
+    'C:/Program Files/Handbrake/HandBrakeCLI.exe',
+    'C:/Program Files(x86)/Handbrake/HandBrakeCLI.exe',
+    'C:/Handbrake/HandBrakeCLI.exe'
+  )
+
+  add_ingredients(
+    { name: :help, description: 'Print help', flag: '--help', allowed_values: [nil], aliases: [:h] },
+    { name: :update, description: 'Check for updates and exit', flag: '--update', allowed_values: [nil], aliases: [] },
+    { name: :verbose, description: 'Be verbose (optional argument: logging level)', flag: '--verbose', allowed_values: [1, 2, 3], aliases: [] },
+    { name: :preset, description: 'Use a built-in preset. Capitalization matters, and if the preset name has spaces, surround it with double quotation marks', flag: '--preset', allowed_values: [String], aliases: [] },
+    { name: :preset_list, description: 'See a list of available built-in presets', flag: '--preset-list', allowed_values: [nil], aliases: [] },
+    { name: :no_dvd_nav, description: 'Do not use dvdnav for reading DVDs', flag: '--no-dvdnav', allowed_values: [nil], aliases: [] },
+    { name: :no_open_cl, description: 'Disable use of OpenCL', flag: '--no-opencl', allowed_values: [nil], aliases: [] },
+    { name: :input, description: 'Set input device', flag: '--input', allowed_values: [String], aliases: [] },
+    { name: :title, description: 'Select a title to encode (0 to scan all titles only', flag: '--title', allowed_values: [Integer, String], aliases: [] },
+    { name: :min_duration, description: 'Set the minimum title duration (in seconds). Shorter  titles will not be scanned.', flag: '--min-duration', allowed_values: [Integer], aliases: [] },
+    { name: :scan, description: 'Scan selected title only.', flag: '--scan', allowed_values: [nil], aliases: [] },
+    { name: :main_feature, description: 'Detect and select the main feature title.', flag: '--main-feature', allowed_values: [nil], aliases: [] },
+    { name: :chapters, description: 'Select chapters (e.g. \'1-3\' for chapters 1 to 3, or \'3\' for chapter 3 only', flag: '--chapters', allowed_values: [], aliases: [] },
+    { name: :angle, description: 'Select the video angle (DVD or Blu-ray only)', flag: '--angle', allowed_values: [Integer], aliases: [] },
+    { name: :previews, description: 'Select how many preview images are generated, and whether or not they\'re stored to disk (0 or 1).', flag: '--previews', allowed_values: [String], aliases: [] },
+    { name: :start_at_preview, description: 'Start encoding at a given preview.', flag: '--start-at-preview', allowed_values: [(1..30)], aliases: [] },
+    { name: :start_at, description: 'Start encoding at a given frame, duration (in seconds), or pts (on a 90kHz clock)', flag: '--start-at', allowed_values: [Object], aliases: [] },
+    { name: :stop_at, description: 'Stop encoding at a given frame, duration (in seconds), or pts (on a 90kHz clock)', flag: '--stop-at', allowed_values: [Object], aliases: [] },
+    { name: :output, description: 'Set output file name', flag: '--output', allowed_values: [String], aliases: [:out] },
+    { name: :format, description: 'Set output container format (av_mp4/av_mkv)', flag: '--format', allowed_values: ['mp4', 'mkv', :mp4, :mkv], aliases: [] },
+    { name: :markers, description: 'Add chapter markers', flag: '--markers', allowed_values: [String], aliases: [] },
+    { name: :large_file, description: 'Create 64-bit mp4 files that can hold more than 4 GB of data. Note: breaks pre-iOS iPod compatibility.', flag: '--large-file', allowed_values: [nil], aliases: [] },
+    { name: :optimize, description: 'Optimize mp4 files for HTTP streaming (\'fast start\')', flag: '--optimize', allowed_values: [nil], aliases: [] },
+    { name: :ipod_atom, description: 'Mark mp4 files so 5.5G iPods will accept them', flag: '--ipod-atom', allowed_values: [nil], aliases: [] },
+    { name: :use_open_cl, description: 'Use OpenCL where applicable', flag: '--use-opencl', allowed_values: [nil], aliases: [] },
+    { name: :use_hwd, description: 'Use DXVA2 hardware decoding', flag: '--use-hwd', allowed_values: [nil], aliases: [] },
+    { name: :encoder, description: 'Set video library encoder. Options: x264/x265/mpeg4/mpeg2/VP8/theora', flag: '--encoder', allowed_values: ['x264', 'x265', 'mpeg4', 'mpeg2', 'VP8', 'theora', :x264, :x265, :mpeg4, :mpeg2, :VP8, :vp8, :theora], aliases: [] },
+    { name: :encoder_preset, description: 'Adjust video encoding settings for a particular speed/efficiency tradeoff (encoder-specific)', flag: '--encoder-preset', allowed_values: [Object], aliases: [] },
+    { name: :encoder_preset_list, description: 'List supported --encoder-preset values for the specified video encoder', flag: '--encoder-preset-list', allowed_values: [nil], aliases: [] },
+    { name: :encoder_tune, description: 'Adjust video encoding settings for a particular  type of souce or situation (encoder-specific)', flag: '--encoder-tune', allowed_values: [Object], aliases: [] },
+    { name: :encoder_tune_list, description: 'List supported --encoder-tune values for the  specified video encoder', flag: '--encoder-tune-list', allowed_values: [nil], aliases: [] },
+    { name: :encopts, description: 'Specify advanced encoding options in the same  style as mencoder (all encoders except theora):  option1=value1:option2=value2', flag: '--encopts', allowed_values: [Object], aliases: [] },
+    { name: :encoder_profile, description: 'Ensures compliance with the requested codec   profile (encoder-specific)', flag: '--encoder-profile', allowed_values: [Object], aliases: [] },
+    { name: :encoder_profile_list, description: 'List supported --encoder-profile values for the   specified video encoder', flag: '--encoder-profile-list', allowed_values: [nil], aliases: [] },
+    { name: :encoder_level, description: 'Ensures compliance with the requested codec  level (encoder-specific)', flag: '--encoder-level', allowed_values: [Object], aliases: [] },
+    { name: :encoder_level_list, description: 'List supported --encoder-level values for the  specified video encoder', flag: '--encoder-level-list', allowed_values: [nil], aliases: [] },
+    { name: :quality, description: 'Set video quality', flag: '--quality', allowed_values: [Integer], aliases: [] },
+    { name: :video_bitrate, description: 'Set video bitrate', flag: '--vb', allowed_values: [Integer], aliases: [:vb, :bitrate] },
+    { name: :two_pass, description: 'Use two-pass mode', flag: '--two-pass', allowed_values: [nil], aliases: [] },
+    { name: :turbo, description: 'When using 2-pass use \'turbo\' options on the  1st pass to improve speed (only works with x264)', flag: '--turbo', allowed_values: [nil], aliases: [] },
+    { name: :video_framerate, description: 'Set video framerate (5/10/12/15/23.976/24/25/29.97/30/50/59.94/60).  Be aware that not specifying a framerate lets  HandBrake preserve a source\'s time stamps,  potentially creating variable framerate video', flag: '--rate', allowed_values: [Float, Integer], aliases: [:framerate] },
+    { name: :variable_framerate, description: 'VFR preserves the source timing.', flag: '--vfr', allowed_values: [nil], aliases: [] },
+    { name: :constant_framerate, description: 'CFR makes the output constant rate at the rate given by the -r flag (or the source\'s average rate if no -r is given)', flag: '--cfr', allowed_values: [nil], aliases: [] },
+    { name: :peak_limited_framerate, description: 'PFR doesn\'t allow the rate to go over the rate specified  with the -r flag but won\'t change the source  timing if it\'s below that rate.', flag: '--pfr', allowed_values: [nil], aliases: [] },
+    { name: :audio_tracks, description: 'Select audio track(s), separated by commas', flag: '--audio', allowed_values: [String], aliases: [] },
+    { name: :audio_encoder, description: 'Audio encoder(s): av_aac, fdk_aac, fdk_haac, copy:aac, ac3, copy:ac3, copy:dts, copy:dtshd, mp3, copy:mp3, vorbis, flac16, flac24, copy. copy:* will passthrough the corresponding audio unmodified to the muxer if it is a supported passthrough audio type. Separated by commas for more than one audio track.', flag: '--aencoder', allowed_values: ['av_aac', 'fdk_aac', 'fdk_haac', 'copy:aac', 'ac3', 'copy:ac3', 'copy:dts', 'copy:dtshd', 'mp3', 'copy:mp3', 'vorbis', 'flac16', 'flac24', 'copy', :av_aac, :fdk_aac, :fdk_haac, :attr_array_removeraac, :ac3, :copy_ac3, :copy_dts, :copy_dtshd, :mp3, :copy_mp3, :vorbis, :flac16, :flac24, :copy], aliases: [] },
+    { name: :audio_copy_mask, description: 'Set audio codecs that are permitted when the \'copy\' audio encoder option is specified (aac/ac3/dts/dtshd/mp3, default: all).', flag: '--audio-copy-mast', allowed_values: ['all', 'aac', 'ac3', 'dts', 'dtshd', 'mp3', :all, :aac, :ac3, :drs, :dtshd, :mp3], aliases: [] },
+    { name: :audio_fallback, description: 'Set audio codec to use when it is not possible to copy an audio track without re-encoding.', flag: '--audio-fallback', allowed_values: ['av_aac', 'fdk_aac', 'fdk_haac', 'copy:aac', 'ac3', 'copy:ac3', 'copy:dts', 'copy:dtshd', 'mp3', 'copy:mp3', 'vorbis', 'flac16', 'flac24', 'copy', :av_aac, :fdk_aac, :fdk_haac, :attr_array_removeraac, :ac3, :attr_array_removerac3, :attr_array_removerdts, :attr_array_removerdtshd, :mp3, :attr_array_removermp3, :vorbis, :flac16, :flac24, :copy], aliases: [] },
+    { name: :audio_bitrate, description: 'Set audio bitrate(s) (default: depends on the selected codec, mixdown and samplerate). Separated by commas for more than one audio track.', flag: '--ab', allowed_values: [String, Integer], aliases: [:ab] },
+    { name: :audio_quality, description: 'Set audio quality metric (default: depends on the selected codec). Separated by commas for more than one audio track.', flag: '--aq', allowed_values: [String, Integer], aliases: [] },
+    { name: :audio_compression, description: 'Set audio compression metric (default: depends on the selected codec). Separated by commas for more than one audio track.', flag: '--ac', allowed_values: [String, Integer], aliases: [] },
+    { name: :mixdown, description: 'Format(s) for audio downmixing/upmixing:, mono, left_only, right_only, stereo, dpl1, dpl2, 5point1, 6point1, 7point1, 5_2_lfe .Separated by commas for more than one audio track.', flag: '--mixdown', allowed_values: ['mono', 'left_only', 'right_only', 'stereo', 'dp11', 'dp12', '5point1', '6point1', '7point1', '5_2_lfe', String, Symbol], aliases: [] },
+    { name: :normalize_mix, description: 'Normalize audio mix levels to prevent clipping.  Separated by commas for more than one audio track.  0 = Disable Normalization (default)  1 = Enable Normalization', flag: '--normalize-mix', allowed_values: [0, 1], aliases: [] },
+    { name: :audio_samplerate, description: 'Set audio samplerate(s) (8/11.025/12/16/22.05/24/32/44.1/48 kHz). Separated by commas for more than one audio track.', flag: '--arate', allowed_values: [String, Float], aliases: [] },
+    { name: :dynamic_range_compression, description: 'Apply extra dynamic range compression to the audio, making soft sounds louder. Range is 1.0 to 4.0  (too loud), with 1.5 - 2.5 being a useful range. Separated by commas for more than one audio track.', flag: '--drc', allowed_values: [Float, Integer, String], aliases: [] },
+    { name: :gain, description: 'Amplify or attenuate audio before encoding.  Does  NOT work with audio passthru (copy). Values are in  dB.  Negative values attenuate, positive values  amplify. A 1 dB difference is barely audible.', flag: '--gain', allowed_values: [Float, Integer, String], aliases: [] },
+    { name: :audio_dither, description: 'Apply dithering to the audio before encoding. Separated by commas for more than one audio track.  Only supported by some encoders (fdk_aac/fdk_haac/flac16).  Options: auto (default),  none,  rectangular,   triangular,   triangular_hp,  triangular_ns', flag: '--adither', allowed_values: ['auto', 'none', 'rectangular', 'triangular', 'triangular_hp', 'triangular_ns', String, Symbol], aliases: [] },
+    { name: :audio_track_name, description: 'Audio track name(s).  Separated by commas for more than one audio track.', flag: '--aname', allowed_values: [String], aliases: [] },
+    { name: :width, description: 'Set picture width', flag: '--width', allowed_values: [Integer], aliases: [:w] },
+    { name: :height, description: 'Set picture height', flag: '--height', allowed_values: [Integer], aliases: [:h] },
+    { name: :crop, description: 'Set cropping values (default: autocrop)', flag: '--crop', allowed_values: [String, Symbol], aliases: [] },
+    { name: :loose_crop, description: 'Always crop to a multiple of the modulus. Specifies the maximum number of extra pixels which may be cropped (default: 15)', flag: '--loose-crop', allowed_values: [String], aliases: [] },
+    { name: :max_height, description: 'Set maximum height', flag: '--maxHeight', allowed_values: [Integer], aliases: [] },
+    { name: :max_width, description: 'Set maximum width', flag: '--maxWidth', allowed_values: [Integer], aliases: [] },
+    { name: :strict_anamorphic, description: 'Store pixel aspect ratio in video stream', flag: '--strict-anamorphic', allowed_values: [nil], aliases: [] },
+    { name: :loose_anamorphic, description: 'Store pixel aspect ratio with specified width', flag: '--loose-anamorphic', allowed_values: [nil], aliases: [] },
+    { name: :custom_anamorphic, description: 'Store pixel aspect ratio in video stream and directly control all parameters.', flag: '--custom-anamorphic', allowed_values: [nil], aliases: [] },
+    { name: :display_width, description: 'Set the width to scale the actual pixels to at playback, for custom anamorphic.', flag: '--display-width', allowed_values: [Integer], aliases: [] },
+    { name: :keep_display_aspect, description: 'Preserve the source\'s display aspect ratio when using custom anamorphic', flag: '--keep-display-aspect', allowed_values: [nil], aliases: [] },
+    { name: :pixel_aspect, description: 'Set a custom pixel aspect for custom anamorphic (--display-width and --pixel-aspect are mutually exclusive and the former will override the latter)', flag: '--pixel-aspect', allowed_values: [String], aliases: [] },
+    { name: :itu_par, description: 'Use wider, ITU pixel aspect values for loose and custom anamorphic, useful with underscanned sources', flag: '--itu-par', allowed_values: [nil], aliases: [] },
+    { name: :modulus, description: 'Set the number you want the scaled pixel dimensions to divide cleanly by. Does not affect strict anamorphic mode, which is always mod 2 (default: 16)', flag: '--modulus', allowed_values: [Integer], aliases: [] },
+    { name: :color_matrix, description: 'Set the color space signaled by the output. Values: 709, pal, ntsc, 601 (same as ntsc) (default: detected from source)', flag: '--color-matrix', allowed_values: [709, 'pal', 'ntsc', 601, :pal, :ntsc], aliases: [] },
+    { name: :deinterlace, description: 'Unconditionally deinterlaces all frames  <fast/slow/slower/bob> or omitted (default settings)  or  <YM:FD>  (default 0:-1)', flag: '--deinterlace', allowed_values: ['omitted', 'fast', 'slow', 'slower', 'bob', :omitted, :fast, :slow, :slower, :bob], aliases: [] },
+    { name: :decomb, description: 'Selectively deinterlaces when it detects combing <fast/bob> or omitted (default settings) or  <MO:ME:MT:ST:BT:BX:BY:MG:VA:LA:DI:ER:NO:MD:PP:FD>  (default: 7:2:6:9:80:16:16:10:20:20:4:2:50:24:1:-1)', flag: '--decomb', allowed_values: [String], aliases: [] },
+    { name: :detelecine, description: 'Detelecine (ivtc) video with pullup filter. Note: this filter drops duplicate frames to restore the pre-telecine framerate, unless you specify a constant framerate (--rate 29.97) <L:R:T:B:SB:MP:FD> (default 1:1:4:4:0:0:-1)', flag: '--detelecine', allowed_values: [String], aliases: [] },
+    { name: :denoise, description: 'Denoise video with hqdn3d filter <ultralight/light/medium/strong> or omitted (default settings) or <SL:SCb:SCr:TL:TCb:TCr> (default: 4:3:3:6:4.5:4.5)', flag: '--denoise', allowed_values: [String], aliases: [] },
+    { name: :nlmeans, description: 'Denoise video with nlmeans filter <ultralight/light/medium/strong> or omitted or <SY:OTY:PSY:RY:FY:PY:Sb:OTb:PSb:Rb:Fb:Pb:Sr:OTr:PSr:Rr:Fr:Pr> (default 8:1:7:3:2:0)', flag: '--nlmeans', allowed_values: [String], aliases: [] },
+    { name: :nimeans_tune, description: 'Tune nlmeans filter to content type. Note: only works in conjunction with presets ultralight/light/medium/strong. <none/film/grain/highmotion/animation> or omitted (default none)', flag: '--nlmeans-tune', allowed_values: ['none', 'film', 'grain', 'highmotion', 'animation', 'omitted', :none, :film, :grain, :highmotion, :animation, :omitted], aliases: [] },
+    { name: :deblock, description: 'Deblock video with pp7 filter (default 5:2)', flag: '--deblock', allowed_values: [String], aliases: [] },
+    { name: :rotate, description: 'Rotate image or flip its axes. Modes: (can be combined) 1 vertical flip, 2 horizontal flip, 4 rotate clockwise 90 degrees, Default: 3 (vertical and horizontal flip)', flag: '--rotate', allowed_values: [1, 2, 3, 4], aliases: [] },
+    { name: :grayscale, description: 'Grayscale encoding', flag: '--grayscale', allowed_values: [nil], aliases: [] },
+    { name: :subtitle_track, description: 'Select subtitle track(s), separated by commas. More than one output track can be used for one input.  Example: \'1,2,3\' for multiple tracks. A special track name \'scan\' adds an extra 1st pass.  This extra pass scans subtitles matching the language of the first audio or the language  selected by --native-language. The one that\'s only used 10 percent of the time or less is selected. This should locate subtitles for short foreign language segments. Best used in conjunction with --subtitle-forced.', flag: '--subtitle', allowed_values: [String, Integer], aliases: [] },
+    { name: :subtitle_forced, description: 'Only display subtitles from the selected stream if the subtitle has the forced flag set. The values in \'string\' are indexes into the subtitle list specified with \'--subtitle\'. Separated by commas for more than one subtitle track. Example: \'1,2,3\' for multiple tracks. If \'string\' is omitted, the first track is forced.', flag: '--subtitle-forced', allowed_values: [String, Integer], aliases: [] },
+    { name: :subtitle_burned, description: 'Burn\' the selected subtitle into the video track. If \'number\' is omitted, the first track is burned. \'number\' is an index into the subtitle list specified with \'--subtitle\'.', flag: '--subtitle-burned', allowed_values: [String, Integer], aliases: [] },
+    { name: :subtitle_default, description: 'Flag the selected subtitle as the default subtitle  to be displayed upon playback.  Setting no default means no subtitle will be automatically displayed. If \'number\' is omitted, the first track is default. \'number\' is an index into the subtitle list specified with \'--subtitle\'.', flag: '--subtitle-default', allowed_values: [String, Integer], aliases: [] },
+    { name: :native_language, description: 'Specifiy your language preference. When the first audio track does not match your native language then select the first subtitle that does. When used in conjunction with --native-dub the audio track is changed in preference to subtitles. Provide the language\'s iso639-2 code (fre, eng, spa, dut, et cetera)', flag: '--native-language', allowed_values: [String], aliases: [] },
+    { name: :native_dub, description: 'Used in conjunction with --native-language requests that if no audio tracks are selected the default selected audio track will be the first one that matches the --native-language. If there are no matching audio tracks then the first matching subtitle track is used instead.', flag: '--native-dub', allowed_values: [String], aliases: [] },
+    { name: :srt_file, description: 'SubRip SRT filename(s), separated by commas.', flag: '--srt-file', allowed_values: [String], aliases: [] },
+    { name: :srt_codeset, description: 'Character codeset(s) that the SRT file(s) are encoded in, separated by commas. Use \'iconv -l\' for a list of valid codesets. If not specified, \'latin1\' is assumed', flag: '--srt-codeset', allowed_values: [String], aliases: [] },
+    { name: :srt_offset, description: 'Offset (in milliseconds) to apply to the SRT file(s), separated by commas. If not specified, zero is assumed. Offsets may be negative.', flag: '--srt-offset', allowed_values: [String], aliases: [] },
+    { name: :srt_lang, description: 'Language as an iso639-2 code fra, eng, spa et cetera) for the SRT file(s), separated by commas. If not specified, then \'und\' is used.', flag: '--srt-lang', allowed_values: [String], aliases: [] },
+    { name: :srt_default, description: 'Flag the selected srt as the default subtitle to be displayed upon playback.  Setting no default means no subtitle will be automatically displayed. If \'number\' is omitted, the first srt is default. \'number\' is an 1 based index into the srt-file list', flag: '--srt-default', allowed_values: [String], aliases: [] },
+    { name: :srt_burn, description: 'Burn\' the selected srt subtitle into the video track. If \'number\' is omitted, the first srt is burned. \'number\' is an 1 based index into the srt-file list', flag: '--srt-burn', allowed_values: [String], aliases: [] },
+    { name: :version, description: 'Display the version number.', flag: '--version', allowed_values: [nil], aliases: [:v] }
+  )
+
+end

data/lib/cli_chef/apps/hand_brake/hand_brake_job.rb

@@ -0,0 +1,11 @@
+class HandBrakeJob < CLIChef::Job
+
+  attr_int :task_count, :task, default: 1
+  attr_float :fps, :average_fps, default: 0
+
+  protected
+
+  def process_line(line, stream = :stdout)
+    self.result.body = self.result.body + line
+  end
+end

data/lib/cli_chef/apps/media_info.rb

@@ -0,0 +1,65 @@
+require 'cli_chef' unless defined?(CLIChef::VERSION)
+
+class MediaInfo < CLIChef::Cookbook
+  self.description = 'MediaInfo is a convenient unified display of the most relevant technical and tag data for video and audio files.'
+
+  add_exit_codes(
+    { code: 0, description: 'No error' },
+    { code: 1, description: 'Failure' }
+  )
+
+  add_default_locations(
+    'C:/Program Files/MediaInfo/MediaInfo.exe',
+    'C:/Program Files(x86)/MediaInfo/MediaInfo.exe'
+  )
+
+  add_ingredients(
+    { name: :help, description: 'Display the CLI help.', flag: '--help', allowed_values: [nil], aliases: [:h], boolean_argument: true },
+    { name: :version, description: 'Display MediaInfo version and exit', flag: '--Version', allowed_values: [nil], aliases: [:v], boolean_argument: true },
+    { name: :full, description: 'Full information Display (all internal tags)', flag: '-f', allowed_values: [nil], aliases: [:verbose], boolean_argument: true },
+    { name: :output_html, description: 'Full information Display with HTML tags', flag: '--Output=HTML', allowed_values: [nil], aliases: [:html], boolean_argument: true },
+    { name: :output_xml, description: 'Full information Display with XML tags', flag: '--Output=XML', allowed_values: [nil], aliases: [:xml], boolean_argument: true },
+    { name: :file, description: 'The file to get tags out of', flag: '', allowed_values: [String], aliases: [:input] }
+  )
+
+  def help
+    run!(help: true).body
+  end
+
+  def version
+    run!(version: true).body.scan(/(?<= v)\d+\.\d+.*/).first
+  end
+
+  def info(file, full = false)
+    run!(file: file, full: full).body.split("\n\n").hmap do |category|
+      lines = category.split("\n")
+      next if lines.empty?
+      [
+        lines.shift.strip.downcase.method_case,
+        lines.hmap do |line|
+          key, value = line.split(':', 2)
+          key = key.downcase.method_case.to_sym
+          [
+            key,
+            convert_value(key, value.strip)
+          ]
+        end
+      ]
+    end.keys_to_sym
+  end
+
+  protected
+
+  def convert_value(key, value)
+    case key
+    when :file_size
+      value.parse_file_size
+    when :duration
+      value.parse_duration
+    when :width, :height
+      value.to_i
+    else
+      value
+    end
+  end
+end

data/lib/cli_chef/apps/sevenzip.rb

@@ -0,0 +1,138 @@
+require 'cli_chef' unless defined?(CLIChef::VERSION)
+require_relative 'sevenzip/archive'
+require_relative 'sevenzip/util'
+
+class SevenZip < CLIChef::Cookbook
+
+  SUPPORTED_ARCHIVES = [
+    '001', '7z', 'a', 'apm', 'ar', 'arj', 'bz2', 'bzip2', 'cab', 'chi', 'chm',
+    'chq', 'chw', 'cpio', 'cramfs', 'deb', 'dmg', 'doc', 'docx', 'epub', 'esd',
+    'ext', 'ext2', 'ext3', 'ext4', 'fat', 'gz', 'gzip', 'hfs', 'hfsx', 'hxi',
+    'hxq', 'hxr', 'hxs', 'hxw', 'ihex', 'img', 'iso', 'jar', 'lha', 'lib',
+    'lit', 'lzh', 'lzma', 'mbr', 'msi', 'mslz', 'msp', 'mub', 'nsis', 'ntfs',
+    'ods', 'odt', 'pkg', 'ppmd', 'ppt', 'qcow', 'qcow2', 'qcow2c', 'r00', 'rar',
+    'rpm', 'scap', 'squashfs', 'swm', 'tar', 'taz', 'tbz', 'tbz2', 'tgz', 'txz',
+    'udf', 'uefif', 'vdi', 'vhd', 'vmdk', 'wim', 'xar', 'xls', 'xlsx', 'xpi',
+    'xz', 'z', 'zip', 'zipx'
+  ].freeze
+
+  self.description = '7-Zip is a file archiver with a high compression ratio.'
+
+  add_exit_codes(
+    { code: 0, description: 'No error' },
+    { code: 1, description: 'Warning (Non fatal error(s)). For example, one or more files were locked by some other application, so they were not compressed.' },
+    { code: 2, description: 'Fatal error', error: true },
+    { code: 7, description: 'Command line error', error: true },
+    { code: 8, description: 'Not enough memory for operation', error: true },
+    { code: 255, description: 'User stopped the process', error: true }
+  )
+
+  add_default_locations(
+    'C:/Program Files/7-Zip/7z.exe',
+    'C:/Program Files(x86)/7-Zip/7z.exe',
+    'C:/7-Zip/7z.exe',
+    '7za',
+    '7z'
+  )
+
+  add_ingredients(
+    { name: :add, description: 'Adds files to archive.', flag: 'a', allowed_values: [nil], aliases: [:a], boolean_argument: true, flag_delimiter: '' },
+    { name: :extract, description: 'Extracts files from an archive to the current directory or to the output directory.', flag: 'e', allowed_values: [nil], aliases: [:e], boolean_argument: true, flag_delimiter: '' },
+    { name: :extract_full_paths, description: 'Extracts files from an archive with their full paths in the current directory, or in an output directory if specified.', flag: 'x', allowed_values: [nil], aliases: [:x], boolean_argument: true, flag_delimiter: '' },
+    { name: :benchmark, description: 'Measures speed of the CPU and checks RAM for errors.', flag: 'b', allowed_values: [nil], aliases: [:b], boolean_argument: true, flag_delimiter: '' },
+    { name: :delete, description: 'Deletes files from archive.', flag: 'd', allowed_values: [nil], aliases: [:d], boolean_argument: true, flag_delimiter: '' },
+    { name: :list, description: 'Lists contents of archive.', flag: 'l', allowed_values: [nil], aliases: [:l], boolean_argument: true, flag_delimiter: '' },
+    { name: :test, description: 'Tests archive files.', flag: 't', allowed_values: [nil], aliases: [:t], boolean_argument: true, flag_delimiter: '' },
+    { name: :update, description: 'Update older files in the archive and add files that are not already in the archive.', flag: 'u', allowed_values: [nil], aliases: [:u], boolean_argument: true, flag_delimiter: '' },
+    { name: :archive, description: 'Specifies the name of the archive', flag: nil, allowed_values: [String, Array], aliases: [:file], flag_delimiter: '' },
+    { name: :include, description: 'Specifies additional include filenames and wildcards.', flag: '-i', allowed_values: [String], aliases: [], flag_delimiter: '' },
+    { name: :method, description: 'Specifies the compression method.', flag: '-m', allowed_values: [String], aliases: [], flag_delimiter: '' },
+    { name: :password, description: 'Specifies password.', flag: '-p', allowed_values: [String], aliases: [], flag_delimiter: '' },
+    { name: :recurse, description: 'Specifies the method of treating wildcards and filenames on the command line.    -r  Enable recurse subdirectories.    -r-  Disable recurse subdirectories. This option is default for all commands.    -r0  Enable recurse subdirectories only for wildcard names.', flag: '-r', allowed_values: [nil, '-', '0', 0], aliases: [], flag_delimiter: '' },
+    { name: :create_sfx, description: 'Creates self extracting archive.', flag: '-sfx', allowed_values: [nil, '7z.sfx', 'tzCon.sfx', '7zS.sfx', '7zSD.sfx'], aliases: [], flag_delimiter: '' },
+    { name: :stdin, description: 'Causes 7-Zip to read data from stdin (standard input) instead of from disc files.', flag: '-si', allowed_values: [nil, String], aliases: [], flag_delimiter: '' },
+    { name: :stdout, description: 'Causes 7-Zip to write output data to stdout (standard output stream).', flag: '-so', allowed_values: [nil, String], aliases: [], flag_delimiter: '' },
+    { name: :compress_shared_files, description: 'Compresses files open for writing by another applications.', flag: '-ssw', allowed_values: [nil], aliases: [], flag_delimiter: '' },
+    { name: :type, description: 'Specifies the type of archive.', flag: '-t', allowed_values: ['*', '7z', 'xz', 'split', 'zip', 'gzip', 'bzip2', 'tar', 'mbr', 'vhd', 'udf'], aliases: [], flag_delimiter: '' },
+    { name: :update_switch, description: 'Specifies how to update files in an archive and (or) how to create new archives.', flag: '-u', allowed_values: [], aliases: [], flag_delimiter: '' },
+    { name: :volumes, description: 'Specifies volume sizes.', flag: '-v', allowed_values: [/\d+[bkmg]/i], aliases: [], flag_delimiter: '' },
+    { name: :working_dir, description: 'Sets the working directory for the temporary base archive.', flag: '-w', allowed_values: [String], aliases: [], flag_delimiter: '' },
+    { name: :exclude, description: 'Specifies which filenames or wildcarded names must be excluded from the operation.', flag: '-x', allowed_values: [String], aliases: [], flag_delimiter: '' },
+    { name: :include_archives, description: 'Specifies additional include archive filenames and wildcards.', flag: '-ai', allowed_values: [String], aliases: [], flag_delimiter: '' },
+    { name: :disable_parsing, description: 'Disables parsing of the archive_name field on the command line.', flag: '-an', allowed_values: [nil], aliases: [], flag_delimiter: '' },
+    { name: :overwrite, description: 'Specifies the overwrite mode during extraction, to overwrite files already present on disk.', flag: '-ao', allowed_values: %w(s a u t), aliases: [:overwrite_mode], flag_delimiter: '' },
+    { name: :exclude_archives, description: 'Specifies archives to be excluded from the operation.', flag: '-ax', allowed_values: [String], aliases: [], flag_delimiter: '' },
+    { name: :output_dir, description: 'Specifies a destination directory where files are to be extracted.', flag: '-o', allowed_values: [String], aliases: [:output_directory, :output], flag_delimiter: '' },
+    { name: :assume_yes, description: 'Disables most of the normal user queries during 7-Zip execution.', flag: '-y', allowed_values: [nil], aliases: [:yes, :assume, :answer_yes], boolean_argument: true, flag_delimiter: '' },
+    { name: :show_technical_information, description: 'Sets technical mode for l (List) command.', flag: '-slt', allowed_values: [nil], aliases: [:slt, :technical, :show_technical], boolean_argument: true, flag_delimiter: '' },
+    { name: :help, description: 'Display the CLI help.', flag: '-h', allowed_values: [nil], aliases: [:h], boolean_argument: true, flag_delimiter: '' },
+    { name: :show_progress, description: 'Print progress to stdout.', flag: '-bsp1', allowed_values: [nil], aliases: [], boolean_argument: true, flag_delimiter: '' }
+  )
+
+  def help
+    run!(help: true).body
+  end
+
+  def version
+    help.scan(/(?<=7-zip )\d+\.\d+\s?\w*/i).first
+  end
+
+  def self.archive(path)
+    SevenZip::Archive.new(path: path)
+  end
+
+  bridge_method :archive
+
+  def list(archive, **opts)
+    args = { list: true, archive: archive, show_technical: true }.merge(opts.except(:list, :archive, :show_technical))
+    run!(args).body.split('----------', 2).last.split("\n\n").map do |details|
+      hash = details.split("\n").hmap do |attribute|
+        next if attribute.empty?
+        key, value = attribute.split(' = ', 2)
+        [key.downcase.gsub(/\s+/, '_').to_sym, value]
+      end
+      Archive::Item.new(hash)
+    end
+  end
+
+  def list_files(archive, **opts)
+    list(archive, **opts).select { |i| i.is_a?(SevenZip::Archive::File) }
+  end
+
+  def list_dirs(archive, **opts)
+    list(archive, **opts).select { |i| i.is_a?(SevenZip::Archive::Dir) }
+  end
+
+  def extract(archive, **opts)
+    type = opts[:full_path] == false ? :extract : :extract_full_paths
+    args = { type => true, file: archive, yes: true, show_progress: true }.merge(opts.except(type, :file, :yes))
+    run(**args) do |line, stream, job|
+      job.percent = line.extract_numbers.first if line =~ /\d+\%/
+    end
+  end
+
+  def extract!(archive, **opts)
+    extract(archive, opts.merge(synchronous: true))
+  end
+
+  [:add, :update, :delete].each do |type|
+    define_method(type) do |archive, file, **opts|
+      args = { type => true, archive: [archive, file], yes: true }.merge(opts.except(type, :archive, :yes))
+      run(**args)
+    end
+
+    define_method("#{type}!") do |archive, file, **opts|
+      send(type, archive, file, opts.merge(synchronous: true))
+    end
+  end
+
+  # TODO Have test return something better
+  def test(archive, **opts)
+    args = { test: true, file: archive, yes: nil }.merge(opts.except(:test, :file, :yes))
+    run(**args)
+  end
+
+  def test!(archive, **opts)
+    test(archive, opts.merge(synchronous: true))
+  end
+end

data/lib/cli_chef/apps/sevenzip/archive.rb

@@ -0,0 +1,43 @@
+require_relative 'item'
+require_relative 'file'
+require_relative 'dir'
+
+class SevenZip < CLIChef::Cookbook
+  class Archive
+    include BBLib::Effortless
+
+    attr_file :path, required: true
+    attr_ary_of File, :files
+    attr_ary_of Dir, :dirs
+
+    after :path=, :load_archive
+
+    def size
+      ::File.size(path)
+    end
+
+    def extract(**opts)
+      SevenZip.extract(path, **opts)
+    end
+
+    def add(file, **opts)
+      SevenZip.add(path, file, **opts)
+    end
+
+    def delete(file, **opts)
+      SevenZip.delete(path, file, **opts)
+    end
+
+    protected
+
+    def load_archive
+      self.files.clear
+      items = SevenZip.list(self.path)
+      items.map { |i| i.archive = self }
+      self.dirs = items.find_all { |i| i.is_a?(Dir) }
+      self.files = items.find_all { |i| !i.is_a?(Dir) }
+      true
+    end
+
+  end
+end

data/lib/cli_chef/apps/sevenzip/dir.rb

@@ -0,0 +1,11 @@
+class SevenZip < CLIChef::Cookbook
+  class Archive
+    class Dir < Item
+
+      def self.folder
+        '+'
+      end
+
+    end
+  end
+end

data/lib/cli_chef/apps/sevenzip/file.rb

@@ -0,0 +1,15 @@
+class SevenZip < CLIChef::Cookbook
+  class Archive
+    class File < Item
+
+      def self.folder
+        '-'
+      end
+
+      def filename
+        path.file_name
+      end
+
+    end
+  end
+end

data/lib/cli_chef/apps/sevenzip/item.rb

@@ -0,0 +1,35 @@
+class SevenZip < CLIChef::Cookbook
+  class Archive
+    class Item
+      include BBLib::Effortless
+
+      attr_str :path, required: true
+      attr_of Archive, :archive, serialize: false
+      attr_int :size, :packed_size, :volume_index, :offset
+      attr_time :modified, :created, :accessed
+      attr_str :comment, :crc, :archive_method, :characteristics
+      attr_str :host_os, :version
+      attr_bool :encrypted, pre_proc: proc { |x| x == '-' }
+
+      init_type :loose
+
+      def self.folder
+        ''
+      end
+
+      setup_init_foundation(:folder) do |a, b|
+        a.to_s[0] == b.to_s[0]
+      end
+
+      def extract(**opts)
+        raise RunTimeError, "No archive has been set for this #{self.class} so it cannot be extracted." unless archive
+        SevenZip.extract([archive.path, self.path], **opts)
+      end
+
+      def delete(**opts)
+        raise RunTimeError, "No archive has been set for this #{self.class} so it cannot be deleted." unless archive
+        archive.delete(self.path)
+      end
+    end
+  end
+end

data/lib/cli_chef/apps/sevenzip/util.rb

@@ -0,0 +1,28 @@
+module BBLib
+  def self.scan_files_and_archives(path, *filters, recursive: false, archive_types: SevenZip::SUPPORTED_ARCHIVES, &block)
+    matches         = []
+    filters         = filters.map { |filter| filter.is_a?(Regexp) ? filter : /^#{Regexp.quote(filter).gsub('\\*', '.*')}$/ }
+    archive_filters = archive_types.map { |type| /\.#{Regexp.quote(type)}$/i }
+
+    scan_files(path, *(filters + archive_filters), recursive: recursive) do |file|
+      if archive_filters.any? { |filter| filter =~ file } && !filters.any? { |filter| filter =~ file }
+        match = false
+        begin
+          SevenZip.list_files(file).select do |archive|
+            match = true if filters.any? { |filter| filter =~ archive.path }
+          end
+        rescue => _e
+          # Nothing, archive check failed
+        end
+        if match
+          matches << file
+          yield file if block_given?
+        end
+      else
+        matches << file
+        yield file if block_given?
+      end
+    end
+    matches
+  end
+end

data/lib/cli_chef/cli_chef.rb

@@ -0,0 +1,6 @@
+require_relative 'version'
+require_relative 'components/ingredient'
+require_relative 'components/exit_code'
+require_relative 'components/result'
+require_relative 'components/job'
+require_relative 'components/cookbook'

data/lib/cli_chef/components/cookbook.rb

@@ -0,0 +1,104 @@
+module CLIChef
+  class Cookbook
+    include BBLib::Effortless
+
+    attr_ary_of String, :default_locations, singleton: true, add_rem: true
+    attr_ary_of ExitCode, :exit_codes, singleton: true, add_rem: true
+    attr_ary_of Ingredient, :ingredients, singleton: true, add_rem: true
+    attr_str :description, singleton: true
+    attr_of Class, :default_job_class, default: CLIChef::Job, singleton: true
+
+    attr_str :path, allow_nil: true, default_proc: proc { |x| x.class.path }
+    attr_of Result, :result, default: nil, allow_nil: true, serialize: false
+
+    before :path, :check_default_locations
+
+    bridge_method :default_job_class, :default_locations, :exit_codes, :ingredients, :description, :ingredient
+
+    # Returns true if the path is either set to a valid file or can be found in the
+    # environment
+    def ready?
+      path && (File.exist?(path) || BBLib::OS.which(path))
+    end
+
+    # Executes a string as a command to this CLI wrapper in a job (threaded)
+    def execute(string, opts = {}, &block)
+      raise RuntimeError, "A valid path is currently not set for #{self.class}. Please set a valid path to the executable first." unless path
+      return execute!(string, opts.except(:synchronous), &block) if opts[:synchronous]
+      string = "#{clean_path} #{string}"
+      BBLib.logger.debug("About to run cmd: #{string}")
+      (opts.delete(:job_class) || default_job_class).new(opts.merge(command: string, parent: self)).tap do |job|
+        job.run(&block)
+      end
+    end
+
+    # Synchonous version of execute
+    def execute!(string, opts = {}, &block)
+      while (job ||= execute(string, opts, &block)).running?
+        # Nothing
+      end
+      job.result
+    end
+
+    # Runs a command within a Job (seperate thread)
+    # For when a command should be run asynchronously
+    def run(**args, &block)
+      return run!(args.except(:synchronous), &block) if args[:synchronous]
+      execute(prepare_args(args), &block)
+    end
+
+    # Blocking version of run that is not executed within a thread.
+    # For when a command should be run synchronously
+    def run!(**args, &block)
+      execute!(prepare_args(args), &block)
+    end
+
+    # Returns the full command line that would be run based on the given arguments
+    def prepare(**args)
+      "#{clean_path} #{prepare_args(args)}"
+    end
+
+    def prepare_args(**args)
+      args.map do |name, arg|
+        ingredient = self.ingredient(name)
+        raise ArgumentError, "Unknown parameter #{name} for #{self.class}." unless ingredient
+        ingredient.to_s(arg)
+      end.join(' ')
+    end
+
+    # Produces a dynamic help menu for this wrapper. Useful mostly for console or
+    # command line based interactions.
+    def menu
+
+    end
+
+    def self.prototype
+      @prototype ||= self.new
+    end
+
+    def self.method_missing(method, *args, &block)
+      prototype.respond_to?(method) ? prototype.send(method, *args, &block) : super
+    end
+
+    def self.respond_to_missing?(method, include_private = false)
+      prototype.respond_to?(method) || super
+    end
+
+    def self.ingredient(name)
+      ingredients.find { |i| i.match?(name) }
+    end
+
+    protected
+
+    def check_default_locations
+      return if @path
+      return unless found = default_locations.find { |path| File.exist?(path) || BBLib::OS.which(path) }
+      self.path = found
+    end
+
+    def clean_path
+      path.to_s.match?(/\s/) ? "\"#{path}\"" : path
+    end
+
+  end
+end

data/lib/cli_chef/components/exit_code.rb

@@ -0,0 +1,19 @@
+module CLIChef
+  class ExitCode
+    include BBLib::Effortless
+
+    attr_int :code, required: true, arg_at: 0
+    attr_str :description, default_proc: proc { |x| x.code == 0 ? 'Success' : 'Undefined Exit Code' }, arg_at: 1
+    attr_bool :error, default: false, arg_at: 2
+
+    def describe
+      "#{error? ? 'ERROR: ' : nil}#{description} (#{code})"
+    end
+  end
+
+  class ExitError < StandardError
+    def initialize(msg = 'The application returned an exit code that indicates an error')
+      super
+    end
+  end
+end

data/lib/cli_chef/components/ingredient.rb

@@ -0,0 +1,46 @@
+module CLIChef
+  class Ingredient
+    include BBLib::Effortless
+    attr_sym :name
+    attr_ary_of Symbol, :aliases, pre_proc: proc { |x| [x].flatten.map { |i| i.to_s.to_sym } }
+    attr_str :flag, default: nil, allow_nil: true
+    attr_of Object, :argument, serialize: false
+    attr_str :delimiter, :flag_delimiter, default: ' '
+    attr_str :description
+    attr_bool :boolean_argument, default: false
+    attr_ary :allowed_values, add_rem: true
+
+    before :argument=, :allowed!, send_arg: true
+
+    def to_s(value = nil)
+      return '' if boolean_argument? && value == false
+      cleaned_arg = cleaned_argument(value)
+      argument == false ? '' : "#{flag}#{flag && !cleaned_arg.empty? ? flag_delimiter : nil}#{cleaned_arg}"
+    end
+
+    def cleaned_argument(value = nil)
+      allowed!(value)
+      return '' if boolean_argument?
+      [value].flatten(1).map(&:to_s).map do |arg|
+        arg.match?(/\s/) && !arg.encap_by?('"') ? "\"#{arg.gsub('"','\\"')}\"" : arg
+      end.join(delimiter)
+    end
+
+    def match?(name)
+      self.name == name || aliases.include?(name)
+    end
+
+    def allowed?(value)
+      return true if allowed_values.empty?
+      allowed_values.any? do |av|
+        av === value || av.nil? && (value == true || value == false)
+      end
+    end
+
+    protected
+
+    def allowed!(value)
+      raise ArgumentError, "#{name} does not accept the value passed to it: #{value} (#{value.class})" unless allowed?(value)
+    end
+  end
+end

data/lib/cli_chef/components/job.rb

@@ -0,0 +1,103 @@
+module CLIChef
+  class Job
+    include BBLib::Effortless
+
+    attr_str :command
+    attr_of Thread, :thread, protected: true
+    attr_of Result, :result, default: nil, allow_nil: true
+    attr_float :percent, default: 0
+    attr_float :eta, default: nil, allow_nil: true
+    attr_of BBLib::TaskTimer, :timer, default: BBLib::TaskTimer.new, serialize: false
+    attr_of Object, :parent, default: nil, allow_nil: true, serialize: false
+    attr_hash :arguments, default: {}
+
+    setup_init_foundation(:type)
+
+    def self.type
+      self.class.to_s.split('::').last.method_case.to_sym
+    end
+
+    serialize_method :type
+    bridge_method :type
+
+    def run(&block)
+      timer.start
+      self.percent = 0.0
+      self.thread = Thread.new do
+        self.result = Result.new(body: '')
+        # TODO Have command killed when parent process dies
+        Open3.popen3(command) do |sin, out, err, pr|
+          self.result.pid = pr.pid
+          { stdout: out, stderr: err }.each do |name, stream|
+            stream.each do |line|
+              block ? yield(line, name, self) : process_line(line, name)
+            end
+          end
+          self.result.exit_code = code_for(pr.value.exitstatus)
+        end
+        self.percent = 100.0
+        self.timer.stop
+        self.result
+      end
+      running?
+    end
+
+    def code_for(code)
+      exit_codes.find do |ec|
+        ec.code == code
+      end || ExitCode.new(code)
+    end
+
+    def exit_codes
+      parent ? parent.exit_codes : []
+    end
+
+    def running?
+      thread && thread.alive?
+    end
+
+    def done?
+      !running?
+    end
+
+    def duration
+      timer.current || timer.last
+    end
+
+    def kill
+      return true unless thread
+      thread.kill
+    end
+
+    def error?
+      result && result.exit_code.error?
+    end
+
+    def success?
+      !error?
+    end
+
+    def eta
+      @eta || estimate_eta
+    end
+
+    def estimate_eta
+      return 0 unless percent && timer.current && percent.positive?
+      (100 - percent) / timer.current
+    end
+
+    protected
+
+    def process_line(line, stream = :stdout)
+      self.result.body = self.result.body + line
+      case stream
+      when :stderr
+        STDERR.puts line unless line.to_s.empty?
+      else
+        # Nothing happens with stdout in the default job class
+        # puts line
+      end
+    end
+
+  end
+end

data/lib/cli_chef/components/result.rb

@@ -0,0 +1,11 @@
+module CLIChef
+  class Result
+    include BBLib::Effortless
+
+    attr_of Object, :body, default: nil, allow_nil: true
+    attr_str :cmd, default: nil, allow_nil: true
+    attr_of ExitCode, :exit_code, default: nil, allow_nil: true
+    attr_int :pid, default: 0
+
+  end
+end

data/lib/cli_chef/version.rb

@@ -0,0 +1,3 @@
+module CLIChef
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: cli_chef
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Brandon Black
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-03-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bblib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: CLI Chef makes building command line wrappers easy and simple to incorporate
+  with your Ruby projects.
+email:
+- d2sm10@hotmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- cli_chef.gemspec
+- lib/bblib/bbfiles.rb
+- lib/cli_chef.rb
+- lib/cli_chef/apps/hand_brake.rb
+- lib/cli_chef/apps/hand_brake/hand_brake_job.rb
+- lib/cli_chef/apps/media_info.rb
+- lib/cli_chef/apps/sevenzip.rb
+- lib/cli_chef/apps/sevenzip/archive.rb
+- lib/cli_chef/apps/sevenzip/dir.rb
+- lib/cli_chef/apps/sevenzip/file.rb
+- lib/cli_chef/apps/sevenzip/item.rb
+- lib/cli_chef/apps/sevenzip/util.rb
+- lib/cli_chef/cli_chef.rb
+- lib/cli_chef/components/cookbook.rb
+- lib/cli_chef/components/exit_code.rb
+- lib/cli_chef/components/ingredient.rb
+- lib/cli_chef/components/job.rb
+- lib/cli_chef/components/result.rb
+- lib/cli_chef/version.rb
+homepage: http://github.com/bblack16/cli-chef
+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.7.4
+signing_key: 
+specification_version: 4
+summary: CLI Chef is a simple and quick CLI wrapper framework for Ruby.
+test_files: []