cindy-cm 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 774f6b5df9922b3a6771968f4fb61e05d8b0f3dc
+  data.tar.gz: 647e09f6a7ebb222966f785c49492a525fd92c5f
+SHA512:
+  metadata.gz: 8ecafc4acc58778989dbab0e650d18a70e026ccf985593ca1c1d5adf2003da8c804b90e5bfae9bad47571a90e9260335046f1a264c208fb0c8028052c411f309
+  data.tar.gz: 2a51c783e0ab07d5b95e0448c5b8e7bf6737cc7804dfc3935ef56fe629c29b23b7bab67d55a1c3d7c946c805dc5c563a7acefbe3566f0c85f56257cdd7f534a8

data/Changelog.md

@@ -0,0 +1,7 @@
+### Changes from 0.0.1 to 0.1.0
+
+* configuration format changed (XML => Ruby)
+* shell completion added
+* reload command added
+* alternate configuration file can be specified through environment variable CINDY_CONF (eg, with (ba|k|z)sh: `CINDY_CONF=alternate/path cindy`)
+* all commands which change internal state removed

data/Gemfile

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

data/README.md

@@ -0,0 +1,121 @@
+## Introduction
+
+Tired to modify your configuration files depending on the targeted computer? Turn them out into ERB templates and deploy them in one command.
+
+The purpose is to implement a kind of shell with limited dependencies to automate configuration and deployment on various (Unix) environments.
+
+Dependencies: net-ssh, highline
+
+## Installation
+
+`gem install cindy-cm`
+
+## Usage
+
+* reload                        => force Cindy to reload its configuration file
+* environment (shortcut: env)
+    * list                      => list all known environments
+* template (shortcut: tpl)
+    * list                      => list all known templates
+    * \<name>
+        * environment \<name>
+            * deploy            => install the generated file on the given environment
+            * print             => display output configuration file as it would be deployed on the given environment
+            * details           => list all applicable variables to the given template, their values and scopes
+## Example
+
+Create ~/.cindy as follows:
+```ruby
+# create 2 environments named "production" and "development"
+environment :development, 'file:///'
+environment :production, 'ssh://root@www.xxx.tld/'
+
+# register the template /home/julp/cindy/templates/nginx.conf.tpl (see below) for our nginx configuration
+template :nginx, '/home/julp/cindy/templates/nginx.conf.tpl' do
+    # default variables
+
+    # have_gzip_static will be set to true or false depending on the result of the following command
+    var :have_gzip_static, Command.new('nginx -V 2>&1 >/dev/null | grep -qF -- --with-http_gzip_static_module') # (ba|k)sh
+
+    on :production, '/usr/local/etc/nginx.conf' do
+        # define and/or override some variables for nginx when on our production environment
+        var :server_name, 'www.xxx.tld'
+        var :root, '/home/julp/app/current/public'
+        var :have_gzip_static, Command.new('(nginx -V > /dev/null) |& grep -qF -- --with-http_gzip_static_module') # (t)csh
+    end
+
+    on :development, '/etc/nginx.conf' do
+        # (re)define variables for nginx when in development
+        var :server_name, 'www.xxx.lan'
+        var :root, '/home/julp/app/public'
+    end
+end
+```
+
+And /home/julp/cindy/templates/nginx.conf.tpl as:
+```
+# <%= _install_file_ %>
+
+server {
+    server_name <%= server_name %>;
+    root <%= root %>;
+
+    <% if false %>
+        this content never appears
+    <% end %>
+
+    <% if have_gzip_static %>
+        gzip_static on;
+    <% end %>
+}
+```
+
+Running `cindy template nginx environment production print`, result in:
+```
+# /usr/local/etc/nginx.conf
+
+server {
+    server_name www.xxx.tld;
+    root /home/julp/app/current/public;
+
+        gzip_static on;
+}
+```
+(if we admit that nginx is built, on production environment, with Gzip Precompression module)
+
+After `cindy template nginx environment production deploy`, output of `ls -l /etc/nginx.conf*` is:
+```
+lrwxrwxrwx [...] /usr/local/etc/nginx.conf -> /usr/local/etc/nginx.conf.201502262311
+-rw-r--r-- [...] /usr/local/etc/nginx.conf.201502262209                              # file at previous deployment
+-rw-r--r-- [...] /usr/local/etc/nginx.conf.201502262311                              # current version (1h02m later)
+```
+
+## What is a *command* typed variable?
+
+It is a kind of dynamic variable: instead of hardcoding a value which depends on the remote host, we execute the associated command before each
+time the template is rendered. It is more convenient mainly if this value can change at any time.
+
+The result of the command is a boolean based on its exit status (0 => true, everithing else => false) if the command does not print anything on
+standard output else a string with the content of standard output.
+
+In the example above, `nginx -V 2>&1 >/dev/null | grep -qF -- --with-http_gzip_static_module` is intended to determine if nginx, on the remote
+server, is compiled or not with the gzip_static module.
+
+As you can see in this same example, note that commands may depend on the "remote shell" (redirections in particular) and also on the value of the
+PATH environment variable.
+
+## Predefined variables in templates
+
+* `_install_dir_`: directory in which output file will be deployed (equivalent to `File.dirname _install_file_` but more convenient)
+* `_install_file_`: filename under which the file will be deployed
+
+## Limitations
+
+* `sudo` prompt to ask passwords is not handled: use a passwordless configuration
+* you need to configure your ssh keys in `~/.ssh/config`, eg:
+
+```
+Host www.domain.tld
+User julp
+IdentityFile /path/to/your/private/key
+```

