lono 0.2.4 → 0.3.0

data/README.md

@@ -22,9 +22,9 @@ This sets up a starter lono project with example templates.
 $ lono generate
 </pre>
 
-This generates the templates that have been defined in config folder of the lono project.
+This generates the templates that have been defined in the config folder of the lono project.
 
-The one of starter lono config files looks like this:
+The starter lono template project config files looks like [this](lib/starter_project/config/lono.rb) and [this](lib/starter_project/config/lono/api.rb).  Here's a snippet from one of the config files with the template call:
 
 ```ruby
 template "prod-api-app.json" do
@@ -54,7 +54,7 @@ The corresponding ERB template example file is [here](lib/starter_project/templa
 
 ## Template helper methods
 
-There are helper methods that available in templates.
+There are helper methods that are available in templates.
 
 * partial - can be use to embed other files in a template.  The partial should be placed in the templates/partial folder of the project.  So:
   * partial('launch_config.json.erb') -> templates/partial/launch_config.json.erb
@@ -75,11 +75,18 @@ Here's how you would call it in the template.
   }
 ```
 
-Within a user_data script you can call another helper method called ref.
+Within a user_data script you can user helper methods that correspond to Cloud Formation [Instrinic Functions](http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/concept-intrinsic-functions.html).  Currently, base64, find_in_map, get_att, get_azs, join, and ref are supported.  Examples of their usage are found in the starter [project template](https://github.com/tongueroo/lono/blob/master/lib/starter_project/templates/user_data/db.sh.erb)
 
-* ref - can be use to reference other parameter or resource value within the cloud formation template.  An [example](lib/starter_project/templates/user_data/db.sh.erb) is in the [starter_project](lib/starter_project).
+## Converting UserData scripts
 
-* find_in_map - can be use to call the find_in_map function within the cloud formation template.  An [example](lib/starter_project/templates/user_data/db.sh.erb) is in the [starter_project](lib/starter_project).
+You can convert UserData scripts in existing Cloud Formation Templates to a starter bash script via:
+
+<pre>
+$ lono bashify cloud_formation_template.json
+$ lono bash cloud_formation_template.json # shorthand
+</pre>
+
+This is useful if you want to take an existing [Cloud Formation Template example](http://aws.amazon.com/cloudformation/aws-cloudformation-templates/) and quicklly change the UserData section into a bash script. The bashify command will generate a snippet that is meant to be copied and pasted into a bash script and used with user_data helper method.  The bash script should work right off the bat as lono will transform the generated Cloud Formation object references to json objects, there's no need to manually change what is generated to the helper methods, though you can if you prefer the look of the helper methods.
 
 ## Breaking up config/lono.rb
 

data/lib/lono.rb

@@ -1,8 +1,11 @@
 require 'json'
+require 'pp'
 
 $:.unshift File.dirname(__FILE__)
 require 'ext/hash'
+require 'lono/version'
 require 'lono/cli'
 require 'lono/task'
 require 'lono/template'
-require 'lono/dsl'
+require 'lono/dsl'
+require 'lono/bashify'

data/lib/lono/bashify.rb

@@ -0,0 +1,43 @@
+module Lono
+  class Bashify
+    def initialize(options={})
+      @options = options
+      @path = options[:path]
+    end
+
+    def user_data_paths(data,path="")
+      paths = []
+      paths << path
+      data.each do |key,value|
+        if value.is_a?(Hash)
+          paths += user_data_paths(value,"#{path}/#{key}")
+        else
+          paths += ["#{path}/#{key}"]
+        end
+      end
+      paths.select {|p| p =~ /UserData/ && p =~ /Fn::Join/ }
+    end
+
+    def find_user_data
+      raw = IO.read(@path)
+      json = JSON.load(raw)
+
+      user_data = json['Resources']['server']['Properties']['UserData']['Fn::Base64']['Fn::Join']
+      @delimiter, @data = user_data
+    end
+
+    def run
+      raw = IO.read(@path)
+      json = JSON.load(raw)
+      paths = user_data_paths(json)
+      paths.each do |path|
+        puts "UserData script for #{path}:"
+        key = path.sub('/','').split("/").map {|x| "['#{x}']"}.join('')
+        user_data = eval("json#{key}")
+        delimiter = user_data[0]
+        script = user_data[1]
+        puts script.join(delimiter)
+      end
+    end
+  end
+end

data/lib/lono/cli.rb

@@ -9,7 +9,7 @@ module Lono
     method_option :project_root, :default => ".", :aliases => "-r", :desc => "project root"
     method_option :quiet, :type => :boolean, :aliases => "-q", :desc => "silence the output"
     def init
-      Lono::Task.init(options)
+      Lono::Task.init(options.clone)
     end
 
     desc "generate", "Generate the cloud formation templates"
@@ -25,8 +25,18 @@ EOL
     method_option :project_root, :default => ".", :aliases => "-r", :desc => "project root"
     method_option :quiet, :type => :boolean, :aliases => "-q", :desc => "silence the output"
     def generate
-      Lono::Task.generate(options)
+      Lono::Task.generate(options.clone)
     end
-  end
-  
+
+    desc "bashify [cloudformation-path]", "Convert the UserData section of an existing Cloud Formation Template to a starter bash script that is compatiable with lono"
+    def bashify(path)
+      Lono::Task.bashify(path)
+    end
+
+    desc "version", "Prints version"
+    def version
+      puts Lono::VERSION
+    end
+
+  end  
 end

data/lib/lono/task.rb

@@ -32,5 +32,10 @@ module Lono
     def generate
       @dsl.run(@options)
     end
+
+    def self.bashify(path)
+      @bashify = Lono::Bashify.new(:path => path)
+      @bashify.run
+    end
   end
 end

data/lib/lono/template.rb

@@ -39,8 +39,7 @@ module Lono
       template = IO.read(path)
       result = ERB.new(template).result(binding)
       output = []
-      lines = result.split("\n")
-      lines.each do |line|
+      result.split("\n").each do |line|
         output += transform(line)
       end
       output.to_json
@@ -50,25 +49,38 @@ module Lono
       %Q|{"Ref"=>"#{name}"}|
     end
 
-    # http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/intrinsic-function-reference-findinmap.html
     def find_in_map(*args)
-      args.map! {|x| x =~ /=>/ ? x : x.inspect }
-      %Q|{"Fn::FindInMap" => [ #{args.join(',')} ]}|
+      %Q|{"Fn::FindInMap" => [ #{transform_array(args)} ]}|
     end
 
-    # transform each line of the bash script into a UserData compatiable with CF template.
-    #   any {"Ref"=>"..."} string get turned into CF Hash elements
-    def transform(line)
-      # Fn::FindInMap transform, also takes care of nested Ref transform
-      data = evaluate(line,/({"Fn::FindInMap" => \[ .* \]})/)
+    def base64(value)
+      %Q|{"Fn::Base64"=>"#{value}"}|
+    end
 
-      # Ref transform
-      already_transformed = data.size > 1
-      unless already_transformed
-        data = evaluate(line,/({"Ref"=>".*?"})/)
-      end
+    def get_att(*args)
+      %Q|{"Fn::GetAtt" => [ #{transform_array(args)} ]}|
+    end
+
+    def get_azs(region="AWS::Region")
+      %Q|{"Fn::GetAZs"=>"#{region}"}|
+    end
+
+    def join(delimiter, values)
+      %Q|{"Fn::Join" => ["#{delimiter}", [ #{transform_array(values)} ]]}|
+    end
 
-      # add newline at the end
+    def select(index, list)
+      %Q|{"Fn::Select" => ["#{index}", [ #{transform_array(list)} ]]}|
+    end
+
+    def transform_array(arr)
+      arr.map! {|x| x =~ /=>/ ? x : x.inspect }
+      arr.join(',')
+    end
+
+    # transform each line of bash script to array with cloud formation template objects
+    def transform(data)
+      data = evaluate(data)
       if data[-1].is_a?(String)
         data[0..-2] + ["#{data[-1]}\n"] 
       else
@@ -76,13 +88,85 @@ module Lono
       end
     end
 
-    # if regex found in line, the match is eval into ruby code
-    #   returns array of evaluated items
-    # if regex pattern not found
-    #   returns array with original line
-    def evaluate(line, regex)
-      data = line.split(regex)
-      data.map {|l| l.is_a?(String) && l.match(regex) ? eval(l) : l }
+    # Input:
+    #   String
+    # Output:
+    #   Array of parse positions
+    #
+    # The positions indicate when the brackets start and close.  
+    # Handles nested brackets.
+    def bracket_positions(line)
+      positions,pair,count = [],[],0
+      line.split('').each_with_index do |char,i|
+        if char == '{'
+          count += 1
+          pair << i if count == 1
+          next
+        end
+
+        if char == '}'
+          count -= 1
+          if count == 0
+            pair << i
+            positions << pair
+            pair = []
+          end
+        end
+      end
+      positions
+    end
+
+    # Input:
+    #   Array - bracket_positions
+    # Ouput:
+    #   Array - positions that can be use to determine what to parse
+    def parse_positions(line)
+      positions = bracket_positions(line)
+      # add 1 to the element in the position pair to make parsing easier in decompose
+      positions.map {|pair| [pair[0],pair[1]+1]}.flatten
+    end
+
+    # Input
+    #   String line of code to decompose into chunks, some can be transformed into objects
+    # Output
+    #   Array of strings, some can be transformed into objects
+    #
+    # Example:
+    # line = 'a{b}c{d{d}d}e' # nested brackets
+    # template.decompose(line).should == ['a','{b}','c','{d{d}d}','e']
+    def decompose(line)
+      positions = parse_positions(line)
+      return [line] if positions.empty?
+
+      result = []
+      str = ''
+      last_index = line.size - 1
+      parse_position = positions.shift
+
+      line.split('').each_with_index do |char,current_i|
+        # the current item's creation will end when
+        #   the next item's index is reached
+        #   or the end of the line is reached
+        str << char
+        next_i = current_i + 1
+        end_of_item = next_i == parse_position
+        end_of_line = current_i == last_index
+        if end_of_item or end_of_line
+          parse_position = positions.shift
+          result << str
+          str = ''
+        end
+      end
+
+      result
+    end
+
+    def recompose(decomposition)
+      decomposition.map { |s| (s =~ /^{/ && s =~ /=>/) ? eval(s) : s }
+    end
+
+    def evaluate(line)
+      recompose(decompose(line))
     end
   end
 end

data/lib/lono/version.rb

@@ -1,3 +1,3 @@
 module Lono
-  VERSION = "0.2.4"
+  VERSION = "0.3.0"
 end

data/lib/starter_project/templates/user_data/db.sh.erb

@@ -1,8 +1,15 @@
 #!/bin/bash -lexv
 exec > >(tee /var/log/user-data.log|logger -t user-data -s 2>/dev/console) 2>&1
 
-FINDINMAP_TEST=<%= find_in_map("MapName", "TopLevelKey", "SecondLevelKey") %>
+FIND_IN_MAP=<%= find_in_map("MapName", "TopLevelKey", "SecondLevelKey") %>
 HOSTNAME_PREFIX=<%= find_in_map("EnvironmentMapping", "HostnamePrefix", ref("Environment")) %>
+BAR=<%= ref("DRINK") %> ; MORE=<%= find_in_map("MapName", "TopLevelKey", "SecondLevelKey") %>
+
+BASE64=<%= base64("value to encode") %>
+GET_ATT=<%= get_att("server", "PublicDnsName") %>
+GET_AZS=<%= get_azs %>
+JOIN=<%= join(":", ['a','b','c']) %>
+SELECT=<%= select("1", ['a','b','c']) %>
 
 echo <%= ref("AWS::StackName") %> > /tmp/stack_name
 # Helper function

data/spec/fixtures/cfn.json

@@ -0,0 +1,369 @@
+{
+  "AWSTemplateFormatVersion": "2010-09-09",
+  "Description": "Api redis",
+  "Outputs": {
+    "DBHostname": {
+      "Description": "Hostname for Redis",
+      "Value": {
+        "Fn::Join": [
+          "",
+          [
+            "",
+            {
+              "Fn::GetAtt": [
+                "server",
+                "PublicDnsName"
+              ]
+            }
+          ]
+        ]
+      }
+    }
+  },
+  "Parameters": {
+    "Ami": {
+      "Default": "ami-456",
+      "Description": "deploy ami",
+      "Type": "String"
+    },
+    "Application": {
+      "Default": "api",
+      "Description": "foo, bar, etc",
+      "Type": "String"
+    },
+    "Environment": {
+      "Default": "prod",
+      "Description": "stag, prod etc",
+      "Type": "String"
+    },
+    "InstanceType": {
+      "AllowedValues": [
+        "t1.micro",
+        "m1.small",
+        "m1.medium",
+        "m1.large",
+        "m1.xlarge",
+        "m2.xlarge",
+        "m2.2xlarge",
+        "m2.4xlarge",
+        "c1.medium",
+        "c1.xlarge",
+        "cc1.4xlarge",
+        "cc2.8xlarge",
+        "cg1.4xlarge"
+      ],
+      "ConstraintDescription": "must be a valid EC2 instance type.",
+      "Default": "m1.small",
+      "Description": "server EC2 instance type",
+      "Type": "String"
+    },
+    "KeyName": {
+      "AllowedPattern": "[-_ a-zA-Z0-9]*",
+      "ConstraintDescription": "can contain only alphanumeric characters, spaces, dashes and underscores.",
+      "Default": "default",
+      "Description": "Name of an existing EC2 KeyPair to enable SSH access to the instances",
+      "MaxLength": "64",
+      "MinLength": "1",
+      "Type": "String"
+    },
+    "Role": {
+      "Default": "redis",
+      "Description": "redis, psql, app, etc",
+      "Type": "String"
+    },
+    "StackNumber": {
+      "Default": "",
+      "Description": "s1, s2, s3, etc",
+      "Type": "String"
+    },
+    "VolumeSize": {
+      "ConstraintDescription": "must be between 5 and 1024 Gb.",
+      "Default": "20",
+      "Description": "Size of Volume",
+      "MaxValue": "1024",
+      "MinValue": "5",
+      "Type": "Number"
+    }
+  },
+  "Resources": {
+    "CfnUser": {
+      "Properties": {
+        "Path": "/",
+        "Policies": [
+          {
+            "PolicyDocument": {
+              "Statement": [
+                {
+                  "Action": "cloudformation:DescribeStackResource",
+                  "Effect": "Allow",
+                  "Resource": "*"
+                }
+              ]
+            },
+            "PolicyName": "root"
+          }
+        ]
+      },
+      "Type": "AWS::IAM::User"
+    },
+    "DataVolume": {
+      "DeletionPolicy": "Snapshot",
+      "Properties": {
+        "AvailabilityZone": {
+          "Fn::GetAtt": [
+            "server",
+            "AvailabilityZone"
+          ]
+        },
+        "Size": {
+          "Ref": "VolumeSize"
+        },
+        "Tags": [
+          {
+            "Key": "Usage",
+            "Value": "Data Volume"
+          }
+        ]
+      },
+      "Type": "AWS::EC2::Volume"
+    },
+    "HostKeys": {
+      "Properties": {
+        "UserName": {
+          "Ref": "CfnUser"
+        }
+      },
+      "Type": "AWS::IAM::AccessKey"
+    },
+    "HostRecord": {
+      "Properties": {
+        "Comment": "DNS name for my stack.",
+        "HostedZoneName": ".mydomain.net.",
+        "Name": {
+          "Fn::Join": [
+            "",
+            [
+              {
+                "Ref": "AWS::StackName"
+              },
+              ".mydomain.net."
+            ]
+          ]
+        },
+        "ResourceRecords": [
+          {
+            "Fn::GetAtt": [
+              "server",
+              "PublicDnsName"
+            ]
+          }
+        ],
+        "TTL": "60",
+        "Type": "CNAME"
+      },
+      "Type": "AWS::Route53::RecordSet"
+    },
+    "MountPoint": {
+      "Properties": {
+        "Device": "/dev/sdf",
+        "InstanceId": {
+          "Ref": "server"
+        },
+        "VolumeId": {
+          "Ref": "DataVolume"
+        }
+      },
+      "Type": "AWS::EC2::VolumeAttachment"
+    },
+    "ServiceSecurityGroup": {
+      "Properties": {
+        "GroupDescription": "Enable SSH access.",
+        "SecurityGroupIngress": [
+          {
+            "CidrIp": "0.0.0.0/0",
+            "FromPort": "22",
+            "IpProtocol": "tcp",
+            "ToPort": "22"
+          }
+        ]
+      },
+      "Type": "AWS::EC2::SecurityGroup"
+    },
+    "WaitCondition": {
+      "DependsOn": "MountPoint",
+      "Metadata": {
+        "Comment1": "Note that the WaitCondition is dependent on the volume mount point allowing the volume to be created and attached to the EC2 instance",
+        "Comment2": "The instance bootstrap script waits for the volume to be attached to the instance prior to signalling completion."
+      },
+      "Properties": {
+        "Handle": {
+          "Ref": "WaitHandle"
+        },
+        "Timeout": "3000"
+      },
+      "Type": "AWS::CloudFormation::WaitCondition"
+    },
+    "WaitHandle": {
+      "Type": "AWS::CloudFormation::WaitConditionHandle"
+    },
+    "server": {
+      "Properties": {
+        "AvailabilityZone": "us-east-1e",
+        "ImageId": {
+          "Ref": "Ami"
+        },
+        "InstanceType": {
+          "Ref": "InstanceType"
+        },
+        "KeyName": {
+          "Ref": "KeyName"
+        },
+        "SecurityGroups": [
+          "global",
+          {
+            "Fn::Join": [
+              "-",
+              [
+                {
+                  "Ref": "Environment"
+                },
+                {
+                  "Ref": "Application"
+                }
+              ]
+            ]
+          },
+          {
+            "Ref": "ServiceSecurityGroup"
+          }
+        ],
+        "UserData": {
+          "Fn::Base64": {
+            "Fn::Join": [
+              "",
+              [
+                "#!/bin/bash -lexv\n",
+                "exec > >(tee /var/log/user-data.log|logger -t user-data -s 2>/dev/console) 2>&1\n",
+                "\n",
+                "FIND_IN_MAP=",
+                {
+                  "Fn::FindInMap": [
+                    "MapName",
+                    "TopLevelKey",
+                    "SecondLevelKey"
+                  ]
+                },
+                "\n",
+                "HOSTNAME_PREFIX=",
+                {
+                  "Fn::FindInMap": [
+                    "EnvironmentMapping",
+                    "HostnamePrefix",
+                    {
+                      "Ref": "Environment"
+                    }
+                  ]
+                },
+                "\n",
+                "BAR=",
+                {
+                  "Ref": "DRINK"
+                },
+                " ; MORE=",
+                {
+                  "Fn::FindInMap": [
+                    "MapName",
+                    "TopLevelKey",
+                    "SecondLevelKey"
+                  ]
+                },
+                "\n",
+                "\n",
+                "BASE64=",
+                {
+                  "Fn::Base64": "value to encode"
+                },
+                "\n",
+                "GET_ATT=",
+                {
+                  "Fn::GetAtt": [
+                    "server",
+                    "PublicDnsName"
+                  ]
+                },
+                "\n",
+                "GET_AZS=",
+                {
+                  "Fn::GetAZs": "AWS::Region"
+                },
+                "\n",
+                "JOIN=",
+                {
+                  "Fn::Join": [
+                    ":",
+                    [
+                      "a",
+                      "b",
+                      "c"
+                    ]
+                  ]
+                },
+                "\n",
+                "SELECT=",
+                {
+                  "Fn::Select": [
+                    "1",
+                    [
+                      "a",
+                      "b",
+                      "c"
+                    ]
+                  ]
+                },
+                "\n",
+                "\n",
+                "echo ",
+                {
+                  "Ref": "AWS::StackName"
+                },
+                " > /tmp/stack_name\n",
+                "# Helper function\n",
+                "function error_exit\n",
+                "{\n",
+                "  /usr/local/bin/cfn-signal -e 1 -r \"$1\" '",
+                {
+                  "Ref": "WaitHandle"
+                },
+                "'\n",
+                "exit 1\n",
+                "}\n",
+                "# Wait for the EBS volume to show up\n",
+                "while [ ! -e /dev/xvdf ]; do echo Waiting for EBS volume to attach; sleep 1; done\n",
+                "/bin/mkdir /media/redis\n",
+                "/sbin/mkfs -t ext4 /dev/xvdf\n",
+                "echo \"/dev/xvdf /media/redis auto defaults 0 0\" >> /etc/fstab\n",
+                "/bin/mount /media/redis\n",
+                "/usr/bin/redis-cli shutdown\n",
+                "sleep 10\n",
+                "mv /var/lib/redis/* /media/redis/\n",
+                "rm -r /var/lib/redis\n",
+                "ln -s /media/redis /var/lib/redis\n",
+                "chown -R redis:redis /var/lib/redis\n",
+                "chown -R redis:redis /media/redis\n",
+                "/usr/bin/redis-server\n",
+                "# If all is well so signal success\n",
+                "/usr/local/bin/cfn-signal -e $? -r \"Ready to rock\" '",
+                {
+                  "Ref": "WaitHandle"
+                },
+                "'\n",
+                "cat /proc/uptime | cut -f1 -d'.' > /tmp/time-to-boot\n"
+              ]
+            ]
+          }
+        }
+      },
+      "Type": "AWS::EC2::Instance"
+    }
+  }
+}

data/spec/lib/lono_spec.rb

@@ -11,6 +11,55 @@ describe Lono do
     FileUtils.rm_rf(@project)
   end
 
+  describe "bashify" do
+    it "should convert cfn user_data to bash script" do
+      path = "#{$root}/spec/fixtures/cfn.json"
+      out = execute("./bin/lono bashify #{path}")
+      out.should match /bash -lexv/
+    end
+  end
+
+  describe "parsing" do
+    it "should transform bash script into json array with cloud formation objects" do
+      block = Proc.new { }
+      template = Lono::Template.new("foo", block)
+
+      line = '0{2345}7'
+      template.bracket_positions(line).should == [[1,6]]
+      line = '0{2}4{6}' # more than one bracket
+      template.bracket_positions(line).should == [[1,3],[5,7]]
+      line = '0{2}4{6{8}0}2' # nested brackets
+      template.bracket_positions(line).should == [[1,3],[5,11]]
+
+      line = '0{2=>5}7'
+      template.parse_positions(line).should == [1,7]
+      line = '0{2=>5}4{6=>{8=>9}}2' # nested brackets
+      template.parse_positions(line).should == [1, 7, 8, 19]
+      line = '0{2=>5}4{' # nested brackets
+      template.parse_positions(line).should == [1, 7]
+
+      line = '{'
+      template.decompose(line).should == ['{']
+
+      line = 'a{"foo"=>"bar"}h'
+      template.decompose(line).should == ['a','{"foo"=>"bar"}','h']
+      line = 'a{"foo"=>"bar"}c{"dog"=>{"cat"=>"mouse"}}e' # nested brackets
+      template.decompose(line).should == ['a','{"foo"=>"bar"}','c','{"dog"=>{"cat"=>"mouse"}}','e']
+
+      line = 'test{"hello"=>"world"}me' # nested brackets
+      decomposition = template.decompose(line)
+      result = template.recompose(decomposition)
+      result.should == ["test", {"hello" => "world"}, "me"]
+
+      line = 'test{"hello"=>"world"}me'
+      template.transform(line).should == ["test", {"hello" => "world"}, "me\n"]
+      line = '{"hello"=>"world"}'
+      template.transform(line).should == [{"hello" => "world"}, "\n"]
+      line = '{'
+      template.transform(line).should == ["{\n"]
+    end
+  end
+
   describe "ruby specs" do
     before(:each) do
       @dsl = Lono::DSL.new(
@@ -48,6 +97,13 @@ describe Lono do
           "SecondLevelKey"
         ]
       })
+      user_data.should include({"Ref" => "DRINK"})
+
+      user_data.should include({"Fn::Base64" => "value to encode"})
+      user_data.should include({"Fn::GetAtt" => ["server", "PublicDnsName"]})
+      user_data.should include({"Fn::GetAZs" => "AWS::Region"})
+      user_data.should include({"Fn::Join" => [ ':', ['a','b','c']]})
+      user_data.should include({"Fn::Select" => [ '1', ['a','b','c']]})
     end
 
     it "should transform bash script to CF template user_data" do
@@ -61,6 +117,14 @@ describe Lono do
       line = 'echo {"Ref"=>"AWS::StackName"} > /tmp/stack_name'
       data = template.transform(line)
       data.should == ["echo ", {"Ref"=>"AWS::StackName"}, " > /tmp/stack_name\n"]
+
+      line = 'echo {"Fn::FindInMap" => [ "A", "B", {"Ref"=>"AWS::StackName"} ]}'
+      data = template.transform(line)
+      data.should == ["echo ", {"Fn::FindInMap" => ["A", "B", {"Ref"=>"AWS::StackName"}]}, "\n"]
+
+      line = 'echo {"Fn::FindInMap" => [ "A", "B", {"Ref"=>"AWS::StackName"} ]} > /tmp/stack_name ; {"Ref"=>"Ami"}'
+      data = template.transform(line)
+      data.should == ["echo ", {"Fn::FindInMap" => ["A", "B", {"Ref"=>"AWS::StackName"}]}, " > /tmp/stack_name ; ", {"Ref"=>"Ami"}, "\n"]
     end
 
     it "task should generate cloud formation templates" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lono
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-26 00:00:00.000000000 Z
+date: 2013-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -207,6 +207,7 @@ files:
 - bin/lono
 - lib/ext/hash.rb
 - lib/lono.rb
+- lib/lono/bashify.rb
 - lib/lono/cli.rb
 - lib/lono/dsl.rb
 - lib/lono/task.rb
@@ -222,6 +223,7 @@ files:
 - lib/starter_project/templates/user_data/app.sh.erb
 - lib/starter_project/templates/user_data/db.sh.erb
 - lono.gemspec
+- spec/fixtures/cfn.json
 - spec/lib/lono_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/tongueroo/lono
@@ -250,5 +252,6 @@ specification_version: 3
 summary: Lono is a Cloud Formation Template ruby generator.  Lono generates Cloud
   Formation templates based on ERB templates.
 test_files:
+- spec/fixtures/cfn.json
 - spec/lib/lono_spec.rb
 - spec/spec_helper.rb