cfoo 0.0.1

data/spec/cfoo/file_system_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'fileutils'
+include FileUtils
+
+module Cfoo
+    describe FileSystem do
+        let(:project_root) { "/tmp/#{File.basename(__FILE__)}#{$$}" }
+        let(:yaml_parser) { double("yaml_parser") }
+        let(:file_system) { FileSystem.new(project_root, yaml_parser) }
+        before do
+            rm_rf project_root
+            mkdir project_root
+        end
+
+        after do
+            rm_rf project_root
+        end
+
+        describe "#list" do
+            it "returns full path of files, resolved relative to project root" do
+                files = %w[a b c].map {|file| File.join(project_root, "modules", file) }
+                mkdir File.join(project_root, "modules")
+                touch files 
+
+                file_system.list("modules").sort.should == files
+            end
+        end
+
+        describe "#glob_relative" do
+            it "returns relative path of files, resolved relative to project root" do
+                files = %w[a b c].map {|file| File.join(project_root, "modules", file) }
+                mkdir File.join(project_root, "modules")
+                touch files 
+
+                relative_files = files.map {|f| f.gsub(project_root + "/", "")}
+
+                file_system.glob_relative("modules/*").sort.should == relative_files
+            end
+            it "expands globs" do
+                files = %w[a.txt b.json c.yml].map {|file| File.join(project_root, "modules", file) }
+                mkdir File.join(project_root, "modules")
+                touch files 
+
+                file_system.glob_relative("modules/*.yml").should == ["modules/c.yml"]
+            end
+        end
+        
+        describe "#parse_file" do
+            it "loads the file with the YAML parser" do
+               yaml_parser.should_receive(:load_file).with("#{project_root}/yamlfile.yml")
+               file_system.parse_file("yamlfile.yml")
+            end
+        end
+
+        def write(file, content)
+            File.open(file, "w+") do |f|
+                f.puts content
+            end
+        end
+    end
+end

data/spec/cfoo/module_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Cfoo
+    describe Module do
+        let(:file_system) { double('file_system') }
+        let(:mod) { Module.new("/modulepath", file_system) }
+
+        describe "#files" do
+            it "lists all files in the module directory" do
+                files = ["file1.yml", "file2.yml", "file3.yml"]
+                file_system.should_receive(:glob_relative).with("/modulepath/*.yml").and_return files
+                mod.files.should == files
+            end
+        end
+    end
+end