data/Rakefile

@@ -0,0 +1,9 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+    t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/bin/cindy

@@ -0,0 +1,54 @@
+#!/usr/bin/env ruby
+
+require 'cindy/all'
+require 'cindy/cli'
+
+require 'readline'
+require 'shellwords'
+
+cli = Cindy::CLI.new
+
+Readline.completion_append_character = " "
+Readline.completion_proc = proc do |s|
+    args = Shellwords.split Readline.line_buffer[0, Readline.point]
+    args.pop unless Readline.line_buffer.end_with? Readline.completion_append_character
+    (
+        case args
+        when []
+            %w(reload environment template)
+        when %w(environment), %w(env)
+            %w(list)
+        when %w(template), %w(tpl)
+            %w(list) + cli.templates
+        else
+            if 'template' == Cindy::CLI::ARGS_ALIASES[args[0]] && args.length >= 2
+                tplname = args.delete_at 1
+                if 1 == args.length
+                    %w(environment) unless 'list' == tplname
+                elsif 'environment' == Cindy::CLI::ARGS_ALIASES[args[1]]
+                    case args.length
+                    when 2
+                        cli.environments
+                    when 3
+                        %w(deploy print details)
+                    end
+                end
+            end
+        end || []
+    ).select { |v| v.start_with? s }
+end
+
+CINDY_EXCEPTIONS = ObjectSpace.each_object(Class).select { |v| v.ancestors.include?(Exception) && 'Cindy' == v.name.split('::').first }
+
+if ARGV.any?
+    cli.parse ARGV
+else
+    while line = Readline.readline('# ', true)
+        begin
+            cli.parse Shellwords.split(line)
+        rescue => e
+            raise unless CINDY_EXCEPTIONS.include? e.class
+            puts "[ ERR ] #{e}"
+        end
+    end
+end

data/cindy.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cindy/version'
+
+Gem::Specification.new do |s|
+    s.name = 'cindy-cm'
+    s.version = Cindy::VERSION
+    s.authors = ['julp']
+    s.summary = 'Turn out your configuration files into ERB templates and deploy them'
+    s.homepage = 'https://github.com/julp/cindy'
+    s.license = 'BSD'
+    s.files = `git ls-files -z`.split("\x0")
+    s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+    s.executables = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+    #s.require_paths = %w(lib)
+    s.required_ruby_version = '>= 2.0.0'
+    s.add_dependency 'net-ssh'
+    s.add_dependency 'highline'
+    s.add_development_dependency 'bundler'
+    s.add_development_dependency 'rake'
+end

data/lib/cindy/all.rb

@@ -0,0 +1,11 @@
+require 'cindy/version'
+require 'cindy/cindy'
+require 'cindy/command'
+require 'cindy/environment'
+require 'cindy/variable'
+require 'cindy/template'
+require 'cindy/executor/ssh'
+require 'cindy/executor/local'
+
+module Cindy
+end

data/lib/cindy/cindy.rb

