org-converge 0.0.1

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "org-ruby"]
+	path = org-ruby
+	url = https://github.com/wallyqs/org-ruby

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+group :development, :test do 
+  gem 'rake'
+  gem 'rspec'
+end
+
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Waldemar Quevedo
+
+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.org

@@ -0,0 +1,109 @@
+# -*- mode: org; mode: auto-fill; -*-
+#+TITLE:	Org Converge
+#+STARTUP:	showeverything
+
+* Description
+
+  This attempts to be an experiment of using Org mode syntax to
+  describe, configure and setting up something, borrowing some ideas
+  of what is possible to do with tools like =chef-solo=, =puppet=,
+  =ansible=, etc...
+
+* Motivation
+
+  The Org babel syntax has proven to be flexible enough to produce
+  /reproducible research/ papers. Then, I believe that configuring and setting up
+  a server for example is something that could be also be done using
+  the same syntax, given that /converging/ the configuration is something
+  that one ought to be able to reproduce.
+
+* Usage
+
+: org-converge path/to/setup-file.org
+
+* How it works
+
+  Org Converge uses an liberally extended version of Org Babel
+  features in order to give support for converging the configuration
+  of a server.
+
+  For example, using Org Babel and macros we can easily spread config
+  files on a server by writing the following on a ~server.org~ file.
+
+  #+begin_src org
+    ,#+MACRO: multitenancy_enabled true
+    ,#+MACRO: status_port true
+    
+    ,#+begin_src yaml :tangle /etc/component.yml
+    multitenant: false
+    status_port: 10004
+    ,#+end_src
+  #+end_src
+
+  And then configure it by running it as follows, (considering we have
+  the correct permissions): 
+
+  #+begin_src sh
+  org-converge server.org
+  #+end_src
+
+  This leverages on the syntax already provided by Org Babel, but one
+  difference here is that if we run it once again without changes...
+
+  #+begin_src sh
+  org-converge server.org
+  #+end_src
+  
+  ...it would finish soon since the configuration has already converged.
+
+  Next, let's say that we no only one want to set the configured templates,
+  but that we also want to install some packages. In that case, we
+  should be able to do the following:
+
+  #+begin_src org
+    ,#+macro: multitenancy_enabled true
+    ,#+macro: status_port  true
+    ,#+macro: project_path path/to/project
+
+    ,* Configuring the component
+
+    ,#+begin_src yaml :tangle /etc/component.yml
+    multitenant: false
+    status_port: 10004
+    ,#+end_src  
+
+    ,* Installing the dependencies
+
+    Need the following so that ~bundle install~ can compile 
+    the native extensions correctly.
+
+    ,#+begin_src sh
+    apt-get install build-essentials -y
+    ,#+end_src
+
+    Then the following should work:
+
+    ,#+begin_src sh
+    cd {{{project_path}}}
+    bundle install
+    ,#+end_src
+  #+end_src
+
+  As long as the repo has been already checked out in the directory, 
+  the previous example will succeed. 
+
+  #+begin_src sh
+  org-converge server.org
+  #+end_src
+
+  If that is not the case, then org-converge will fail 
+  and pickup from that last step.
+
+  More practical examples can be found [[here]], more will be added as
+  long as dogfooding from this goes well.
+
+* Contributing
+
+The project is in very early development at this moment, but if you
+feel that it is interesting enough, please create a ticket so start
+the discussion.

data/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+  spec.rspec_opts = ['--format', 'documentation', '--colour']
+end

data/TODO