data/spec/cfoo/parser_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+module Cfoo
+    describe Parser do
+        let(:file_system) { double('file_system') }
+        let(:parser) { Parser.new(file_system) }
+
+        describe "#parse_file" do
+            context "when processing a normal array" do
+                it "returns it" do
+                    file_system.should_receive(:parse_file).with("myfile.yml").and_return([1, 2, 3])
+                    parser.parse_file("myfile.yml").should == [1, 2, 3]
+                end
+            end
+
+            context "when processing a normal map" do
+                it "returns it" do
+                    file_system.should_receive(:parse_file).with("myfile.yml").and_return({"a" => "b"})
+                    parser.parse_file("myfile.yml").should == { "a" => "b" }
+                end
+            end
+
+            context "when parsing integer literals" do
+                it "returns them" do
+                    file_system.should_receive(:parse_file).with("myfile.yml").and_return(1)
+                    parser.parse_file("myfile.yml").should == 1
+                end
+            end
+
+            context "when parsing boolean literals" do
+                it "turns false into a string" do
+                    file_system.should_receive(:parse_file).with("myfile.yml").and_return(false)
+                    parser.parse_file("myfile.yml").should == "false"
+                end
+                it "turns true into a string" do
+                    file_system.should_receive(:parse_file).with("myfile.yml").and_return(true)
+                    parser.parse_file("myfile.yml").should == "true"
+                end
+            end
+
+            context "when parsing a string" do
+                it 'turns simple EL references into CloudFormation "Ref" maps' do
+                    file_system.should_receive(:parse_file).with("myfile.yml").and_return("$(orange)")
+                    parser.parse_file("myfile.yml").should == {"Ref" => "orange"}
+                end
+
+                it 'turns EL references embedded in strings into appended arrays' do
+                    file_system.should_receive(:parse_file).with("myfile.yml").and_return("large $(MelonType) melon")
+                    parser.parse_file("myfile.yml").should == {"Fn::Join" => [ "", [ "large ", { "Ref" => "MelonType" }, " melon" ] ] }
+                end
+
+                it 'turns multiple EL references embedded in strings into single appended arrays' do
+                    file_system.should_receive(:parse_file).with("myfile.yml").and_return("$(apples) and $(oranges)")
+                    expected = {"Fn::Join" => [ "", [ { "Ref" => "apples" }, " and ", { "Ref" => "oranges" } ] ] }
+                    parser.parse_file("myfile.yml").should == expected
+                end
+
+                it 'turns EL attribute references into CloudFormation "GetAtt" maps' do
+                    file_system.should_receive(:parse_file).with("myfile.yml").and_return("$(apple.color)")
+                    parser.parse_file("myfile.yml").should == {"Fn::GetAtt" => ["apple", "color"]}
+                end
+
+                it 'turns EL map references into CloudFormation "FindInMap" maps' do
+                    file_system.should_receive(:parse_file).with("myfile.yml").and_return("$(fruit[apple][color])")
+                    parser.parse_file("myfile.yml").should == {"Fn::FindInMap" => ["fruit", "apple", "color"]}
+                end
+
+                it 'leaves escaped EL alone' do
+                    file_system.should_receive(:parse_file).with("myfile.yml").and_return("\\$(apple.color) apple")
+                    parser.parse_file("myfile.yml").should == "$(apple.color) apple"
+                end
+            end
+
+            context "when parsing a YAML::PrivateType" do
+                it "wraps references in AWS Ref maps" do
+                    file_system.should_receive(:parse_file).with("ref.yml").and_return(YAML::DomainType.create("Ref", "AWS::Region"))
+                    parser.parse_file("ref.yml").should == {"Ref" => "AWS::Region" }
+                end
+                it "wraps attribute references in AWS GetAtt maps" do
+                    file_system.should_receive(:parse_file).with("getattr.yml").and_return(YAML::DomainType.create("GetAtt", ["Object", "Property"]))
+
+                    parser.parse_file("getattr.yml").should == {"Fn::GetAtt" => [ "Object", "Property" ] }
+                end
+                it "wraps joins in AWS Join function-calls" do
+                    file_system.should_receive(:parse_file).with("join.yml").and_return(YAML::DomainType.create("Join", ['', ["a","b","c"]]))
+
+                    parser.parse_file("join.yml").should == {"Fn::Join" => [ "" , [ "a", "b", "c" ] ] }
+                end
+                it "wraps concatenations in AWS Join function-calls with empty strings" do
+                    file_system.should_receive(:parse_file).with("join.yml").and_return(YAML::DomainType.create("Concat", ["a","b","c"]))
+
+                    parser.parse_file("join.yml").should == {"Fn::Join" => [ "" , [ "a", "b", "c" ] ] }
+                end
+                it "wraps map lookups in AWS FindInMap function-calls" do
+                    file_system.should_receive(:parse_file).with("findinmap.yml").and_return(YAML::DomainType.create("FindInMap", ["Map", "Key", "Value"]))
+
+                    parser.parse_file("findinmap.yml").should == {"Fn::FindInMap" => [ "Map", "Key", "Value" ] }
+                end
+                it "wraps AZ lookups in AWS GetAZs function-calls" do
+                    file_system.should_receive(:parse_file).with("az.yml").and_return(YAML::DomainType.create("GetAZs", "us-east-1"))
+
+                    parser.parse_file("az.yml").should == {"Fn::GetAZs" => "us-east-1"}
+                end
+                it "wraps base64 strings in AWS Base64 function-calls" do
+                    file_system.should_receive(:parse_file).with("b64.yml").and_return(YAML::DomainType.create("Base64", "myencodedstring"))
+
+                    parser.parse_file("b64.yml").should == {"Fn::Base64" => "myencodedstring"}
+                end
+            end
+
+            context "in an array" do
+                it "expands elements' EL" do
+                    file_system.should_receive(:parse_file).with("myfile.yml").and_return [ "$(orange)" ]
+                    parser.parse_file("myfile.yml").should == [{"Ref" => "orange"}]
+                end
+            end
+
+            context "in a map" do
+                it "expands values' EL" do
+                    file_system.should_receive(:parse_file).with("myfile.yml").and_return({ "IpAddress" => "$(IpAddress)" })
+                    parser.parse_file("myfile.yml").should == {"IpAddress" => { "Ref" => "IpAddress"}}
+                end
+            end
+
+            context "in a complex data structure" do
+                it "expands EL deeply" do
+                    input_map = {
+                        "AvailabilityZones" => ["$(PublicSubnetAz)"],
+                        "URLs" => ["http://$(Hostname)/index.html"] 
+                    }
+                    expected_output = {
+                        "AvailabilityZones" => [ {"Ref" => "PublicSubnetAz"}],
+                        "URLs" => [{"Fn::Join" => [ "", [ "http://", { "Ref" => "Hostname" }, "/index.html" ] ] }] 
+                    }
+                    file_system.should_receive(:parse_file).with("myfile.yml").and_return(input_map)
+                    parser.parse_file("myfile.yml").should == expected_output
+                end
+            end
+
+            context "when presented with an unknown object" do
+                it "raises an error" do
+                    file_system.should_receive(:parse_file).with("myfile.yml").and_return(/a regex/)
+                    expect {parser.parse_file("myfile.yml")}.to raise_error Parser::ElParseError
+                end
+            end
+        end
+    end
+end