@@ -0,0 +1,151 @@
+module Cindy
+
+    class UndefinedEnvironmentError < ::NameError
+    end
+
+    class UndefinedTemplateError < ::NameError
+    end
+
+    class AlreadyExistsError < ::NameError
+    end
+
+    class Cindy
+
+        CONFIGURATION_FILE = File.expand_path '~/.cindy'
+
+        module DSL
+            class TemplateEnvironmentNode
+                def initialize(tpl, envname)
+                    @tpl = tpl
+                    @envname = envname
+                end
+
+                def var(varname, value)
+                    @tpl.set_variable @envname, varname, value
+                end
+
+                alias_method :variable, :var
+            end
+
+            class TemplateNode
+                def initialize(tpl)
+                    @tpl = tpl
+                end
+
+                def var(varname, value)
+                    @tpl.set_variable nil, varname, value
+                end
+
+                alias_method :variable, :var
+
+                def on(envname, file, &block)
+                    @tpl.set_path_for_environment envname, file
+                    TemplateEnvironmentNode.new(@tpl, envname).instance_eval &block if block_given?
+                end
+            end
+
+            class CindyNode
+                def initialize(cindy)
+                    @cindy = cindy
+                end
+
+                def template(tplname, path, &block)
+                    tpl = @cindy.template_add tplname, path
+                    TemplateNode.new(tpl).instance_eval &block
+                    tpl
+                end
+
+                def environment(envname, uri = nil)
+                    @cindy.environment_add envname, uri
+                end
+            end
+        end
+
+        def initialize
+            @environments = {}
+            @templates = {}
+        end
+
+        def self.from_string(string)
+            cindy = Cindy.new
+            DSL::CindyNode.new(cindy).instance_eval string
+            cindy
+        end
+
+        def self.load(filename = nil)
+            @filename = filename || CONFIGURATION_FILE
+            cindy = Cindy.new
+            DSL::CindyNode.new(cindy).instance_eval(File.read(@filename), File.basename(@filename), 0)
+            cindy
+        end
+
+        def to_s
+            (@environments.values.map(&:to_s) + [''] + @templates.values.map(&:to_s)).join("\n")
+        end
+
+        def environments
+            @environments.values
+        end
+
+        def has_environment?(envname)
+            envname = envname.intern
+            @environments.key? envname
+        end
+
+        def environment_add(envname, attributes)
+            envname = envname.intern
+            # assert !@environments.key? envname
+            @environments[envname] = Environment.new(envname, attributes)
+        end
+
+        def templates
+            @templates.values
+        end
+
+        def has_template?(tplname)
+            tplname = tplname.intern
+            @templates.key? tplname
+        end
+
+        def template_add(tplname, file)
+            tplname = tplname.intern
+            # assert !@templates.key? name
+            @templates[tplname] = Template.new File.expand_path(file), tplname
+        end
+
+        def template_environment_print(envname, tplname)
+            envname = envname.intern
+            tplname = tplname.intern
+            check_environment! envname
+            check_template! tplname
+            @templates[tplname].print @environments[envname]
+        end
+
+        def template_environment_deploy(envname, tplname)
+            envname = envname.intern
+            tplname = tplname.intern
+            check_environment! envname
+            check_template! tplname
+            @templates[tplname].deploy @environments[envname]
+        end
+
+        def template_environment_variables(envname, tplname)
+            envname = envname.intern
+            tplname = tplname.intern
+            check_environment! envname
+            check_template! tplname
+            @templates[tplname].list_variables envname
+        end
+
+private
+
+        def check_environment!(envname)
+            raise UndefinedEnvironmentError.new "call to an undefined environment: #{envname}" unless has_environment? envname
+        end
+
+        def check_template!(tplname)
+            raise UndefinedTemplateError.new "call to an undefined template: #{tplname}" unless has_template? tplname
+        end
+
+    end
+end

data/lib/cindy/cli.rb