@@ -0,0 +1,167 @@
+# -*- mode: org; mode: auto-fill; -*-
+#+TODO:    TODO | DONE CANCELED 
+#+startup: showeverything
+
+* [0/2] 0.0.3 version
+
+- [ ] Macros can be loaded and applied to the configuration
+- [ ] Actually support converging and idempotency
+  + Do not do an operation unless it is required
+  + Abort in case there was a failure in executing the script.
+
+* [0/2] 0.0.2 version
+
+Run the code blocks!
+
+- [ ] Code blocks are executed by default after tangling
+  Only when :shebang exists as an argument
+- [ ] Display how the run would look like
+  : org-converge setupfile.org --dry-run
+
+* [3/3] 0.0.1 version
+
+Need some basic functionality of what Org babel offers first.
+
+- [X] Display files that were captured with command
+  : org-converge setupfile.org --showfiles
+- [X] ~:tangle~ puts the files in the correct path
+- [X] ~--tangle~ flag
+- [X] Support a root dir for when not running relative to the directory
+
+* [2/14] Ideas
+** CANCELED We don't need to create the directories in most cases
+
+Something like this is not required because the ~:tangle~ blocks
+would create the necessary directories behind the scenes.
+
+#+begin_src org
+  ,We need to prepare some directories for the configuration:
+  
+  ,#+begin_src converge
+  ,mkdir -p etc/fluentd/config
+  ,#+end_src
+#+end_src
+
+** CANCELED How to set the permissions from the directory from the file that is being tangled when it does not exists?
+
+By default, this would be 0644, but we also need to specify the
+user:group of it so the syntax would have to be:
+
+#+begin_src conf :tangle etc/something/config/path :chmod 0664 :user td-agent :group
+hmm dont't like this syntax for folders
+#+end_src
+
+Let's keep it simple and just use a babel block that shells out to create the directories
+until I can think of something better.
+
+** TODO By default, it should use current dir for tangling
+** TODO Converging: Only do an operation when it didn't finish
+
+Hence the name of the project
+
+** TODO For now we keep the indentation of the code blocks
+
+The indentatin of the ~#+begin_src~ should always 
+be at the beginning of the file, not at the indentation
+level from when the file was written in Org mode.
+
+** TODO We should have a whitelist of languages that can be executed and ignore everything
+
+Under which heuristics or configuration should we decide which will be the 
+binary that should be used to execute the block? Specify with shebang?
+
+- For now, unless shebang is specified it will be executed.
+  Then in the scripts buffer used ~index::shebang~ as a key.
+
+** TODO Setting permissions from a tangled file
+
+It should be possible to tangle the files this way:
+
+#+begin_src conf :tangle etc/something/config/path :chmod 0664 :user td-agent :group td-agent
+<source>
+</source>
+#+end_src
+
+** TODO Adopting the ~#+SETUPFILE~ for loading a config that is done JSON or YAML
+
+It seems that there is support for a ~#+SETUPFILE~
+
+** TODO Something more flexible than macros:
+
+One example of syntax that we could use instead of macros:
+
+#+begin_src yaml :session
+fluentd:
+  port: 4224
+  path: here.log
+#+end_src
+
+But need to 
+
+** TODO Using the :tags: to setup the things to run right away
+
+Kind of like the chef-solo runlist, a headline like this...
+
+#+begin_src org
+  ,* Everything in its right place                                      :config:
+  
+  ,#+begin_src conf :tangle etc/this.yml
+  ,hello: "world"
+  ,#+end_src
+#+end_src
+
+...could be called like this
+
+#+begin_src sh
+org-converge fluentd.org -t config
+#+end_src
+
+** TODO Managing dependencies: could be handled with ~#+include~ directives
+
+One idea is that it would be useful to compile different manuals
+that are dependent among each other. 
+
+For example, the centralized logs server would require fluentd.
+We should be able to express that dependency somehow:
+
+#+begin_src org :tangle logserver.org
+  ,#+include: "fluentd.org"
+  
+  ,* Setup the centralized logserver                                     :setup:
+  
+  ,Once the fluentd.org has been converged, we can build upon this and
+  ,override the original config to make it particular for this logserver
+#+end_src
+
+# But one problem, is that once I have included something, sometimes we
+# will want "reopen" the previous manuals?
+
+** TODO Loading all the Org mode files first and then setup only one part
+
+So maybe, each one of these tags would have to be namespaces under the
+name of the file:
+
+: org-converge logserver.org -t "fluentd::setup, fluentd::config, logserver::setup"
+
+** TODO Choosing a templating language: default for now is mustache
+
+We could implement the macro systems, but it seems that it may not be
+strong enough for providing with all the cases we may run into.
+
+** TODO Chaining resources with ~#+NAME:~ directives and ~:notify~ argument
+
+One idea is to be able to notify resources by naming the code blocks.
+
+Example: Here first the td-agent service would try to start,
+and if it succeeds, then it would execute the script defined in the
+~announce-availability~ resource.
+
+#+name: td-agent-start
+#+begin_src sh :notify announce-availability
+sudo service td-agent start
+#+end_src
+
+#+name: announce-availability
+#+begin_src sh
+sudo /etc/register-to-balancer
+#+end_src

