bocuse 0.1.0

data/bin/bocuse

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+#
+
+require 'thor'
+
+$:.unshift File.expand_path '../../lib', __FILE__
+require 'bocuse'
+
+class BocuseCLI < Thor
+  desc "compile NODE_FQDN", "Compiles the node given and outputs its JSON configuration."
+  def compile(node_fqdn)
+    project     = Bocuse::Project.new(Dir.pwd)
+    node_config = project.nodes[node_fqdn]
+        
+    puts MultiJson.encode node_config.to_h
+  end
+end
+
+BocuseCLI.start

data/lib/bocuse/configuration.rb

@@ -0,0 +1,103 @@
+module Bocuse
+  
+  # This is the core class of bocuse.
+  #
+  # Its functions are:
+  #  * to be able to spit out a configuration hash when prompted.
+  #  * to be configurable
+  #
+  # It will mainly return proxies that will lodge themselves in its internal
+  # hash. The proxies usually represent an internal hash value.
+  #
+  class Configuration
+    
+    attr_reader :store,
+                :unresolved_block
+    
+    def initialize(hash=nil, &block)
+      @store = hash && hash.dup || Hash.new
+      
+      call(block) if block
+    end
+    
+    # Explicit accessor for POROs.
+    #
+    # Note: Unwraps Values.
+    #
+    def [] key
+      value = @store[key]
+      value.to_h rescue value
+    end
+    
+    # Sets key to value. 
+    #
+    def []= key, value
+      @store[key] = value
+    end
+        
+    # The main method.
+    #
+    # It will react to method calls, install the right keys on the internal
+    # store and return proxies on which callers can perform operations, e.g.
+    # <<.
+    #
+    # Note: The user only interacts with Configurations. Not with the internal
+    # values.
+    #
+    # Except when the user explicitly takes the
+    # values out using [].
+    #
+    def method_missing name, *args
+      case args.size
+      when 0
+        if block_given?
+          subconfig = Configuration.new &Proc.new
+          store[name] = subconfig
+        else
+          store[name] ||= Value.new 
+        end
+      when 1
+        store[name] = Value.new args.first
+      end
+    end
+    
+    # Returns a configuration hash.
+    #
+    # NOTE: Resolves any unresolved blocks.
+    #
+    # NOTE: Call to_json on this to get a JSON representation of the hash.
+    #
+    def to_h
+      copy = {}
+      store.each do |key, value|
+        value = value.to_h if value.respond_to?(:to_h)
+        copy[key] = value if value
+      end
+      copy
+    end
+    
+    # Performs a deep duplication of this configuration object. This is mainly
+    # used by the user for quickly generating a lot of copies of a template.
+    # 
+    def dup(&block)
+      dup_cfg = Configuration.new
+
+      store.each do |key, value|
+        dup_cfg[key] = value.dup
+      end
+
+      dup_cfg.call(block) if block
+      dup_cfg
+    end
+    
+    # Executes the block such that it may modify this object. 
+    #
+    def call(block)
+      fail ArgumentError unless block
+
+      block.call(self) if block.arity>0
+      instance_eval(&block) if block.arity == 0
+    end
+  end
+  
+end

data/lib/bocuse/file.rb