@@ -0,0 +1,96 @@
+module Cindy
+    class CLI
+        ARGS_ALIASES = Hash.new do |h,k|
+            k
+        end.merge!({ 'tpl' => 'template', 'var' => 'variable', 'env' => 'environment' })
+
+        class InvalidArgumentError < ::ArgumentError
+            def initialize(given, expected)
+                super "invalid argument '#{given}'" + case expected
+                    when String
+                        ", expecting '#{expected}'"
+                    when Array
+                        ", expecting one of: '#{expected.join('\', \'')}'"
+                end
+            end
+        end
+
+#         class TooManyArgumentError < ::ArgumentError
+#             def initialize
+#                 super "too many arguments"
+#             end
+#         end
+# 
+#         class TooFewArgumentError < ::ArgumentError
+#             def initialize
+#                 super "too few arguments"
+#             end
+#         end
+
+        def initialize
+            @cindy = Cindy.load ENV['CINDY_CONF']
+        end
+
+        def environments
+            @cindy.environments.map { |v| v.name.to_s }
+        end
+
+        def templates
+            @cindy.templates.map { |v| v.alias.to_s }
+        end
+
+#         def check_args_count(given, expected, method = :"==")
+#             raise (given > expected ? TooManyArgumentError : TooFewArgumentError).new unless given.send(method, expected)
+#         end
+
+        def parse(args)
+            arg = args.shift
+            case ARGS_ALIASES[arg]
+            when 'reload'
+                # assert 0 == args.length
+                @cindy = Cindy.load ENV['CINDY_CONF']
+            when 'environment'
+                arg = args.shift
+                case arg
+                when 'list'
+                    # assert 0 == args.length
+                    @cindy.environments.each do |env|
+                        puts "- #{env.name}: #{env.uri}"
+                    end
+                end
+            when 'template'
+                arg = args.shift
+                case arg
+                when 'list'
+                    # assert 0 == args.length
+                    @cindy.templates.each do |tpl|
+                        puts "> #{tpl.alias}: #{tpl.file}"
+                    end
+                else
+                    tplname = arg
+                    arg = args.shift
+                    case ARGS_ALIASES[arg]
+                    when 'environment'
+                        # assert args.length >= 2
+                        envname = args.shift
+                        arg = args.shift
+                        case ARGS_ALIASES[arg]
+                        when 'details'
+                            # assert 0 == args.length
+                            @cindy.template_environment_variables(envname, tplname)
+                        when 'deploy', 'print'
+                            # assert 0 == args.length
+                            @cindy.send(:"template_environment_#{arg}", envname, tplname)
+                        else
+                            raise InvalidArgumentError.new arg, %w(details deploy print)
+                        end
+                    else
+                        raise InvalidArgumentError.new arg, %w(environment)
+                    end
+                end
+            else
+                raise InvalidArgumentError.new arg, %w(reload environment template)
+            end
+        end
+    end
+end

data/lib/cindy/command.rb

@@ -0,0 +1,19 @@
+module Cindy
+    class Command
+        def initialize(command)
+            @command = command
+        end
+
+        def to_s
+            @command
+        end
+
+        def inspect
+            "#{self.class.name}.new(#{@command.inspect})"
+        end
+
+        def call(executor)
+            executor.exec(@command, nil, true)
+        end
+    end
+end

data/lib/cindy/environment.rb

@@ -0,0 +1,20 @@
+module Cindy
+    class Environment
+
+        attr_reader :name, :uri
+
+        def initialize(name, uri)
+            @uri = uri
+            @name = name
+        end
+
+        def to_s
+            "environment :#{@name}, #{@uri.inspect}"
+        end
+
+        def update(attributes)
+            @uri = attributes['uri'] if attributes['uri']
+            @name = attributes['name'] if attributes['name']
+        end
+    end
+end

data/lib/cindy/executor/local.rb

@@ -0,0 +1,29 @@
+require 'open3'
+
+module Cindy
+    module Executor
+        class Local
+            def exec(command, stdin_str = nil, status_only = false)
+                exit_status = 1
+                stdout_str = stderr_str = ''
+                Open3.popen3({ 'PATH' => "#{ENV['PATH']}:/bin:/sbin:/usr/bin:/usr/sbin:/usr/local/bin:/usr/local/sbin" }, command) do |stdin, stdout, stderr, wait_thr|
+                    if stdin_str
+                        stdin.write stdin_str
+                        stdin.close
+                    end
+                    stdout_str = stdout.read
+                    stderr_str = stderr.read
+                    exit_status = wait_thr.value
+                end
+# puts [ command, stderr_str, exit_status ].inspect
+                raise Exception.new if 0 != exit_status && !stderr_str.empty?
+                return nil if status_only && 0 != exit_status
+                stdout_str.chomp
+            end
+
+            def close
+                # NOP
+            end
+        end
+    end
+end

data/lib/cindy/executor/ssh.rb