data/spec/cfoo/processor_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+module Cfoo
+    describe Processor do
+
+        let(:parser) { double('parser') }
+        let(:project) { double('project') }
+        let(:processor) { Processor.new(parser, project) }
+
+        describe "#process" do
+            it "parses the specified files" do
+                parser.should_receive(:parse_file).with("app.yml").and_return({"Resources" => { "AppServer" => { "Type" => "EC2Instance" } } })
+                parser.should_receive(:parse_file).with("db.yml").and_return({"Resources" => { "DbServer" => { "Type" => "EC2Instance" } } })
+                parser.should_receive(:parse_file).with("network.yml").and_return({"Parameters" => { "LoadBalancerIpAddress" => "10.0.0.51" } })
+                processor.process("app.yml", "db.yml", "network.yml").should == {
+                    "AWSTemplateFormatVersion" => "2010-09-09",
+                    "Parameters" => {
+                        "LoadBalancerIpAddress" => "10.0.0.51"
+                    },
+                    "Resources" => {
+                        "AppServer" => { "Type" => "EC2Instance" },
+                        "DbServer" => { "Type" => "EC2Instance" }
+                    }
+                }
+            end
+        end
+
+        describe "#process_all" do
+            it "processes all modules" do
+                modules = [ double("module0"), double("module1") ]
+                project.should_receive(:modules).and_return(modules)
+                modules[0].should_receive(:files).and_return ["app.yml", "db.yml"]
+                modules[1].should_receive(:files).and_return ["network.yml"]
+                parser.should_receive(:parse_file).with("app.yml").and_return({"Resources" => { "AppServer" => { "Type" => "EC2Instance" } } })
+                parser.should_receive(:parse_file).with("db.yml").and_return({"Resources" => { "DbServer" => { "Type" => "EC2Instance" } } })
+                parser.should_receive(:parse_file).with("network.yml").and_return({"Parameters" => { "LoadBalancerIpAddress" => "10.0.0.51" } })
+
+                processor.process_all.should == {
+                    "AWSTemplateFormatVersion" => "2010-09-09",
+                    "Parameters" => {
+                        "LoadBalancerIpAddress" => "10.0.0.51"
+                    },
+                    "Resources" => {
+                        "AppServer" => { "Type" => "EC2Instance" },
+                        "DbServer" => { "Type" => "EC2Instance" }
+                    }
+                }
+            end
+        end
+    end
+end
+