@@ -0,0 +1,72 @@
+
+# Represents a bocuse File. 
+#
+# This is usually a file that contains one or more of the
+# following directives:
+#  * node
+#  * template
+#
+# It is used to generate a config hash from the given files.
+#
+class Bocuse::File
+  attr_reader :path
+
+  # When inside a construct that has a configuration associated, this will 
+  # return that configuration instance.
+  attr_reader :current_configuration
+
+  def initialize(path, context)
+    @path = path
+    @context = context
+  end
+    
+  # Returns a config hash.
+  #
+  # Call to_h on the returned configuration to get the config hash.
+  #
+  # Will return nil if there is no configuration to speak of inside the file.
+  # Use "node" or "template" to define a configuration.
+  #
+  def evaluate
+    ::File.open path, 'r' do |file|
+      self.instance_eval file.read, file.path
+    end
+  end
+
+  # The files read by #evaluate will trigger these methods.
+  #
+  def node name
+    unit = Bocuse::Unit.new(Proc.new, @context)
+
+    configuration_block do |configuration|
+      unit.call(configuration)
+      @context.register_node name, configuration
+    end
+  end
+  def template
+    # Delay template evaluation until someone tries to call include_template.
+    # At that time, we'll have a configuration object to have the template
+    # manipulate. 
+    unit = Bocuse::Unit.new(Proc.new, @context)
+    @context.register_template path, unit
+    unit
+  end
+private
+  def configuration_block
+    # NOTE since thread-safety is not an issue here (who would use threads
+    # to define configuration?), we can use a simple file-global state to
+    # keep track of which configuration is in progress. We use the begin-end
+    # construct to make sure that configurations are not used beyond the end
+    # of the node block. 
+
+    configuration = @current_configuration = Bocuse::Configuration.new
+  
+    begin
+      yield configuration
+    ensure
+      @current_configuration = nil
+    end
+  
+    configuration
+  end
+end

data/lib/bocuse/project.rb

@@ -0,0 +1,155 @@
+require 'pathname'
+
+module Bocuse
+  # A bocuse project comes in two flavours: simple and co-located with chef.
+  # The simple project is a directory with the subdirectories 
+  #   nodes/
+  #   templates/
+  #   lib/
+  #
+  # The nodes/ subdirectory contains all node descriptions, templates/
+  # contains templates and lib/ is added to the load path and can contain code
+  # to help with construction of the configuration. 
+  #
+  # When you co-host bocuse with chef, normally you would store all these
+  # directories one level deeper. Here's what your hierarchy should look like
+  # in this case: 
+  # 
+  #   config/
+  #     nodes/
+  #     templates/
+  #     lib/
+  #
+  # This class does most of the base path handling and of the path
+  # manipulation. 
+  #
+  class Project
+    attr_reader :base_path
+        
+    # Initialize a bocuse project by specifying its base directory. 
+    #
+    def initialize(base_directory=nil)
+      base_directory = base_directory || Dir.pwd
+        
+      if chef_cohosted?(base_directory)
+        base_directory = ::File.join(base_directory, 'config')
+      end
+      
+      @base_path = Pathname.new(base_directory)
+      @templates = Hash.new
+      @nodes     = Hash.new
+      
+      # Make sure that project libraries can be loaded: 
+      lib_dir = base_path.join('lib')
+      $:.unshift lib_dir if ::File.directory?(lib_dir)
+    end
+    
+    # Returns one of the projects files as a {File}.
+    #
+    # @param path [String] a relative or absolute file path 
+    # @return [File] file at path below the project directory
+    #
+    def file path
+      path = Pathname.new(path)
+      path = base_path.join(path) unless path.absolute?
+      
+      Bocuse::File.new(path, self)
+    end
+    
+    # Evaluates a file given by path. 
+    #
+    # @param path [String] file path, either absolute or relative to project
+    #   base directory
+    # @return [void]
+    #
+    def evaluate path
+      file(path).evaluate
+    end
+    
+    # Registers a template for project usage. 
+    #
+    def register_template path, template
+      path = path.to_s
+      template_base = base_path.join('templates/').to_s
+      
+      # Is this template path below base_path?
+      if path.start_with?(template_base)
+        path = path[template_base.size..-1]
+      end
+      
+      # Does the path end in .rb? (most will)
+      if path.end_with?('.rb')
+        path = path.slice 0..-4
+      end
+
+      @templates.store path.to_sym, template
+    end
+    
+    # Returns a template by name. Official template names can be either
+    # absolute paths or relative paths to template files, but do NOT end in
+    # .rb. 
+    # 
+    #   foo               -> templates/foo.rb
+    #   /templates/bar    -> /usr/templates/bar.rb
+    #
+    def template name
+      unless @templates.has_key?(name.to_sym)
+        file_name = name.to_s
+        file_name += '.rb' unless file_name.end_with?('.rb')
+        
+        # Try to find and load this template: 
+        template_path = base_path.join('templates', file_name)
+        file(template_path).evaluate
+        
+        # A successful load will register the template.
+      end
+      
+      @templates.fetch(name.to_sym)
+    end
+    
+    # Registers a machine node in the project. 
+    #
+    def register_node name, node
+      @nodes.store name, node
+    end
+    
+    # Returns all nodes in this project as a hash. 
+    #
+    # @return [Hash<name,Configuration>] A hash mapping node names to their
+    #   configuration objects.
+    #
+    def nodes
+      evaluate_all unless @nodes.size > 0
+      @nodes
+    end
+    
+    # Evaluates all files in the project.
+    #
+    # Retrieve the found configurations via
+    #   Nodes.find pattern_or_name
+    #
+    # @param dir [String] directory to use as project base directory
+    # @return [void]
+    #
+    def evaluate_all
+      nodes_glob = base_path.join('nodes', '**', '*.rb')
+
+      Dir[nodes_glob].each do |filename|
+        file(filename).evaluate
+      end
+    end
+        
+    class << self
+      def bocuse_path?(path)
+        %w(nodes).all? { |el| 
+          ::File.directory?(::File.join(path, el)) }
+      end
+    end
+    
+  private
+    def chef_cohosted?(base)
+      !self.class.bocuse_path?(base) && 
+        self.class.bocuse_path?(::File.join(base, 'config'))
+    end
+  end
+end