@@ -0,0 +1,43 @@
+require 'net/ssh'
+
+module Cindy
+    module Executor
+        class SSH
+            def initialize(cnx)
+                @cnx = cnx
+            end
+
+            def exec(command, stdin_str = nil, status_only = false)
+                exit_status = 1
+#                 if stdin_str
+                    stdout_str = stderr_str = ''
+                    @cnx.open_channel do |channel|
+                        channel.exec(command) do |ch, success|
+                            channel.on_data do |ch, data|
+                                stdout_str += data
+                            end
+                            channel.on_extended_data do |ch, type, data|
+                                stderr_str += data
+                            end
+                            channel.on_request 'exit-status' do |ch, data|
+                                exit_status = data.read_long
+                            end
+                            channel.send_data stdin_str if stdin_str
+                            channel.eof!
+                        end
+                    end
+                    @cnx.loop
+#                 else
+#                     result = @cnx.exec!(command)
+#                     result.chomp if result.respond_to? :chomp # as result can be nil <=> result.chomp if result <=> result.try? :chomp (rails way)
+#                 end
+                return nil if status_only && 0 != exit_status
+                stdout_str.chomp
+            end
+
+            def close
+                @cnx.close
+            end
+        end
+    end
+end

data/lib/cindy/template.rb

@@ -0,0 +1,130 @@
+require 'erb'
+require 'uri'
+require 'ostruct'
+
+module Cindy
+    class Template
+
+        attr_reader :file, :alias, :paths, :defvars, :envvars
+
+        def initialize(file, name)
+            @file = file # local template filename
+            @alias = name
+            @paths = {}   # remote filenames (<environment name> => <filename>)
+            @defvars = {} # default/global variables
+            @envvars = {} # environment specific variables
+        end
+
+        IDENT_STRING = ' ' * 4
+
+        def to_s
+            ret = ["template :#{@alias}, #{@file.inspect} do"]
+            @defvars.each_pair do |k,v|
+                ret << "#{IDENT_STRING * 1}var :#{k}, #{v.inspect}"
+            end
+            @paths.each_pair do |ke,ve|
+               ret << "#{IDENT_STRING * 1}on :#{ke}, #{ve.inspect} do"
+               @envvars[ke].each_pair do |kv,vv|
+                   ret << "#{IDENT_STRING * 2}var :#{kv}, #{vv.inspect}"
+               end
+               ret << "#{IDENT_STRING * 1}end"
+            end
+            ret << "end"
+            ret << ''
+            ret.join "\n"
+        end
+
+        def print(env)
+            puts render(env)
+        end
+
+        def deploy(env)
+            executor = executor_for_env env
+            remote_filename = @paths[env.name]
+            sudo = ''
+            sudo = 'sudo ' unless 0 == executor.exec('id -u').to_i
+            suffix = executor.exec('date \'+%Y%m%d%H%M\'') # use remote - not local - time machine
+            executor.exec("[ -e \"#{remote_filename}\" ] && [ ! -h \"#{remote_filename}\" ] && #{sudo} mv -i \"#{remote_filename}\" \"#{remote_filename}.pre\"")
+            executor.exec("#{sudo} tee #{remote_filename}.#{suffix} > /dev/null", render(env, executor))
+            executor.exec("#{sudo} ln -snf \"#{remote_filename}.#{suffix}\" \"#{remote_filename}\"")
+            executor.close
+        end
+
+#         def variables
+#             (@defvars.keys + @envvars.collect { |v| v[1].keys }.flatten).uniq
+#         end
+
+        def list_variables(envname)
+            @defvars.merge(@envvars[envname]).each_pair do |k,v|
+                puts "- #{k}#{' (default)' unless @envvars[envname].key? k } = #{v} (#{v.class.name})"
+            end
+        end
+
+#         def unset_variable(varname)
+#             @defvars.delete varname
+#             @envvars.each_value do |h|
+#                 h.delete varname
+#             end
+#         end
+
+#         def rename_variable(oldvarname, newvarname)
+#             @defvars[newvarname] = value if value = @defvars.delete(oldvarname)
+#             @envvars.each_value do |h|
+#                 h[newvarname] = value if value = h.delete(oldvarname)
+#             end
+#         end
+
+        def set_variable(envname, varname, value)
+            envname = envname.intern if envname
+            varname = varname.intern
+            STDERR.puts "[ WARN ] non standard variable name found" unless varname =~ /\A[a-z][a-z0-9_]*\z/
+            if envname
+                @envvars[envname][varname] = value
+            else
+                @defvars[varname] = value
+            end
+        end
+
+        def set_path_for_environment(envname, path)
+            envname = envname.intern
+            @paths[envname] = path
+            @envvars[envname] ||= {}
+        end
+
+private
+
+        def executor_for_env(env)
+            uri = URI.parse(env.uri)
+            case uri.scheme
+                when nil, 'file'
+                    Executor::Local.new
+                when 'ssh'
+                    Executor::SSH.new Net::SSH.start(uri.host, uri.user)
+                else
+                    raise Exception.new 'Unexpected protocol'
+            end
+        end
+
+        def render(env, executor = nil)
+            close_executor = executor.nil?
+            executor ||= executor_for_env(env)
+#             shell = executor.exec('ps -p $$ -ocomm=')
+            vars = Hash[
+                @defvars.merge(@envvars[env.name]).map do |k, v|
+                    if v.respond_to? :call
+                        [ k, v.call(executor) ]
+                    else
+                        [ k, v ]
+                    end
+                end
+            ]
+            # ||= to not overwrite a previously user defined variable with the same name
+            vars['_install_file_'] ||= @paths[env.name]
+            vars['_install_dir_'] ||= File.dirname @paths[env.name]
+            erb = ERB.new(File.read(@file), 0, '-')
+            executor.close if close_executor
+            erb.result(OpenStruct.new(vars).instance_eval { binding })
+        end
+
+    end
+end

