cfoo 0.0.1

data/features/modules.feature

@@ -0,0 +1,101 @@
+Feature: Modules
+    As a CloudFormation user
+    I want to split my templates into logical modules
+    So that I can organise them and share them
+
+    Scenario: Module with a template
+        Given I have a project 
+        And I have a module named "webapp"
+        And I have a file "modules/webapp/webapp.yml" containing
+        """
+        Parameters:
+            FrontendSize:
+                Type: Integer
+                Default: 5
+        Resources:
+            FrontendFleet:                                                                                                                                               
+                Type: AWS::AutoScaling::AutoScalingGroup                                         
+                Properties:                                                                         
+                    MinSize: 1                                                                      
+                    MaxSize: 10                                                                     
+        """
+        When I build the project
+        Then the output should match JSON
+        """
+        {
+            "AWSTemplateFormatVersion" : "2010-09-09",
+            "Parameters" : {
+                "FrontendSize" : { "Type" : "Integer", "Default" : 5 }
+            },
+            "Resources" : {
+                "FrontendFleet" : {
+                    "Type" : "AWS::AutoScaling::AutoScalingGroup",
+                    "Properties" : {
+                        "MinSize" : 1,
+                        "MaxSize" : 10
+                    }
+                }
+            }
+        }
+        """
+
+    Scenario: Multiple modules get merged
+        Given I have a project 
+        And I have a module named "webapp"
+        And I have a file "modules/webapp/webapp.yml" containing
+        """
+        Parameters:
+            FrontendSize:
+                Type: Integer
+                Default: 5
+        Resources:
+            FrontendFleet:                                                                                                                                               
+                Type: AWS::AutoScaling::AutoScalingGroup                                         
+                Properties:                                                                         
+                    MinSize: 1                                                                      
+                    MaxSize: $(FrontendSize)                                                                     
+        """
+        And I have a module named "database"
+        And I have a file "modules/database/database.yml" containing
+        """
+        Parameters:
+            DbName:
+                Type: String
+                Default: My Precious
+        Resources:
+            MySQLDatabase:
+                Type: AWS::RDS::DBInstance
+                Properties:
+                    Engine: MySQL
+                    DBName: $(DbName)
+                    MultiAZ: true
+        """
+        When I build the project
+        Then the output should match JSON
+        """
+        {
+            "AWSTemplateFormatVersion" : "2010-09-09",
+            "Parameters" : {
+                "FrontendSize" : { "Type" : "Integer", "Default" : 5 },
+                "DbName" : { "Type" : "String", "Default" : "My Precious" }
+            },
+            "Resources" : {
+                "FrontendFleet" : {
+                    "Type" : "AWS::AutoScaling::AutoScalingGroup",
+                    "Properties" : {
+                        "MinSize" : 1,
+                        "MaxSize" : { "Ref" : "FrontendSize" }
+                    }
+                },
+                "MySQLDatabase": {
+                   "Type": "AWS::RDS::DBInstance",
+                   "Properties": {
+                       "Engine" : "MySQL",
+                       "DBName" : { "Ref": "DbName" },
+                       "MultiAZ" : "true"
+                   }
+               }
+            }
+        }
+        """
+            

data/features/parse_files.feature

@@ -0,0 +1,46 @@
+Feature: Modules
+    As a casual Cfoo user
+    I want to combine arbitrary Cfoo templates
+    So that I can quickly generate a CloudFormation template without a project structure
+
+    Scenario: Parse files
+        Given I have a file "webapp.yml" containing
+        """
+        Resources:
+            FrontendFleet:                                                                                                                                               
+                Type: AWS::AutoScaling::AutoScalingGroup                                         
+                Properties:                                                                         
+                    MinSize: 1                                                                      
+                    MaxSize: 10                                                                     
+        """
+        And I have a file "vpc.yml" containing
+        """
+        Resources:
+            VPC:
+                Type: AWS::EC2::VPC
+                Properties:
+                    CidrBlock: "10.0.0.0/16"
+        """
+        When I process files "webapp.yml" and "vpc.yml"
+        Then the output should match JSON
+        """
+        {
+            "AWSTemplateFormatVersion" : "2010-09-09",
+            "Resources" : {
+                "FrontendFleet" : {
+                    "Type" : "AWS::AutoScaling::AutoScalingGroup",
+                    "Properties" : {
+                        "MinSize" : 1,
+                        "MaxSize" : 10
+                    }
+                },
+                "VPC" : {
+                    "Type" : "AWS::EC2::VPC",
+                    "Properties" : {
+                        "CidrBlock" : "10.0.0.0/16"
+                    }
+                }
+            }
+        }
+        """
+            