data/bin/org-converge

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+# -*- mode: ruby -*-
+require 'docopt'
+require 'org-converge'
+
+doc = <<OPTIONS
+
+org-converge: A light configuration management tool for Org mode
+
+Usage:
+  org-converge <org_file> [--tangle] [--showfiles] [--log=<logfile>] [--root-dir=<root_dir>]
+
+Options:
+
+  -h --help               Show this screen.
+
+OPTIONS
+
+begin
+  require "pp"
+  cmd = Docopt::docopt(doc)
+rescue Docopt::Exit => e
+  puts e.message
+end
+
+exit 1 unless cmd
+
+o = OrgConverge::Command.new(cmd)
+o.execute!

data/examples/apt-get-install/setup.org

@@ -0,0 +1,11 @@
+#+TITLE: Installing some packages
+
+* Just install some packages for example
+
+#+begin_src sh
+sudo apt-get install build-essentials
+#+end_src
+
+Should be able to be run with something like:
+
+: org-converge examples/apt-get-install.org

data/examples/fluentd/setup.org

@@ -0,0 +1,50 @@
+# -*- mode: org; auto-fill-mode -*-
+#+TITLE:	Setting up Fluentd
+#+startup:	showeverything 
+
+* Introduction
+
+The following will setup and configure ~fluentd~ on a node.
+
+* Settings
+
+These can be defined with Org mode macro directives, but thinking on
+other ways to do it as well.
+
+#+macro: fluentd_port     4224
+#+macro: fluentd_filepath here.log
+
+* Setup 							      :setup:
+
+Fluentd can be installed either as a package from treasure data or
+just as a gem. In this example, we only install as a gem:
+
+#+begin_src sh
+gem install fluentd
+#+end_src
+
+* Configuration 						     :config:
+
+Set Fluentd to listen on the ~fluentd_port~ port and to write logs
+to ~fluentd_filepath~.
+
+#+begin_src conf :tangle etc/fluentd.conf
+<source>
+  type forward
+  port {{{ fluentd_port }}}
+</source>
+
+<match **>
+  type file
+  path {{{ fluentd_filepath }}}
+</match>
+#+end_src
+
+# A script to daemonize the process could be written here, as well as
+# any /etc/default/* required settings...
+
+* Start which was configured here 				      :start:
+
+#+begin_src sh
+fluentd -c etc/fluentd.conf -vvv
+#+end_src

data/examples/macro-config/setup.org

@@ -0,0 +1,14 @@
+#+TITLE: Using macros for configuration
+
+#+macro: hello world
+#+macro: application my-application
+
+Hello {{{hello}}}, this will setup something for {{{application}}}.
+
+#+begin_src sh :results output
+echo "Hello for {{{application}}}" > /tmp/hello
+#+end_src
+
+#+RESULTS:
+: Hello for {{{application}}}
+

data/examples/simple/setup.org