data/lib/bocuse/unit.rb

@@ -0,0 +1,44 @@
+module Bocuse
+  # A configuration unit. 
+  #
+  class Bocuse::Unit
+    # Returns the current configuration, but only during a call to this unit. 
+    attr_reader :current_configuration
+    
+    def initialize(block, context)
+      @block = block
+      @context = context
+    end
+    
+    def call(configuration)
+      @current_configuration = configuration
+      
+      # Fill in the config hash argument if the block cares at all.
+      instance_exec(configuration, &@block)
+    ensure 
+      @current_configuration = nil
+    end
+    
+    # Cook adds to the toplevel recipes of this file's configuration.
+    #
+    def cook recipe
+      current_configuration.recipes << recipe
+    end
+    
+    # Make the given module a helper module for this node. 
+    #
+    def helper_module(mod)
+      extend mod
+    end
+  
+    # Include the given template name.
+    #
+    # Note: This could be pushed to the configuration.
+    #
+    def include_template identifier
+      template_block = @context.template identifier
+
+      template_block.call(current_configuration)
+    end
+  end
+end

data/lib/bocuse/value.rb

@@ -0,0 +1,43 @@
+module Bocuse
+
+  # This is a value object that by default starts out life as not having
+  # decided what exactly it is.
+  #
+  # On first adding another object, it assumes an internal form.
+  #
+  # It will complain if its internal form does not correspond to the assumed
+  # external one, ie. when you want to << something, but it has already
+  # assumed the internal form of a hash (<< does not exist on a hash).
+  #
+  class Value
+    
+    module Empty; def self.empty?; true; end end
+    
+    def initialize internal = Empty
+      @internal = internal
+    end
+    
+    def empty?
+      @internal && @internal.empty?
+    end
+    
+    def []= key, value
+      @internal = {} if empty?
+      @internal[key] = value
+    end
+    
+    def << element
+      @internal = [] if empty?
+      @internal << element
+    end
+    
+    def to_h
+      @internal unless Empty == @internal
+    end
+    
+    def dup
+      Value.new(@internal.dup)
+    end
+  end
+  
+end

data/lib/bocuse.rb

@@ -0,0 +1,7 @@
+require 'multi_json'
+
+require 'bocuse/project'
+require 'bocuse/value'
+require 'bocuse/configuration'
+require 'bocuse/file'
+require 'bocuse/unit'

data/spec/integration/cli_spec.rb

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+require 'multi_json'
+
+describe "CLI:" do
+  describe 'compile NODE_FQDN' do
+    it "parses nodes and outputs a single nodes JSON" do
+      Dir.chdir File.expand_path('../../files/complex', __FILE__)
+      
+      # Explicitly call the current binary.
+      #
+      
+      MultiJson.load(`#{project_path('bin/bocuse')} \
+        compile complex.production.example.com`).should == 
+        {
+          "recipes"=>["nginx", "git", "app::install", "app::deploy"], 
+          "key_location" => 
+            "/Users/kschiess/git/own/bocuse/spec/files/complex/config/nodes/production/key.txt"}
+    end
+  end
+end