data/features/reference_expansion.feature

@@ -0,0 +1,49 @@
+Feature: Expand EL References
+    As a CloudFormation user
+    I want to use an expression language as a shorthand for references
+    So that I my templates are easier to read
+
+    Scenario: Simple reference
+        Given I have a file "reference.yml" containing
+        """
+        Server:
+            InstanceType: $(InstanceType)
+            SecurityGroups:
+                - sg-123456
+                - $(SshSecurityGroup)
+                - sg-987654
+        """
+        When I process "reference.yml"
+        Then the output should match JSON
+        """
+        {
+            "AWSTemplateFormatVersion" : "2010-09-09",
+            "Server" : {
+                "InstanceType" : { "Ref" : "InstanceType" },
+                "SecurityGroups" : [
+                    "sg-123456",
+                    { "Ref": "SshSecurityGroup" },
+                    "sg-987654"
+                ]
+            }
+        }
+        """
+
+    Scenario: Embedded reference
+        Given I have a file "reference.yml" containing
+        """
+        content:
+            /var/www/html: http://$(DownloadHost)/website.tar.gz
+            /etc/puppet: https://github.com/$(GithubAccount)/$(RepoName).git
+        """
+        When I process "reference.yml"
+        Then the output should match JSON
+        """
+        {
+            "AWSTemplateFormatVersion" : "2010-09-09",
+            "content": {
+                "/var/www/html" : { "Fn::Join" : [ "", [ "http://", {"Ref" : "DownloadHost"}, "/website.tar.gz" ] ] },
+                "/etc/puppet" : { "Fn::Join" : [ "", [ "https://github.com/", {"Ref" : "GithubAccount"}, "/", {"Ref" : "RepoName"}, ".git" ] ] }
+            }
+        }
+        """

data/features/step_definitions/cfoo_steps.rb

@@ -0,0 +1,107 @@
+require 'fileutils'
+require 'json'
+include FileUtils
+
+Given /^I have a project$/ do
+end
+
+Given /^I have a module named "(.*?)"$/ do |module_name|
+    create_dir "modules/#{module_name}"
+end
+
+Given /^I have a file "(.*?)" containing$/ do |filename, content|
+    write_file(filename, content)
+end
+
+When /^I process "(.*?)"$/  do |filename|
+    cfoo.process(filename)    
+end
+
+#TODO: can we use varargs?
+When /^I process files "(.*?)"(?:(?:,| and) "(.*?)")$/  do |filename_1, filename_2|
+    cfoo.process(filename_1, filename_2)
+end
+
+When /^I build the project$/ do
+    cfoo.build_project
+end
+
+Then(/^the output should match JSON$/) do |expected_json|
+    begin
+        expected = JSON.parse(expected_json)
+    rescue StandardError => e
+        puts "Couldn't parse expected ouput as JSON"
+        raise e
+    end
+    begin
+        actual = JSON.parse(stdout.messages.join "")
+    rescue StandardError => e
+        puts "Couldn't parse actual ouput as JSON"
+        raise e
+    end
+    actual.should == expected
+end
+
+def write_file(filename, content)
+    file_fqn = resolve_file(filename)
+    mkdir_p(File.dirname file_fqn)
+    File.open(file_fqn, "w") do |file|
+        file.puts content
+    end
+end
+
+def create_dir(directory)
+    mkdir_p(resolve_file(directory))
+end
+
+def resolve_file(filename)
+    "#{project_root}/#{filename}"
+end
+
+def cfoo
+    @cfoo ||= Cfoo::Cfoo.new(processor, renderer, stdout)
+end
+
+def processor
+    @processor ||= Cfoo::Processor.new(parser, project)
+end
+
+def parser
+    @parser ||= Cfoo::Parser.new(file_system)
+end
+
+def renderer
+    @renderer ||= Cfoo::Renderer.new
+end
+
+def project
+    @project ||= Cfoo::Project.new(file_system)
+end
+
+def file_system
+    @file_system ||= Cfoo::FileSystem.new(project_root, Cfoo::YamlParser.new)
+end
+
+def project_root
+    @project_root ||= "/tmp/cfoo-cucumber-#{$$}"
+    mkdir_p(@project_root)
+    @project_root
+end
+
+def stdout
+    @output ||= Output.new
+end
+
+After do                                                                             
+    rm_rf project_root if File.directory? project_root
+end
+
+class Output
+    def messages
+        @messages ||= []
+    end
+
+    def puts(message)
+        messages << message
+    end
+end