@@ -0,0 +1,51 @@
+#+TITLE: Simple example
+
+It does not get more simple than this:
+
+- First, configure something:
+
+  #+begin_src conf :tangle /tmp/my-conf
+<source>
+  bind 0.0.0.0
+
+
+
+  port 4224
+
+
+
+
+</source>
+
+<match **>
+  type file
+
+
+  path /var/tmp/a.log
+</match>
+  #+end_src
+
+- And then run something
+
+  #+begin_src sh
+echo "1) Hello world" > /tmp/my-echo
+echo "2) Hello world" > /tmp/my-echo
+echo "3) Hello world" > /tmp/my-echo
+  #+end_src
+
+- Then configure something again
+
+  #+begin_src sh
+echo "4) Hello world" >> /tmp/my-echo
+echo "5) Hello world" >> /tmp/my-echo
+echo "6) Hello world" >> /tmp/my-echo
+
+echo "7) Hello world" >> /tmp/my-echo
+  #+end_src
+
+- And send something to babel once again
+
+  #+begin_src conf :tangle /tmp/hello-conf.yml
+status_port: 9090
+no_tab_after_that: true
+  #+end_src

data/lib/org-converge/babel.rb

@@ -0,0 +1,60 @@
+#
+# Class with util methods that try to reimplement some of
+# the functionality provided by Org Babel from Emacs
+#
+require 'fileutils'
+
+module Orgmode
+  class Babel
+    attr_reader :ob     # Babel Output Buffer with parsed contents
+    attr_reader :logger
+
+    def initialize(babel_output_buffer, options={})
+      @ob = babel_output_buffer
+      @options = options
+      @logger  = options[:logger] || Logger.new(STDOUT)
+      @root_dir = options[:root_dir]
+    end
+
+    # TODO: should be able to tangle relatively to a dir
+    def tangle!
+      logger.info "Tangling #{ob.tangle.keys.count} files..."
+
+      ob.tangle.each do |tangle_file, lines|
+        file = if @root_dir
+                 File.join(@root_dir, tangle_file)
+               else
+                 tangle_file
+               end
+
+        logger.info "BEGIN(#{tangle_file}): Tangling #{lines.count} lines at '#{file}'"
+        # TODO: should abort when the directory does not exists
+        # TODO: should abort when the directory failed because of permissions
+        if not Dir.exists?(File.dirname(file))
+          logger.error "Could not tangle #{file} because directory does not exists!"
+          raise TangleError
+        end
+
+        if File.exists?(file)
+          logger.warn "File already exists at #{file}, it will be overwritten"
+        end
+
+        begin
+          File.open(file, 'w') do |f|
+            lines.each do |line|
+              f.puts line
+            end
+          end
+        rescue => e
+          logger.error "Problem while writing to '#{file}': #{e}"
+          raise TangleError
+        end
+        logger.info "END(#{file}): done."
+      end
+
+      logger.info "Tangling succeeded!".green
+    end
+
+    class TangleError < Exception; end
+  end
+end

data/lib/org-converge/babel_output_buffer.rb