data/spec/cfoo/project_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+module Cfoo
+    describe Project do
+
+        let(:file_system) { double('file_system') }
+        let(:project) { Project.new(file_system) }
+        describe '#modules' do
+            it 'lists the directories in the "modules" folder of the project' do
+                file_system.should_receive(:glob_relative).with("modules/*").and_return ["a", "b", "c"]
+                project.modules.should == ["a", "b", "c"].map {|e| Module.new("modules/#{e}", file_system) }
+            end
+        end
+    end
+end
+

data/spec/cfoo/renderer_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+module Cfoo
+    describe Renderer do
+        describe "#render" do
+            let(:renderer) { Renderer.new }
+            it "renders a Hash as a CloudFormation JSON template" do
+                hash = {
+                    "Resources" => {
+                            "Server" => { "Type" => "EC2Instance" },
+                            "DNS Entry" => { "Type" => "ARecord" }
+                        }
+                }
+                renderer.render(hash).should == JSON.pretty_unparse(hash)
+            end
+        end
+    end
+end
+

data/spec/cfoo/yaml_parser_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+module Cfoo
+    describe YamlParser do
+
+        let(:parser) { YamlParser.new }
+        let(:working_dir) { "/tmp/#{File.basename(__FILE__)}#{$$}" }
+
+        before do
+            rm_rf working_dir
+            mkdir working_dir
+        end
+
+        after do
+            rm_rf working_dir
+        end
+
+        describe "#load_file" do
+            it "parses a file as YAML" do
+                write "#{working_dir}/file.yml", "key: value"
+
+                parser.load_file("#{working_dir}/file.yml").should == {"key" => "value"}
+            end
+            context "when the YAML contains EL" do
+                it "parses it with the EL intact" do
+                    write "#{working_dir}/el.yml", "key: [$(value)]"
+
+                    parser.load_file("#{working_dir}/el.yml").should == {"key" => ["$(value)"]}
+                end
+            end
+            context "when the YAML is invalid" do
+                it "raises an error" do
+                    write "#{working_dir}/bad.yml", "key: : value"
+
+                    expect {parser.load_file("#{working_dir}/bad.yml")}.to raise_error
+                end
+            end
+            context "when the YAML contains a custom AWS datatype" do
+                it "wraps references in AWS Ref maps" do
+                    write "#{working_dir}/ref.yml", "!Ref AWS::Region"
+
+                    parser.load_file("#{working_dir}/ref.yml").should == YAML::DomainType.create("Ref", "AWS::Region")
+                end
+                it "wraps attribute references in AWS GetAtt maps" do
+                    write "#{working_dir}/getatt.yml", "!GetAtt [Object, Property]"
+
+                    parser.load_file("#{working_dir}/getatt.yml").should == YAML::DomainType.create("GetAtt", ["Object", "Property"])
+                end
+                it "wraps joins in AWS Join function-calls" do
+                    write "#{working_dir}/join.yml", "!Join ['', [a, b, c]]"
+
+                    parser.load_file("#{working_dir}/join.yml").should == YAML::DomainType.create("Join", ["", ["a","b","c"]])
+                end
+                it "wraps concatenations in AWS Join function-calls with empty strings" do
+                    write "#{working_dir}/concat.yml", "!Concat [a, b, c]"
+
+                    parser.load_file("#{working_dir}/concat.yml").should == YAML::DomainType.create("Concat", ["a","b","c"])
+                end
+                it "wraps map lookups in AWS FindInMap function-calls" do
+                    write "#{working_dir}/findinmap.yml", "!FindInMap [Map, Key, Value]"
+
+                    parser.load_file("#{working_dir}/findinmap.yml").should == YAML::DomainType.create("FindInMap", ["Map", "Key", "Value"])
+                end
+                it "wraps base64 strings in AWS Base64 function-calls" do
+                    write "#{working_dir}/base64.yml", "!Base64 myencodedstring"
+
+                    parser.load_file("#{working_dir}/base64.yml").should == YAML::DomainType.create("Base64", "myencodedstring")
+                end
+            end
+        end
+
+        def write(file, content)
+            File.open(file, "w+") do |f|
+                f.puts content
+            end
+        end
+    end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require 'simplecov'
+require 'cfoo'