data/spec/integration/complex_spec.rb

@@ -0,0 +1,57 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe 'complex example with templates' do
+  let(:project) { Bocuse::Project.new(fixture('complex')) }
+  
+  describe 'hash of node "test.staging.example.com"' do
+    it 'looks right' do
+      configuration = project.evaluate('nodes/staging/complex.rb')
+      
+      configuration.to_h.should == {
+        :user => "root",
+        :users => [
+          {
+            :username => "some_user",
+            :password => "toooootally_secret",
+            :authorized_keys => ["key1", "key2"],
+            :shell => "/bin/someshell",
+            :gid => 1000,
+            :uid => 1000,
+            :sudo => true
+          }
+        ],
+        :webserver => {
+          :domains => ["staging.example.com"],
+          :listen_ip => "1.2.3.4",
+          :ssl_support => true
+        },
+        :server => {
+          :ip => "11.22.33.44",
+          :external_net => 28,
+          :internal_ip => "1.1.1.1",
+          :internal_net => "10",
+          :context => 20
+        },
+        :cache1 => {
+          :address => "1.1.1.1"
+        },
+        :cache2 => {
+          :address => "1.1.1.1"
+        },
+        :empty => true,
+        :recipes => ["nginx", "git", "app::install", "app::deploy"]
+      }
+    end
+  end
+  describe 'hash of node "complex.production.example.com"' do
+    it "contains only recipes that are relevant to the node" do
+      config = project.nodes.
+        find { |name, _| name == 'complex.production.example.com' }.
+        last
+        
+      config.to_h[:recipes].should =~ %w(nginx git app::install app::deploy)
+    end 
+  end
+end

data/spec/integration/helpers_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe 'helpers example' do
+  let(:project) { Bocuse::Project.new(fixture('helpers')) }
+  
+  describe 'loading "node"' do
+    it 'works' do
+      configuration = project.nodes['node']      
+      configuration[:foo].should == 'bar'
+      configuration[:nested][:foo].should == 'bar'
+    end
+  end
+
+end

data/spec/integration/node_finding_spec.rb

@@ -0,0 +1,18 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe 'finding nodes in files/many' do
+  let(:project) { Bocuse::Project.new(fixture('many')) }
+  
+  describe 'loading all nodes' do    
+    it 'works with defaults' do
+      project.should have(4).nodes
+    end
+    it 'works with specific string' do
+      nodes = project.nodes.select { |name, _| 'subfolder1' === name }
+      nodes.size.should == 1
+    end
+  end
+  
+end

data/spec/integration/templates_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe 'Templates' do
+  let(:project) { Bocuse::Project.new(fixture('complex')) }
+
+  describe 'loading' do
+    it 'works' do
+      config = Bocuse::Configuration.new
+      project.template(:users).call(config)
+      
+      config.to_h.should == {
+        :user => "root",
+        :users => [
+          {
+            :username => "some_user",
+            :password => "toooootally_secret",
+            :authorized_keys => ["key1", "key2"],
+            :shell => "/bin/someshell",
+            :gid => 1000,
+            :uid => 1000,
+            :sudo => true
+          }
+        ]
+      }
+    end
+  end
+  
+  describe '#require_ingredients' do
+    it "complains if the current configuration doesn't contain the given keys" 
+  end
+end

data/spec/lib/bocuse/configuration_spec.rb