@@ -0,0 +1,82 @@
+module Orgmode
+  class BabelOutputBuffer < OutputBuffer
+    attr_reader :tangle
+    attr_reader :scripts
+
+    def initialize(output)
+      super(output)
+
+      # ~@tangle~ files are put in the right path
+      # : @tangle['/path'] = [Lines]
+      @tangle  = Hash.new {|h,k| h[k] = []}
+
+      # ~@scripts~ are tangled in order and ran
+      # : @scripts = [text, text, ...]
+      @scripts = []
+
+      @buffer = ''
+    end
+
+    def push_mode(mode, indent)
+      super(mode, indent)
+    end
+
+    def pop_mode(mode = nil)
+      m = super(mode)
+      @list_indent_stack.pop
+      m
+    end
+
+    def insert(line)
+      # We try to get the lang from #+BEGIN_SRC blocks
+      if line.begin_block?
+        @block_lang = line.block_lang
+        if line.block_header_arguments[':tangle']
+          @current_tangle = line.block_header_arguments[':tangle']
+        else
+          @shebang = line.block_header_arguments[':shebang']
+          @current_tangle = nil
+          @buffer = ''
+        end
+      end
+
+      case
+      when (line.assigned_paragraph_type == :code and @current_tangle)
+        # Need to keep track of the current tangle to buffer its lines
+        @tangle[@current_tangle] << line
+      when (line.assigned_paragraph_type == :code)
+        # When a tangle is not going on, it means that the lines would go
+        # into a runnable script
+        @buffer << line.output_text << "\n"
+      when (!@buffer.empty? and not (line.begin_block? or line.assigned_paragraph_type == :code))
+        # Fix indentation and remove pre fix commas from Org mode before flushing
+        strip_code_block!
+        @scripts << @buffer
+        @buffer = ''
+      end
+
+      @output_type = line.assigned_paragraph_type || line.paragraph_type
+    end
+
+    # Flushing is a bit different since we still need the metadata
+    # from lines in order to flush to correct tangle buffer
+    # TODO: Should be in the parent class as well...
+    def flush!; false; end
+
+    # TODO: This should be in the parent class....
+    def output_footnotes!; false; end
+
+    def strip_code_block!
+      if @code_block_indent and @code_block_indent > 0
+        strip_regexp = Regexp.new("^" + " " * @code_block_indent)
+        @buffer.gsub!(strip_regexp, "")
+      end
+      @code_block_indent = nil
+
+      # Strip proctective commas generated by Org mode (C-c ')
+      @buffer.gsub! /^(\s*)(,)(\s*)([*]|#\+)/ do |match|
+        "#{$1}#{$3}#{$4}"
+      end
+    end
+  end
+end

data/lib/org-converge/command.rb

@@ -0,0 +1,58 @@
+module OrgConverge
+  class Command
+    attr_reader :dotorg
+    attr_reader :logger
+    attr_reader :ob
+
+    def initialize(options)
+      @options = options
+      @dotorg  = options['<org_file>']
+      @logger  = Logger.new(options['--log'] || STDOUT)
+      @root_dir = options['--root-dir']
+      @ob = Orgmode::Parser.new(File.read(dotorg)).babelize
+    end
+
+    def execute!
+      case
+      when @options['--showfiles']
+
+        showfiles
+      when @options['--tangle']
+        tangle!
+      else
+        converge!
+      end
+
+      true
+    rescue => e
+      false
+    end
+
+    def converge!
+      tangle!
+    end
+
+    def tangle!
+      begin
+        babel = Orgmode::Babel.new(ob, { :logger => logger, :root_dir => @root_dir })
+        results = babel.tangle!
+      rescue Orgmode::Babel::TangleError
+        logger.error "Cannot converge because there were errors during tangle step".red
+      end
+    end
+
+    def showfiles
+      ob.tangle.each do |file, lines|
+        puts "---------- #{file} --------------".green
+        lines.each do |line|
+          puts line
+        end
+      end
+
+      ob.scripts.each_with_index do |script, index|
+        puts "---------- script: #{index} --------------".green
+        puts script
+      end
+    end
+  end
+end

data/lib/org-converge/version.rb

@@ -0,0 +1,3 @@
+module OrgConverge
+  VERSION = "0.0.1"
+end

data/lib/org-converge.rb

@@ -0,0 +1,37 @@
+require 'org-ruby'
+require 'org-converge/babel_output_buffer'
+require 'org-converge/babel'
+require 'org-converge/command'
+require 'org-converge/version'
+
+module Orgmode
+  class Parser
+
+    # This would return a babel output buffer which has the methods
+    # needed in order to be able to tangle the files
+    def babelize
+      # Feed the parsed contens and create the necessary internal structures
+      # for doing babel like features
+      output = ''
+      ob = BabelOutputBuffer.new(output)
+      translate(@header_lines, ob)
+      @headlines.each do |headline|
+        translate(headline.body_lines, ob)
+      end
+
+      ob
+    end
+  end
+end
+
+module StringWithColors
+  def red;    colorize("\e[0m\e[31m");  end
+  def green;  colorize("\e[0m\e[32m");  end
+  def yellow; colorize("\e[0m\e[33m");  end
+  def bold;   colorize("\e[0m\e[1m");   end
+  def colorize(color_code); "#{color_code}#{self}\e[0m"; end
+end
+
+class String
+  include StringWithColors
+end

data/org-converge.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/org-converge/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Waldemar Quevedo"]
+  gem.email         = ["waldemar.quevedo@gmail.com"]
+  gem.description   = %q{A light configuration management tool for Org mode}
+  gem.summary       = %q{Provides an 'org-converge' command which can be used for tangling and running Org mode code blocks}
+  gem.homepage      = "https://github.com/wallyqs/org-converge"
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "org-converge"
+  gem.require_paths = ["lib"]
+  gem.version       = OrgConverge::VERSION
+  gem.add_runtime_dependency('docopt', '0.5.0')
+  gem.add_runtime_dependency('org-ruby', '~> 0.9.2')
+end

data/spec/converge_examples/basic_tangle/conf.yml.expected

@@ -0,0 +1,7 @@
+bind: 0.0.0.0
+port: 2442
+
+mysql:
+  db: users
+  host: somewhere-example.local
+  password: 111111111

data/spec/converge_examples/basic_tangle/setup.org

@@ -0,0 +1,18 @@
+#+TITLE: Relative Tangle
+
+In this test, tangles files will exist relative to this file.
+
+#+begin_src yaml :tangle conf.yml
+bind: 0.0.0.0
+port: 2442
+#+end_src
+
+e.g. including the connections to the database in the same file:
+
+#+begin_src yaml :tangle conf.yml
+
+mysql:
+  db: users
+  host: somewhere-example.local
+  password: 111111111
+#+end_src

data/spec/converge_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe OrgConverge::Command do
+  context "when converging 'basic_tangle'" do
+    example_dir = File.join(EXAMPLES_DIR, 'basic_tangle')
+
+    it "should tangle a 'conf.yml' file" do
+      setup_file = File.join(example_dir, 'setup.org')
+      o = OrgConverge::Command.new({ 
+                                     '<org_file>' => setup_file,
+                                     '--root-dir' => example_dir
+                                   })
+      success = o.execute!
+      success.should == true
+
+      expected_contents = File.read(File.join(example_dir, 'conf.yml.expected'))
+
+      resulting_file = File.join(example_dir, 'conf.yml')
+      File.exists?(resulting_file).should == true
+
+      result = File.read(resulting_file)
+
+      result.should == expected_contents
+    end
+  end
+end
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'org-converge'
+require 'fileutils'
+
+RESULTS_DIR  = File.expand_path("tmp/#{Time.now.strftime("test_%s")}", File.dirname(__FILE__))
+SPEC_DIR     = File.dirname(File.expand_path('.', __FILE__))
+EXAMPLES_DIR = File.join(SPEC_DIR, 'converge_examples')

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: org-converge
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Waldemar Quevedo
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: docopt
+  requirement: &70317759431040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *70317759431040
+- !ruby/object:Gem::Dependency
+  name: org-ruby
+  requirement: &70317759430520 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70317759430520
+description: A light configuration management tool for Org mode
+email:
+- waldemar.quevedo@gmail.com
+executables:
+- org-converge
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitmodules
+- Gemfile
+- LICENSE
+- README.org
+- Rakefile
+- TODO
+- bin/org-converge
+- examples/apt-get-install/setup.org
+- examples/fluentd/setup.org
+- examples/macro-config/setup.org
+- examples/simple/setup.org
+- lib/org-converge.rb
+- lib/org-converge/babel.rb
+- lib/org-converge/babel_output_buffer.rb
+- lib/org-converge/command.rb
+- lib/org-converge/version.rb
+- org-converge.gemspec
+- spec/converge_examples/basic_tangle/conf.yml.expected
+- spec/converge_examples/basic_tangle/setup.org
+- spec/converge_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/wallyqs/org-converge
+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.10
+signing_key: 
+specification_version: 3
+summary: Provides an 'org-converge' command which can be used for tangling and running
+  Org mode code blocks
+test_files:
+- spec/converge_examples/basic_tangle/conf.yml.expected
+- spec/converge_examples/basic_tangle/setup.org
+- spec/converge_spec.rb
+- spec/spec_helper.rb