metadata

@@ -0,0 +1,235 @@
+--- !ruby/object:Gem::Specification
+name: cfoo
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- drrb
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  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: parslet
+  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: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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: cucumber
+  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: simplecov
+  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: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.3
+- !ruby/object:Gem::Dependency
+  name: json
+  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: 'Cfoo: CloudFormation master'
+email:
+- drrrrrrrrrrrb@gmail.com
+executables:
+- cfoo
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .simplecov
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- TODO
+- bin/cfoo
+- cfoo.gemspec
+- features/attribute_expansion.feature
+- features/convert_yaml_to_json.feature
+- features/el_escaping.feature
+- features/map_reference_expansion.feature
+- features/modules.feature
+- features/parse_files.feature
+- features/reference_expansion.feature
+- features/step_definitions/cfoo_steps.rb
+- features/support/env.rb
+- features/yamly_shortcuts.feature
+- lib/cfoo.rb
+- lib/cfoo/cfoo.rb
+- lib/cfoo/el_parser.rb
+- lib/cfoo/file_system.rb
+- lib/cfoo/module.rb
+- lib/cfoo/parser.rb
+- lib/cfoo/processor.rb
+- lib/cfoo/project.rb
+- lib/cfoo/renderer.rb
+- lib/cfoo/version.rb
+- lib/cfoo/yaml.rb
+- lib/cfoo/yaml_parser.rb
+- spec/cfoo/cfoo_spec.rb
+- spec/cfoo/el_parser_spec.rb
+- spec/cfoo/file_system_spec.rb
+- spec/cfoo/module_spec.rb
+- spec/cfoo/parser_spec.rb
+- spec/cfoo/processor_spec.rb
+- spec/cfoo/project_spec.rb
+- spec/cfoo/renderer_spec.rb
+- spec/cfoo/yaml_parser_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/drrb/cfoo
+licenses:
+- GPL-3
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Cfoo (pronounced 'sifu') allows you to write your CloudFormation templates
+  in a YAML-based markup language, and organise it into modules to make it easier
+  to maintain.
+test_files:
+- features/attribute_expansion.feature
+- features/convert_yaml_to_json.feature
+- features/el_escaping.feature
+- features/map_reference_expansion.feature
+- features/modules.feature
+- features/parse_files.feature
+- features/reference_expansion.feature
+- features/step_definitions/cfoo_steps.rb
+- features/support/env.rb
+- features/yamly_shortcuts.feature
+- spec/cfoo/cfoo_spec.rb
+- spec/cfoo/el_parser_spec.rb
+- spec/cfoo/file_system_spec.rb
+- spec/cfoo/module_spec.rb
+- spec/cfoo/parser_spec.rb
+- spec/cfoo/processor_spec.rb
+- spec/cfoo/project_spec.rb
+- spec/cfoo/renderer_spec.rb
+- spec/cfoo/yaml_parser_spec.rb
+- spec/spec_helper.rb