# dependencies

name: rake
version: 10.3.2
summary: Rake is a Make-like program implemented in Ruby
homepage: https://github.com/jimweirich/rake
license_names: ["MIT"]
description:
  Rake is a Make-like program implemented in Ruby. Tasks and dependencies are
  specified in standard Ruby syntax.

  Rake has the following features:

  * Rakefiles (rake's version of Makefiles) are completely defined in
    standard Ruby syntax.  No XML files to edit.  No quirky Makefile
    syntax to worry about (is that a tab or a space?)

  * Users can specify tasks with prerequisites.

  * Rake supports rule patterns to synthesize implicit tasks.

  * Flexible FileLists that act like arrays but know about manipulating
    file names and paths.

  * A library of prepackaged tasks to make building rakefiles easier. For example,
    tasks for building tarballs and publishing to FTP or SSH sites.  (Formerly
    tasks for building RDoc and Gems were included in rake but they're now
    available in RDoc and RubyGems respectively.)

  * Supports parallel execution of tasks.


name: addressable
version: 2.3.6
summary: URI Implementation
homepage: http://addressable.rubyforge.org/
license_names: ["Apache 2.0"]
description:
  Addressable is a replacement for the URI implementation that is part of
  Ruby's standard library. It more closely conforms to the relevant RFCs and
  adds support for IRIs and URI templates.


name: mime-types
version: 1.25.1
summary: This library allows for the identification of a file's likely MIME content type
homepage: http://mime-types.rubyforge.org/
license_names: ["MIT","Artistic 2.0","GPL-2"]
description:
  This library allows for the identification of a file's likely MIME content
  type. This is release 1.25.1, fixing an issue with priority comparison for
  mime-types 1.x. The current release is 2.0, which only supports Ruby 1.9 or
  later.

  Release 1.25.1 contains all features of 1.25, including the experimental
  caching and lazy loading functionality. The caching and lazy loading features
  were initially implemented by Greg Brockman (gdb). As these features are
  experimental, they are disabled by default and must be enabled through the use
  of environment variables. The cache is invalidated on a per-version basis; the
  cache for version 1.25 will not be reused for any later version.

  To use lazy loading, set the environment variable +RUBY_MIME_TYPES_LAZY_LOAD+
  to any value other than 'false'. When using lazy loading, the initial startup
  of MIME::Types is around 12–25× faster than normal startup (on my system,
  normal startup is about 90 ms; lazy startup is about 4 ms). This isn't
  generally useful, however, as the MIME::Types database has not been loaded.
  Lazy startup and load is just *slightly* faster—around 1 ms. The real advantage
  comes from using the cache.

  To enable the cache, set the environment variable +RUBY_MIME_TYPES_CACHE+ to a
  filename where MIME::Types will have read-write access. The first time a new
  version of MIME::Types is run using this file, it will be created, taking a
  little longer than normal. Subsequent loads using the same cache file will be
  approximately 3½× faster (25 ms) than normal loads. This can be combined with
  +RUBY_MIME_TYPES_LAZY_LOAD+, but this is *not* recommended in a multithreaded
  or multiprocess environment where all threads or processes will be using the
  same cache file.

  As the caching interface is still experimental, the only values cached are the
  default MIME::Types database, not any custom MIME::Types added by users.

  MIME types are used in MIME-compliant communications, as in e-mail or HTTP
  traffic, to indicate the type of content which is transmitted. MIME::Types
  provides the ability for detailed information about MIME entities (provided as
  a set of MIME::Type objects) to be determined and used programmatically. There
  are many types defined by RFCs and vendors, so the list is long but not
  complete; don't hesitate to ask to add additional information. This library
  follows the IANA collection of MIME types (see below for reference).

  MIME::Types for Ruby was originally based on MIME::Types for Perl by Mark
  Overmeer, copyright 2001 - 2009.

  MIME::Types is built to conform to the MIME types of RFCs 2045 and 2231. It
  tracks the {IANA registry}[http://www.iana.org/assignments/media-types/]
  ({ftp}[ftp://ftp.iana.org/assignments/media-types]) with some unofficial types
  added from the {LTSW collection}[http://www.ltsw.se/knbase/internet/mime.htp]
  and added by the users of MIME::Types.


name: rest-client
version: 1.6.7
summary: Simple HTTP and REST client for Ruby, inspired by microframework syntax for specifying actions.
homepage: http://github.com/archiloque/rest-client
license_names: ["MIT"]
description:
  A simple HTTP and REST client for Ruby, inspired by the Sinatra microframework style of specifying actions: get, put, post, delete.


name: rubocop
version: 0.27.1
summary: Automatic Ruby code style checking tool.
homepage: http://github.com/bbatsov/rubocop
license_names: ["MIT"]
description:
      Automatic Ruby code style checking tool.
      Aims to enforce the community-driven Ruby Style Guide.


name: multipart-post
version: 2.0.0
summary: A multipart form post accessory for Net::HTTP.
homepage: https://github.com/nicksieger/multipart-post
license_names: ["MIT"]
description:
  Use with Net::HTTP to do multipart form posts.  IO values that have #content_type, #original_filename, and #local_path will be posted as a binary file.


name: hitimes
version: 1.2.2
homepage: http://github.com/copiousfreetime/hitimes
license_names: ["ISC"]
summary:
  Hitimes is a fast, high resolution timer library for recording performance metrics.  It uses the appropriate low method calls for each system to get the highest granularity time increments possible.

description:
  Hitimes is a fast, high resolution timer library for recording performance metrics.  It uses the appropriate low method calls for each system to get the highest granularity time increments possible.   It currently supports any of the following systems: * any system with the POSIX call `clock_gettime()` * Mac OS X * Windows * JRuby Using Hitimes can be faster than using a series of `Time.new` calls, and it will have a much higher granularity. It is definitely faster than using `Process.times`.


name: timers
version: 4.0.1
description: Pure Ruby one-shot and periodic timers
homepage: https://github.com/celluloid/timers
license_names: ["MIT"]
summary:
  Schedule procs to run after a certain time, or at periodic intervals, using any API that accepts a timeout


name: celluloid
version: 0.16.0
summary: Actor-based concurrent object framework for Ruby
homepage: https://github.com/celluloid/celluloid
license_names: ["MIT"]
description:
  Celluloid enables people to build concurrent programs out of concurrent objects just as easily as they build sequential programs out of sequential objects


name: cleanroom
version: 1.0.0
summary: (More) safely evaluate Ruby DSLs with cleanroom
homepage: https://github.com/sethvargo/cleanroom
license_names: ["Apache 2.0"]
description:
  Ruby is an excellent programming language for creating and managing custom DSLs, but how can you securely evaluate a DSL while explicitly controlling the methods exposed to the user? Our good friends instance_eval and instance_exec are great, but they expose all methods - public, protected, and private - to the user. Even worse, they expose the ability to accidentally or intentionally alter the behavior of the system! The cleanroom pattern is a safer, more convenient, Ruby-like approach for limiting the information exposed by a DSL while giving users the ability to write awesome code!


name: minitar
version: 0.5.4
summary: Provides POSIX tarchive management from Ruby programs.
homepage: http://www.github.com/atoulme/minitar
license_names: ["ruby"]
description:
  Archive::Tar::Minitar is a pure-Ruby library and command-line utility that provides the ability to deal with POSIX tar(1) archive files. The implementation is based heavily on Mauricio Ferna'ndez's implementation in rpa-base, but has been reorganised to promote reuse in other projects. Antoine Toulme forked the original project on rubyforge to place it on github, under http://www.github.com/atoulme/minitar


name: buff-ignore
version: 1.1.1
description: Parse ignore files with Ruby
homepage: https://github.com/sethvargo/buff-ignore
license_names: ["Apache 2.0"]
summary:
  A Ruby library for parsing lists of files and applying pattern matching exclusion (such as .gitignore)


name: erubis
version: 2.7.0
summary: a fast and extensible eRuby implementation which supports multi-language
homepage: http://www.kuwata-lab.com/erubis/
license_names: ["MIT"]
description:
    Erubis is an implementation of eRuby and has the following features:

    * Very fast, almost three times faster than ERB and about 10% faster than eruby.
    * Multi-language support (Ruby/PHP/C/Java/Scheme/Perl/Javascript)
    * Auto escaping support
    * Auto trimming spaces around '<% %>'
    * Embedded pattern changeable (default '<% %>')
    * Enable to handle Processing Instructions (PI) as embedded pattern (ex. '<?rb ... ?>')
    * Context object available and easy to combine eRuby template with YAML datafile
    * Print statement available
    * Easy to extend and customize in subclass
    * Ruby on Rails support


name: net-http-persistent
version: 2.9.4
summary: Manages persistent connections using Net::HTTP plus a speed fix for Ruby 1.8
homepage: http://docs.seattlerb.org/net-http-persistent
license_names: ["MIT"]
description:
  Manages persistent connections using Net::HTTP plus a speed fix for Ruby 1.8.
  It's thread-safe too!

  Using persistent HTTP connections can dramatically increase the speed of HTTP.
  Creating a new HTTP connection for every request involves an extra TCP
  round-trip and causes TCP congestion avoidance negotiation to start over.

  Net::HTTP supports persistent connections with some API methods but does not
  handle reconnection gracefully.  Net::HTTP::Persistent supports reconnection
  and retry according to RFC 2616.


name: test-kitchen
version: 1.2.1
homepage: http://kitchen.ci
license_names: ["Apache 2.0"]
summary:
  Test Kitchen is an integration tool for developing and testing infrastructure code and software on isolated target platforms.

description:
  Test Kitchen is an integration tool for developing and testing infrastructure code and software on isolated target platforms.


name: chef
version: 11.16.4
homepage: http://wiki.opscode.com/display/chef
license_names: ["Apache 2.0"]
summary:
  A systems integration framework, built to bring the benefits of configuration management to your entire infrastructure.

description:
  A systems integration framework, built to bring the benefits of configuration management to your entire infrastructure.


name: rack
version: 1.5.2
summary: a modular Ruby webserver interface
homepage: http://rack.github.com/
license_names: ["MIT"]
description:
  Rack provides a minimal, modular and adaptable interface for developing
  web applications in Ruby.  By wrapping HTTP requests and responses in
  the simplest way possible, it unifies and distills the API for web
  servers, web frameworks, and software in between (the so-called
  middleware) into a single method call.

  Also see http://rack.github.com/.


name: diff-lcs
version: 1.2.5
homepage: http://diff-lcs.rubyforge.org/
license_names: ["MIT","Perl Artistic v2","GNU GPL v2"]
summary:
  Diff::LCS computes the difference between two Enumerable sequences using the McIlroy-Hunt longest common subsequence (LCS) algorithm

description:
  Diff::LCS computes the difference between two Enumerable sequences using the
  McIlroy-Hunt longest common subsequence (LCS) algorithm. It includes utilities
  to create a simple HTML diff output format and a standard diff-like tool.

  This is release 1.2.4, fixing a bug introduced after diff-lcs 1.1.3 that did
  not properly prune common sequences at the beginning of a comparison set.
  Thanks to Paul Kunysch for fixing this issue.

  Coincident with the release of diff-lcs 1.2.3, we reported an issue with
  Rubinius in 1.9 mode
  ({rubinius/rubinius#2268}[https://github.com/rubinius/rubinius/issues/2268]).
  We are happy to report that this issue has been resolved.


name: highline
version: 1.6.21
summary: HighLine is a high-level command-line IO library.
homepage: http://highline.rubyforge.org
license_names: ["ruby"]
description:
  A high-level IO library that provides validation, type conversion, and more for
  command-line interfaces. HighLine also includes a complete menu system that can
  crank out anything from simple list selection to complete shells with just
  minutes of work.


name: net-ssh
version: 2.9.1
summary: Net::SSH: a pure-Ruby implementation of the SSH2 client protocol.
homepage: https://github.com/net-ssh/net-ssh
license_names: ["MIT"]
description:
  Net::SSH: a pure-Ruby implementation of the SSH2 client protocol. It allows you to write programs that invoke and interact with processes on remote servers, via SSH2.


name: ipaddress
version: 0.8.0
summary: IPv4/IPv6 addresses manipulation library
homepage: http://github.com/bluemonk/ipaddress
license_names: ["MIT"]
description:
        IPAddress is a Ruby library designed to make manipulation 
        of IPv4 and IPv6 addresses both powerful and simple. It mantains
        a layer of compatibility with Ruby's own IPAddr, while 
        addressing many of its issues.


name: wmi-lite
version: 1.0.0
homepage: https://github.com/opscode/wmi-lite
license_names: ["Apache 2.0"]
summary:
  A lightweight utility library for accessing basic WMI (Windows Management Instrumentation) functionality on Windows

description:
  A lightweight utility over win32ole for accessing basic WMI (Windows Management Instrumentation) functionality in the Microsoft Windows operating system. It has no runtime dependencies other than Ruby, so it can be used without concerns around dependency issues.


name: plist
version: 3.1.0
summary: All-purpose Property List manipulation library.
homepage: http://plist.rubyforge.org
license_names: ["MIT"]
description:
  Plist is a library to manipulate Property List files, also known as plists.  It can parse plist files into native Ruby data structures as well as generating new plist files from your Ruby objects.


name: coderay
version: 1.1.0
summary: Fast syntax highlighting for selected languages.
homepage: http://coderay.rubychan.de
license_names: ["MIT"]
description:
  Fast and easy syntax highlighting for selected languages, written in Ruby. Comes with RedCloth integration and LOC counter.


name: nokogiri
version: 1.6.4.1
summary: Nokogiri (鋸) is an HTML, XML, SAX, and Reader parser
homepage: http://nokogiri.org
license_names: ["MIT"]
description:
  Nokogiri (鋸) is an HTML, XML, SAX, and Reader parser.  Among Nokogiri's
  many features is the ability to search documents via XPath or CSS3 selectors.

  XML is like violence - if it doesn’t solve your problems, you are not using
  enough of it.


name: chefspec
version: 4.1.1
summary: Write RSpec examples and generate coverage reports for Chef recipes!
homepage: http://code.sethvargo.com/chefspec
license_names: ["MIT"]
description:
  ChefSpec is a unit testing and resource coverage (code coverage) framework for testing Chef cookbooks ChefSpec makes it easy to write examples and get fast feedback on cookbook changes without the need for virtual machines or cloud servers.


name: multi_json
version: 1.10.1
summary: A common interface to multiple JSON libraries.
homepage: http://github.com/intridea/multi_json
license_names: ["MIT"]
description:
  A common interface to multiple JSON libraries, including Oj, Yajl, the JSON gem (with C-extensions), the pure-Ruby JSON gem, NSJSONSerialization, gson.rb, JrJackson, and OkJson.


name: mini_portile
version: 0.6.1
summary: Simplistic port-like solution for developers
homepage: http://github.com/luislavena/mini_portile
license_names: ["MIT"]
description:
  Simplistic port-like solution for developers. It provides a standard and simplified way to compile against dependency libraries without messing up your system.


name: polyglot
version: 0.3.5
summary: Augment 'require' to load non-Ruby file types
homepage: http://github.com/cjheath/polyglot
license_names: ["MIT"]
description:
  The Polyglot library allows a Ruby module to register a loader
  for the file type associated with a filename extension, and it
  augments 'require' to find and load matching files.


name: lumberjack
version: 1.0.9
homepage: http://github.com/bdurand/lumberjack
license_names: ["MIT"]
summary:
  A simple, powerful, and very fast logging utility that can be a drop in replacement for Logger or ActiveSupport::BufferedLogger.

description:
  A simple, powerful, and very fast logging utility that can be a drop in replacement for Logger or ActiveSupport::BufferedLogger. Provides support for automatically rolling log files even with multiple processes writing the same log file.


name: safe_yaml
version: 1.0.4
description: Parse YAML safely
homepage: https://github.com/dtao/safe_yaml
license_names: ["MIT"]
summary:
  SameYAML provides an alternative implementation of YAML.load suitable for accepting user input in Ruby applications.


name: sqlite3
version: 1.3.10
homepage: https://github.com/sparklemotion/sqlite3-ruby
license_names: ["New BSD"]
summary:
  This module allows Ruby programs to interface with the SQLite3 database engine (http://www.sqlite.org)

description:
  This module allows Ruby programs to interface with the SQLite3
  database engine (http://www.sqlite.org).  You must have the
  SQLite engine installed in order to build this module.

  Note that this module is only compatible with SQLite 3.6.16 or newer.


name: license_finder
version: 1.2
summary: Audit the OSS licenses of your application's dependencies.
homepage: https://github.com/pivotal/LicenseFinder
license_names: ["MIT"]
description:
      LicenseFinder works with your package managers to find
      dependencies, detect the licenses of the packages in them, compare
      those licenses against a user-defined whitelist, and give you an
      actionable exception report.


name: ruby-progressbar
version: 1.7.0
summary: Ruby/ProgressBar is a flexible text progress bar library for Ruby.
homepage: https://github.com/jfelchner/ruby-progressbar
license_names: ["MIT"]
description:
  Ruby/ProgressBar is an extremely flexible text progress bar library for Ruby.
  The output can be customized with a flexible formatting system including:
  percentage, bars of various formats, elapsed time and estimated time remaining.