@@ -0,0 +1,148 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Bocuse::Configuration do
+
+  let(:configuration) { described_class.new }
+
+  describe 'construction' do
+    it "constructs given a hash" do
+      h = { foo: 'bar' }
+      
+      config = described_class.new(h)
+      
+      config.to_h.should == h
+      config.to_h.should_not equal(h)
+    end 
+  end
+  
+  describe 'uninitialized values' do
+    it 'will be ignored' do
+      something = configuration.something
+      
+      configuration.to_h.should == {}
+    end
+  end
+  describe '.something as a value' do
+    it 'returns the right value' do
+      configuration.something.to_h.should == nil # Bocuse::Value::Empty is returned as nil
+    end
+    it 'returns the right value' do
+      configuration.something nil # explicit nil
+      
+      configuration.something.to_h.should == nil
+    end
+    it 'returns the right value' do
+      configuration.something 'value'
+      
+      configuration.something.to_h.should == 'value' # <= This is the tested getter.
+    end
+    it 'is modifiable in place' do
+      something = configuration.something
+      
+      something << "hello"
+      
+      configuration.something.to_h.should == ["hello"]
+    end
+    it 'is modifiable in place' do
+      something = configuration.something
+      
+      something[:key] = "value"
+      
+      configuration.something.to_h.should == { :key => 'value' }
+    end
+    it 'is modifiable in place' do
+      something = configuration.something
+      
+      something[:key] = nil # Explicit nil.
+      
+      configuration.to_h.should == { :something => { :key => nil } }
+    end
+  end
+  describe '.something "value"' do
+    it 'stores the value correctly' do
+      configuration.something 'value'
+      
+      configuration.to_h.should == { :something => 'value' }
+    end
+  end
+  describe '.something do ... end' do
+    it 'stores the value correctly' do
+      configuration.something do
+        key 'value'
+      end
+      
+      configuration.to_h.should == { :something => { :key => 'value' } }
+    end
+  end
+  describe '.something do |param| ... end' do
+    it "doesn't allow implicit access" do
+      expect {
+        configuration.something do |something|
+          foo 'bar'
+        end
+      }.to raise_error
+    end
+    it "represents a configuration, one level deeper" do
+      result = nil
+      configuration.something do |something|
+        result = something
+      end
+
+      result.should be_instance_of(described_class)
+    end   
+    it 'stores the value correctly' do
+      configuration.something do |cfg|
+        cfg.key 'value'
+      end
+      
+      configuration.to_h.should == { :something => { :key => 'value' } }
+    end
+  end
+  describe '#[]' do
+    it 'offers a [] method' do
+      configuration[:something].should == nil
+    end
+    it 'returns the right value' do
+      configuration.something :value
+      
+      configuration[:something].should == :value
+    end
+    it 'returns the right value' do
+      configuration.something do
+        key 'value'
+      end
+      
+      configuration[:something].should == { :key => 'value' }
+    end
+    it 'is not modifiable in place as it is a PORO' do
+      something = configuration[:something]
+      
+      expect { something << "hello" }.to raise_error
+      
+      # configuration.to_h.should == { :something => ["hello"] } # This might be expected by a user.
+    end
+  end
+  describe '#dup' do
+    before(:each) { 
+      configuration.foo do
+        bar []
+      end }
+    let(:dup) { configuration.dup }
+    
+    it "is performed in depth" do
+      configuration[:foo][:bar].should_not equal(dup[:foo][:bar])
+    end
+    it "returns a duplicate" do
+      configuration.to_h.should == dup.to_h
+    end 
+    it "takes a block, allowing modification of the result" do
+      dup = configuration.dup do |cfg|
+        cfg.baz 'this is new'
+      end
+      
+      dup[:baz].should == 'this is new'
+    end 
+  end
+end

data/spec/lib/bocuse/file_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+require 'bocuse/file'
+
+describe Bocuse::File do
+  let(:context) { flexmock('context') }
+  let(:file) { described_class.new('path', context) }
+  
+  before(:each) { 
+    context.
+      should_receive(
+        :register_node, :register_template).by_default 
+  }
+  
+  it "checks that helper inclusion only works for the current file" 
+
+  describe 'node' do
+    it 'works correctly' do
+      configuration = file.node 'name' do |cfg|
+        cfg.something :value
+        cfg.something_else do
+          key 'value'
+        end
+      end
+      
+      configuration.to_h.should == { :something => :value, :something_else => { :key => "value" } }
+    end
+    it "registers the node in the context" do
+      context.should_receive(:register_node).
+        with('name', Bocuse::Configuration).once
+        
+      file.node('name') { }
+    end 
+  end
+  
+  describe 'template' do
+    it 'works correctly' do
+      template = file.template do |cfg|
+        cfg.something :value
+        cfg.something_else do
+          key 'value'
+        end
+      end
+      
+      config = Bocuse::Configuration.new
+      template.call config
+      
+      config.to_h.should == { :something => :value, :something_else => { :key => "value" } }
+    end
+  end
+  
+end