data/lib/cindy/variable.rb

@@ -0,0 +1,28 @@
+module Cindy
+    class Variable
+        TAG_NAME = self.name.split('::').last.downcase
+
+        class << self
+            def parse_boolean(string)
+                'true' == string
+            end
+
+            def parse_string(string)
+                string
+            end
+
+            def parse_command(string)
+                Command.new string
+            end
+
+            def parse_int(string)
+                string.to_i
+            end
+        end
+
+        TYPES = public_methods.inject([]) do |ret,v|
+            ret << $' if v =~ /\Aparse_/
+            ret
+        end
+    end
+end

data/lib/cindy/version.rb

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

data/test/minitest_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'cindy/all'
+
+require 'minitest/autorun'

data/test/test_cindy.rb

@@ -0,0 +1,9 @@
+require 'minitest_helper'
+
+class CindyTest < Minitest::Test
+
+    def test_true
+        assert true
+    end
+
+end

data/test/test_dsl.rb

@@ -0,0 +1,40 @@
+require 'minitest_helper'
+
+class DSLTest < Minitest::Test
+
+    def test_on_without_block
+        cindy = Cindy::Cindy.from_string <<-EOS
+            environment :foo
+
+            template :bar, 'abc' do
+                on :foo, 'def'
+            end
+        EOS
+
+        tpl = cindy.templates[0]
+        assert_equal tpl.alias, :bar
+        assert_equal tpl.paths[:foo], 'def'
+    end
+
+    def test_string_equivalent_to_symbol
+        cindy = Cindy::Cindy.from_string <<-EOS
+            environment 'foo'
+
+            template 'bar', 'abc' do
+                on 'foo', 'def' do
+                    var 'x', 'y'
+                end
+            end
+        EOS
+
+        assert cindy.has_environment? :foo
+        assert cindy.has_environment? 'foo'
+        assert cindy.has_template? :bar
+        assert cindy.has_template? 'bar'
+        tpl = cindy.templates[0]
+        assert tpl.envvars.key? :foo
+#         assert tpl.has_variable? :x
+#         assert tpl.has_variable? 'x'
+    end
+
+end

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: cindy-cm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- julp
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-ssh
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: 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: 
+email: 
+executables:
+- cindy
+extensions: []
+extra_rdoc_files: []
+files:
+- Changelog.md
+- Gemfile
+- README.md
+- Rakefile
+- bin/cindy
+- cindy.gemspec
+- lib/cindy/all.rb
+- lib/cindy/cindy.rb
+- lib/cindy/cli.rb
+- lib/cindy/command.rb
+- lib/cindy/environment.rb
+- lib/cindy/executor/local.rb
+- lib/cindy/executor/ssh.rb
+- lib/cindy/template.rb
+- lib/cindy/variable.rb
+- lib/cindy/version.rb
+- test/minitest_helper.rb
+- test/test_cindy.rb
+- test/test_dsl.rb
+homepage: https://github.com/julp/cindy
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Turn out your configuration files into ERB templates and deploy them
+test_files: []