data/features/support/env.rb

@@ -0,0 +1,5 @@
+lib_path = File.expand_path('../../../lib', __FILE__)
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include? lib_path
+
+require 'simplecov'
+require 'cfoo'

data/features/yamly_shortcuts.feature

@@ -0,0 +1,132 @@
+Feature: YAMLy shortcuts
+    I should be able to write standalone (non-embedded) CloudFormation bits using custom YAML datatypes
+    So that I can have a quick YAMLy way to write them
+    
+    Scenario: Reference
+        Given I have a file "ref.yml" containing
+        """
+        Reference: !Ref AWS::Region
+        """
+        When I process "ref.yml"
+        Then the output should match JSON
+        """
+        {
+            "AWSTemplateFormatVersion" : "2010-09-09",
+            "Reference" : { "Ref" : "AWS::Region" }
+        }
+        """
+
+    Scenario: Attribute
+        Given I have a file "ref.yml" containing
+        """
+        Attribute: !GetAtt [ BastionHost, PublicIp ]
+        """
+        When I process "ref.yml"
+        Then the output should match JSON
+        """
+        {
+            "AWSTemplateFormatVersion" : "2010-09-09",
+            "Attribute" :  { "Fn::GetAtt" : [ "BastionHost", "PublicIp" ]}
+        }
+        """
+
+    Scenario: Join function call
+        Given I have a file "join.yml" containing
+        """
+        Join: !Join
+            - ""
+            - [ "string a", "string b" ]
+        """
+        When I process "join.yml"
+        Then the output should match JSON
+        """
+        {
+            "AWSTemplateFormatVersion" : "2010-09-09",
+            "Join" :  { "Fn::Join" : [ "", [ "string a", "string b" ] ]}
+        }
+        """
+
+    Scenario: Join function call with empty strings
+        Given I have a file "join.yml" containing
+        """
+        Join: !Concat [ "string a", "string b" ]
+        """
+        When I process "join.yml"
+        Then the output should match JSON
+        """
+        {
+            "AWSTemplateFormatVersion" : "2010-09-09",
+            "Join" :  { "Fn::Join" : ["", [ "string a", "string b" ]]}
+        }
+        """
+
+    Scenario: FindInMap lookup
+        Given I have a file "map.yml" containing
+        """
+        MapLookup: !FindInMap [Map, Key, Value]
+        """
+        When I process "map.yml"
+        Then the output should match JSON
+        """
+        {
+            "AWSTemplateFormatVersion" : "2010-09-09",
+            "MapLookup" : { "Fn::FindInMap" : ["Map", "Key", "Value"] }
+        }
+        """
+
+    Scenario: AZ listing
+        Given I have a file "map.yml" containing
+        """
+        AvailabilityZones: !GetAZs us-east-1
+        """
+        When I process "map.yml"
+        Then the output should match JSON
+        """
+        {
+            "AWSTemplateFormatVersion" : "2010-09-09",
+            "AvailabilityZones" : { "Fn::GetAZs" : "us-east-1" }
+        }
+        """
+
+    Scenario: Base64 string
+        Given I have a file "multistring.yml" containing
+        """
+        mystring: !Base64 |
+            Some string
+            across multiple
+            lines
+        """
+        When I process "multistring.yml"
+        Then the output should match JSON
+        """
+        {
+            "AWSTemplateFormatVersion" : "2010-09-09",
+            "mystring" : { "Fn::Base64" : "Some string\nacross multiple\nlines\n" }
+        }
+        """
+
+    Scenario: Base64 string with embedded EL
+        Given I have a file "embeddedel.yml" containing
+        """
+        mystring: !Base64 |
+            Some string
+            across $(Number)
+            lines
+        """
+        When I process "embeddedel.yml"
+        Then the output should match JSON
+        """
+        {
+            "AWSTemplateFormatVersion" : "2010-09-09",
+            "mystring" :
+               { "Fn::Base64" :
+                  { "Fn::Join": [ "", [
+                           "Some string\nacross ",
+                           { "Ref" : "Number" },
+                           "\nlines\n"
+                        ]
+                     ]
+                  }
+               }
+        }
+        """

data/lib/cfoo.rb

@@ -0,0 +1,11 @@
+require "cfoo/cfoo"
+require "cfoo/el_parser"
+require "cfoo/file_system"
+require "cfoo/module"
+require "cfoo/parser"
+require "cfoo/processor"
+require "cfoo/project"
+require "cfoo/renderer"
+require "cfoo/version"
+require "cfoo/yaml"
+