data/spec/lib/bocuse/project_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+require 'bocuse/project'
+
+describe Bocuse::Project do
+  let(:project) { described_class.new(fixture('complex')) }
+
+  describe '#base_path' do
+    it "detects a simple project" do
+      described_class.new(fixture('complex/config')).
+        base_path.should == fixture('complex/config')
+    end
+    it "detects a co-hosted project" do
+      described_class.new(fixture('complex')).
+        base_path.should == fixture('complex/config')
+    end  
+  end
+  describe '#file' do
+    let(:file)    { project.file('nodes/production/complex') }
+    
+    it "returns a Bocuse::Unit instance" do
+      file.should be_instance_of(Bocuse::File)
+    end 
+    it "has the correct expanded path" do
+      file.path.should == 
+        fixture('complex/config/nodes/production/complex')
+    end 
+  end
+  describe '#register_node' do
+    
+  end
+  describe '#register_template / #template' do
+    before(:each) { 
+      base = project.base_path
+      template = base.join('templates', 'foo', 'bar.rb')
+      project.register_template template, :configuration }
+      
+    it "returns the template" do
+      project.template('foo/bar').should == :configuration
+    end 
+  end
+end

data/spec/lib/bocuse/value_spec.rb

@@ -0,0 +1,23 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Bocuse::Value do
+
+  describe 'to_h' do
+    it 'works correctly' do
+      Bocuse::Value.new.to_h.should == nil
+    end
+    it 'works correctly' do
+      value = Bocuse::Value.new
+      value << 1
+      value.to_h.should == [1]
+    end
+    it 'works correctly' do
+      value = Bocuse::Value.new
+      value[:address] = '1.2.3.4'
+      value.to_h.should == { :address => '1.2.3.4' }
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,176 @@
+--- !ruby/object:Gem::Specification
+name: bocuse
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Florian Hanke
+- Kaspar Schiess
+- Jens-Christian Fischer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: flexmock
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.15'
+description: ! "    bocuse teaches chef-solo a few tricks. A strict front-end to chef-solo,
+  \n    it reads a configuration syntax that is under source control and \n    generates
+  JSON for chef-solo.\n\n    This library puts the full power of Ruby at your fingertips
+  when composing\n    configuration for your nodes using templates and helpers. It
+  is the \n    missing link between puppet and chef. \n"
+email:
+- florian.hanke@technologyastronauts.ch
+- kaspar.schiess@technologyastronauts.ch
+- jcf@mobino.com
+executables:
+- bocuse
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bocuse/configuration.rb
+- lib/bocuse/file.rb
+- lib/bocuse/project.rb
+- lib/bocuse/unit.rb
+- lib/bocuse/value.rb
+- lib/bocuse.rb
+- spec/integration/cli_spec.rb
+- spec/integration/complex_spec.rb
+- spec/integration/helpers_spec.rb
+- spec/integration/node_finding_spec.rb
+- spec/integration/templates_spec.rb
+- spec/lib/bocuse/configuration_spec.rb
+- spec/lib/bocuse/file_spec.rb
+- spec/lib/bocuse/project_spec.rb
+- spec/lib/bocuse/value_spec.rb
+- bin/bocuse
+homepage: http://github.com/mobino/bocuse
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A front-end language to chef-solo.
+test_files:
+- spec/integration/cli_spec.rb
+- spec/integration/complex_spec.rb
+- spec/integration/helpers_spec.rb
+- spec/integration/node_finding_spec.rb
+- spec/integration/templates_spec.rb
+- spec/lib/bocuse/configuration_spec.rb
+- spec/lib/bocuse/file_spec.rb
+- spec/lib/bocuse/project_spec.rb
+- spec/lib/bocuse/value_spec.rb
+has_rdoc: