cheflow 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 17c47fae0ce7df45d53352e6807952f1cea5feb6
+  data.tar.gz: 826c83ab7e8947a0674298978366bff777d886c8
+SHA512:
+  metadata.gz: de3309fe608bafdddd5394ff08be05792868c56c6fc072fe0e86a124cc9df716899507ba7434225dafd0eeed26f44e7593c66a110b34f12953637bd1662c58c3
+  data.tar.gz: 0a3609669fb3c280d96b45a0c559bc658b5084be597a1fd7eca138fb4324298f7723b2d8d6b082517ff16d27f3135ac469b7d16580d5303093bceca251a20980

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/COOKBOOKS.md

@@ -0,0 +1,213 @@
+## Cookbooks
+
+Each cookbook has a pattern applied to it, which is one of Library, Application, or Node, and every
+cookbook should reside in its own Git repository.
+
+
+### Library Cookbooks
+
+This is the most basic building block of Cookbooks. These types of cookbooks are reusable and are
+mixed into other cookbooks to enhance them by:
+
+  - Adding LWRPs that abstract common functionality
+  - Including Libraries that add Ruby modules/classes for any depending cookbooks
+
+The goal of these cookbooks is to abstract common things into re-usable building blocks. They often
+do not include a single recipe because their job is to solely enhance the Chef primitives. It is
+also very common for these cookbooks to not include attributes since there's nothing to configure.
+
+Library cookbooks may depend on other library cookbooks or application cookbooks. They never depend
+on a Node Cookbook and they never depend on a Wrapper cookbook.
+
+Since the name of an LWRP is derived from the cookbook it is defined in, these cookbooks are named
+with that in mind. Pick names that make sense for the way you want LWRPs to appear in recipes.
+
+Library cookbooks are usually public, and you are strongly encouraged to open source your Library
+cookbooks.
+
+
+### Application Cookbooks
+
+These describe a single application or a single piece of software, that share the same name as the
+cookbook itself. If the application the cookbook manages contains multiple components then each one
+is broken up into it's own recipe and the recipe is named after the component it will install.
+Things are broken up in this way so you could install various components spread across a number of
+nodes within an environment.
+
+These cookbooks almost always contain a set of attributes which act as the runtime configuration for
+the cookbook. These attributes can do something like setting a port number or even describing the
+desired state of a service.
+
+Application cookbooks may depend on Library Cookbooks and other Application Cookbooks. They never
+depend on Node Cookbooks. They never depend on a Wrapper or Base Cookbook unless they are intended
+to be internal to your organization and will never be distributed to the Chef Community Site.
+
+These cookbooks are always named after the application they manage, and are usually name-spaced
+with your organization name as a prefix `{organization}_{application_cookbook}`.
+
+
+### Wrapper Cookbooks
+
+This is the lightest Cookbook out of all the known Cookbook patterns. It does a very simple job of
+depending on an Application Cookbook and then exposing a recipe for each recipe found in the
+Application Cookbook that it is wrapping.
+
+Wrapper cookbooks depend on Application Cookbooks only. They do not depend on other Wrapper
+Cookbooks, Library Cookbooks, or Environment Cookbooks.
+
+These cookbooks follow the naming convention `{organization}_{wrapped_cookbook}` or even sometimes
+`{application}_{wrapped_cookbook}`. So the RabbitMQ cookbook for Codio would be called
+`codio_rabbitmq`.
+
+
+### Node Cookbooks
+
+This is the piece that ties the release process of your development cycle together and allows you to
+release software that is easy to install and to configure in anyone's infrastructure as long as they
+have a Chef Server.
+
+These may encapsulate one or more cookbooks which will be run on a node. They would usually be
+private as they are specific to a particular organisation and its nodes. They can be likened to Chef
+Roles, but are preferable due to the more flexible nature of a cookbook.
+
+A Node cookbook is the only cookbook that has its Berksfile.lock checked into source control, as it
+is used to set the cookbook constraints for the node(s) that this will be applied to. This is
+achieved using Chef Environments, where a Node cookbook directly corresponds to a Chef Environment
+of the same name. The Berkshelf lock file is converted into the environment's `cookbook_versions`
+using the Berkshelf `apply` command.
+
+Node cookbook names are prefixed with `node_`. For example `node_webserver`
+
+
+### Base Cookbook
+
+All Node Cookbooks require at least one dependency, and that is the Base cookbook. The Base Cookbook
+is very similar in nature to a Library Cookbook. It contains several recipes that are common to all
+nodes. Examples include configuring NTP and creating system users and SSH access.
+
+The default recipe of your Node cookbooks would be the best place to include your Base cookbook.
+
+
+## Cookbook Development
+
+Chef Cookbooks must adhere to [Semantic Versioning](http://semver.org/). When developing or testing
+changes in a cookbook, you must ensure that the version is set to an odd patch number, for example
+`1.0.1`. Patch releases should be even numbers only, for example `1.0.2`, but major and minor
+releases can be be both odd and even.
+
+All new releases require that the CHANGELOG.md be updated with the release number and the changes
+made in that release.
+
+### Managing Dependencies
+
+[Berkshelf](http://berkshelf.com/) is used to manage Cookbook dependencies in all Cookbooks,
+especially Node Cookbooks.
+
+Every Cookbook, no matter what type should alwsy contain a Berksfile with at least the following
+content:
+
+```ruby
+source "http://berkshelf-api.int.codio.com"
+
+metadata
+```
+
+This specifies the Codio Berkshelf API server instead of the usual public Berkshelf API server. The
+Codio Berkshelf API server pulls in data from both the Chef Cookbook Community and the Codio Chef
+Server.
+
+### Applying Dev Versions
+
+First, don't forget to make sure a dev version is set by setting the patch release to an odd number,
+for example `1.0.1`.
+
+Now upload the node cookbook without freezing it:
+
+```bash
+$ berks upload --no-freeze
+```
+
+Berkshelf will by default, freeze any new cookbook versions that you upload, which prevents further
+uploads from overwriting existing versions. This prevents any nasty surprises. By passing the
+`--no-freeze` option, the new version will not be frozen, allowing you to continue iterating and
+uploading changes to the current version without having to bump the version each time.
+
+#### Node Cookbooks
+
+Because Node cookbooks have the `Berksfile.lock` committed to source control, the development and
+release process is a little different.
+
+Follow the steps above first, then continue on below.
+
+Every Node cookbook has a Chef Environment with the same name, and an accompanying development
+environment. For example, the `node_fileserver` cookbook has a `node_fileserver` and a
+`node_fileserver_dev` Environment. During development, you should ONLY use the dev environment -
+that is the environment ending with `_dev`.
+
+Other environments may exist, for example `staging`, which would have a full Chef environment
+name of `node_fileserver_dev`. Environments without a suffix, are treated as being a production
+environment. For example: `node_fileserver` is the production environment for the FileServer Nodes.
+
+You need to apply the the Node cookbook's version constraints against the development environment.
+
+```bash
+$ berks apply ENVIRONMENT_dev
+```
+
+Or to the staging environment:
+
+```bash
+$ berks apply ENVIRONMENT_staging
+```
+
+This will take the `Berksfile.lock` file and apply its cookbook constraints to the environment
+you passed.
+
+WARNING: Make sure you apply against the correct environment!.
+
+Run chef on each node of the node environment you applied, and your changes should be run.
+
+
+## Cookbook Releasing
+
+Releasing a Cookbook is very similar to applying a dev version.
+
+First, don't forget to make sure a release version is set by setting the version accordingly. If it
+is a patch release, then sure that you use an even number, for example `1.0.2`.
+
+Now upload the node cookbook:
+
+```bash
+$ berks upload
+```
+
+#### Node Cookbooks
+
+When releasing a Node cookbook, you need to apply the the Node cookbook's version constraints
+against the production environment.
+
+```bash
+$ berks apply ENVIRONMENT
+```
+
+This will take the `Berksfile.lock` file and apply its cookbook constraints to the environment
+you passed. Which in this case, because you passed no suffix, the constraints will be applied
+to the production environment.
+
+Now just wait for Chef to run automatically (default every is 2 hours), or run it manually on
+each node of the node environment you applied, and your changes should be run.
+
+```bash
+sudo chef-client
+```
+
+
+## New Nodes
+
+To create and bootstrap a new Chef Node on EC2, a command similar to this should be run:
+
+```bash
+knife ec2 server create -N NODE_NAME -G SECURITY_GROUP_NAME -r "recipe[NODE_COOKBOOK]" -E NODE_ENVIRONMENT --secret-file ~/.chef/codio/encrypted_data_bag_secret -T Product=Codio
+```
+
+For more details, please refer to the Git repository README fr the Node Cookbook you are using.

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Joel Moss
+
+MIT License
+
+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,89 @@
+# Cheflow
+
+A command line tool for managing Chef Environments using Berkshelf and the Node Cookbook Pattern.
+
+> TLDR of the Node Cookbook Pattern; You have one top level cookbook that is locked to a Chef
+Environment. One node per Chef Environment. This Chef Environment is named
+`node_{application_name}_{environment_name}` (i.e. `node_myface_dev`).
+
+Huge thanks go to [Jamie Winsor](https://github.com/reset) who coined the Environment Cookbook
+pattern and created the excellent [Berkflow](https://github.com/reset/berkflow) gem that this Gem is
+based upon and inspired by.
+
+For the full details, read COOKBOOKS.md.
+
+
+## Requirements
+
+* [ChefDK](http://getchef.com/downloads/chef-dk) >= 0.2.0
+
+
+## Installation
+
+Install Cheflow into the ChefDK
+
+    $ chef gem install cheflow
+
+
+## Workflow
+
+The Cheflow workflow is predominantly based on the current Cookbook version, which determines
+whether to apply version locks from Berksfile.lock to the production environment or not.
+
+### Development Releases
+
+If the version's patch number is an odd one, ie. a dev release, then the environment should be
+specified. If no environment is specified, then it will default to `development`. Cheflow will not
+allow you to lock a development release to production, even if you specify it.
+
+#### Create a new development version of a Node cookbook
+
+- Bump the dev version. (eg. 1.0.0 to 1.0.1)
+- Update Berkshelf: `berks install`.
+- Upload new unfrozen version: `berks upload COOKBOOK --no-freeze`.
+- Apply new version to the given Node environment: `berks apply ENVIRONMENT`
+
+Equivalent Cheflow command:
+
+    cheflow up [ENVIRONMENT]
+
+Default environment is `development`.
+
+#### Update development version of a Node cookbook
+
+- Upload new unfrozen version: `berks upload COOKBOOK --no-freeze`.
+
+Cheflow command:
+
+    cheflow up [ENVIRONMENT]
+
+Default environment is `development`.
+
+### Production Releases
+
+If the version's patch number is an even one. ie. a production release, then the environment is
+assumed to be `production`. You can specify any other environment.
+
+- Upload new frozen version
+- Apply frozen version
+
+Cheflow command:
+
+    cheflow release [ENVIRONMENT]
+
+Default environment is `production`.
+
+
+## Usage
+
+    $ cheflow help
+
+
+
+## Contributing
+
+1. Fork it ( https://github.com/joelmoss/cheflow/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/cheflow

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+$:.push File.expand_path('../../lib', __FILE__)
+require 'cheflow/cli'
+
+Cheflow::Cli.start(ARGV)

data/cheflow.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cheflow/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cheflow"
+  spec.version       = Cheflow::VERSION
+  spec.authors       = ["Joel Moss"]
+  spec.email         = ["joel@developwithstyle.com"]
+  spec.summary       = %q{A Cookbook-Centric workflow tool}
+  spec.description   = %q{A CLI for managing Chef Environments using Berkshelf and the [slightly modified] Environment Cookbook Pattern.}
+  spec.homepage      = "https://github.com/joelmoss/cheflow"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "semverse",          "~> 1.1"
+  spec.add_dependency "berkshelf",         "~> 3.0"
+  spec.add_dependency "ridley",            "~> 4.0"
+  spec.add_dependency "ridley-connectors", "~> 2.3"
+  spec.add_dependency "thor",              "~> 0.18"
+  spec.add_dependency "octokit",           "~> 3.0"
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+end

data/lib/cheflow/cli.rb

@@ -0,0 +1,101 @@
+require 'cheflow'
+require 'thor'
+require 'semverse'
+require 'tempfile'
+require 'fileutils'
+require 'celluloid'
+
+module Cheflow
+  class Cli < Thor
+
+    LATEST = "latest".freeze
+
+
+    def initialize(*args)
+      super(*args)
+
+      Ridley.logger.level = ::Logger::INFO if @options[:verbose]
+      Ridley.logger.level = ::Logger::DEBUG if @options[:debug]
+    end
+
+
+    namespace 'cheflow'
+
+    map 'up' => :upgrade
+    map 'i' => :info
+    map ["ver", "-v", "--version"] => :version
+
+    class_option :verbose,
+      type: :boolean,
+      desc: "Output verbose information",
+      aliases: "-v",
+      default: false
+    class_option :debug,
+      type: :boolean,
+      desc: "Output debug information",
+      aliases: "-d",
+      default: false
+    class_option :berksfile,
+      type: :string,
+      default: nil,
+      desc: 'Path to a Berksfile to operate off of.',
+      aliases: '-b',
+      banner: 'PATH'
+    class_option :ssh_user,
+      type: :string,
+      desc: "SSH user to execute commands as",
+      aliases: "-u",
+      default: ENV["USER"]
+    class_option :ssh_password,
+      type: :string,
+      desc: "Perform SSH authentication with the given password",
+      aliases: "-p",
+      default: nil
+    class_option :ssh_key,
+      type: :string,
+      desc: "Perform SSH authentication with the given key",
+      aliases: "-P",
+      default: nil
+
+    # desc "upgrade [environment]", "Upload and apply the current cookbook version to the specified"
+    # def upgrade(env = 'development')
+    # end
+
+    desc 'version', 'Display version information'
+    def version
+      say "Cheflow v#{Cheflow::VERSION}"
+    end
+
+    desc 'info', 'Display information about the cookbook'
+    def info
+      say "#{cookbook.type} Cookbook: #{cookbook}"
+      say cookbook.path
+      say
+      say "Environments: #{cookbook.node_environments.join("\n              ")}"
+      say
+      say 'Versions:'
+      say "  Production:  " + cookbook.prod_versions.join(', ')
+      say "  Development: " + cookbook.dev_versions.join(', ')
+    end
+
+    desc 'default', 'Show version, info and help'
+    def default
+      invoke :version
+      say
+      say '-' * 90
+      invoke :info
+      say '-' * 90
+      say
+      invoke :help
+    end
+    default_task :default
+
+
+    private
+
+      def cookbook
+        @cookbook ||= Cheflow::Cookbook.new(options)
+      end
+
+  end
+end

data/lib/cheflow/cookbook.rb

@@ -0,0 +1,91 @@
+module Cheflow
+  class Cookbook
+
+    attr_reader :berksfile
+
+
+    def initialize(options)
+      @options = options
+      @berksfile = Berkshelf::Berksfile.from_options(options)
+    end
+
+    def metadata
+      @metadata ||= begin
+        metadata_path = File.expand_path(File.join(path, 'metadata.rb'))
+        Ridley::Chef::Cookbook::Metadata.from_file(metadata_path)
+      end
+    end
+
+    def version
+      @version ||= Semverse::Version.new(metadata.version)
+    end
+
+    def name
+      @name ||= metadata.name
+    end
+
+    def path
+      @path ||= File.dirname(berksfile.filepath)
+    end
+
+    def type
+      if name.start_with? 'node_'
+        'Node'
+      end
+    end
+
+    def node_environment_objects
+      @node_environments ||= ridley.search(:environment, "name:node_mongodb*")
+    end
+
+    def node_environments
+      @node_environment_names ||= node_environment_objects.map do |e|
+        env = e.name.gsub /^#{name}_/, ''
+        env = env == name ? 'production' : env
+        "#{env.ljust(12)} (#{e.cookbook_versions[name]})"
+      end
+    end
+
+    def versions
+      @versions ||= ridley.cookbook.versions(name)
+    end
+
+    def dev_versions
+      versions.select { |v| Semverse::Version.new(v).patch.odd? }
+    end
+
+    def prod_versions
+      versions.select { |v| Semverse::Version.new(v).patch.even? }
+    end
+
+    def to_s
+      "#{name} v#{version}#{' (dev)' if version.patch.odd?}#{' (FROZEN)' if frozen?}"
+    end
+
+    def frozen?
+      ridley.cookbook.find(name, version).frozen?
+    end
+
+
+    private
+
+      def ridley
+        @ridley ||= Ridley.new(server_url: config.chef.chef_server_url, client_name: config.chef.node_name,
+          client_key: config.chef.client_key, ssh: {
+            user: @options[:ssh_user], password: @options[:ssh_password], keys: @options[:ssh_key],
+            sudo: use_sudo?
+        }, ssl: {
+          verify: config.ssl.verify
+        })
+      end
+
+      def config
+        Berkshelf::Config.instance
+      end
+
+      def use_sudo?
+        @options[:sudo].nil? ? true : @options[:sudo]
+      end
+
+  end
+end

data/lib/cheflow/version.rb

@@ -0,0 +1,3 @@
+module Cheflow
+  VERSION = "0.1.0"
+end

data/lib/cheflow.rb

@@ -0,0 +1,11 @@
+require 'celluloid/autostart'
+require 'cheflow/version'
+require 'ridley'
+require 'ridley-connectors'
+require 'berkshelf'
+
+Celluloid.logger.level = ::Logger::ERROR
+
+module Cheflow
+  require 'cheflow/cookbook'
+end

metadata

@@ -0,0 +1,170 @@
+--- !ruby/object:Gem::Specification
+name: cheflow
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joel Moss
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: semverse
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: berkshelf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: ridley
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: ridley-connectors
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.3'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.18'
+- !ruby/object:Gem::Dependency
+  name: octokit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+description: A CLI for managing Chef Environments using Berkshelf and the [slightly
+  modified] Environment Cookbook Pattern.
+email:
+- joel@developwithstyle.com
+executables:
+- cheflow
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- COOKBOOKS.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/cheflow
+- cheflow.gemspec
+- lib/cheflow.rb
+- lib/cheflow/cli.rb
+- lib/cheflow/cookbook.rb
+- lib/cheflow/version.rb
+homepage: https://github.com/joelmoss/cheflow
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A Cookbook-Centric workflow tool
+test_files: []