cfoo 0.0.1

data/lib/cfoo/cfoo.rb

@@ -0,0 +1,15 @@
+module Cfoo
+    class Cfoo
+        def initialize(processor, renderer, stdout)
+            @processor, @renderer, @stdout = processor, renderer, stdout
+        end
+
+        def process(*filenames)
+            @stdout.puts(@renderer.render @processor.process(*filenames))
+        end
+
+        def build_project
+            @stdout.puts(@renderer.render @processor.process_all)
+        end
+    end
+end

data/lib/cfoo/el_parser.rb

@@ -0,0 +1,105 @@
+require 'rubygems'
+require 'parslet'
+
+module Cfoo
+    class ElParser < Parslet::Parser
+
+        def self.parse(string)
+            return string if string.empty?
+
+            parser = ElParser.new
+            transform = ElTransform.new
+
+            tree = parser.parse(string)
+            transform.apply(tree)
+        #rescue Parslet::ParseFailed => failure
+        #    #TODO: handle this properly
+        end
+
+        rule(:space) { match('\s') }
+        rule(:space?) { space.maybe }
+        rule(:escaped_dollar) { str('\$').as(:escaped_dollar) }
+        rule(:lone_backslash) { str('\\').as(:lone_backslash) }
+        rule(:lparen) { str('(') }
+        rule(:rparen) { str(')') }
+        rule(:lbracket) { str('[') }
+        rule(:rbracket) { str(']') }
+        rule(:dot) { str('.') }
+        rule(:identifier) { match['a-zA-Z:'].repeat(1).as(:identifier) }
+        rule(:text) { match['^\\\\$'].repeat(1).as(:text) }
+        rule(:attribute_reference) do
+            (
+                expression.as(:reference) >> (
+                    str(".") >> identifier.as(:attribute) |
+                    str("[") >> expression.as(:attribute) >> str("]")
+                )
+            ).as(:attribute_reference)
+        end
+        rule(:mapping) do
+            (
+                expression.as(:map) >>
+                str("[") >> expression.as(:key) >> str("]") >>
+                str("[") >> expression.as(:value) >> str("]")
+            ).as(:mapping)
+        end
+        rule(:reference) do
+            expression.as(:reference)
+        end
+
+        rule(:expression) { el | identifier }
+        rule(:el) do
+            str("$(") >> ( mapping | attribute_reference | reference ) >> str(")")
+        end
+        rule(:string) do
+            ( escaped_dollar | lone_backslash | el | text ).repeat.as(:string)
+        end
+
+        root(:string)
+    end
+
+    class ElTransform < Parslet::Transform
+
+        rule(:escaped_dollar => simple(:dollar)) { "$" }
+        rule(:lone_backslash => simple(:backslash)) { "\\" }
+
+        rule(:identifier => simple(:identifier)) do
+            identifier.str
+        end
+
+        rule(:text => simple(:text)) do
+            text.str
+        end
+
+        rule(:reference => subtree(:reference)) do
+            { "Ref" => reference }
+        end
+
+        rule(:mapping => { :map => subtree(:map), :key => subtree(:key), :value => subtree(:value)}) do
+            { "Fn::FindInMap" => [map, key, value] }
+        end
+
+        rule(:attribute_reference => { :reference => subtree(:reference), :attribute => subtree(:attribute)}) do
+            { "Fn::GetAtt" => [ reference, attribute ] }
+        end
+
+        rule(:string => subtree(:string)) do
+            # Join escaped EL with adjacent strings
+            parts = string.inject(['']) do |combined_parts, part|
+                previous = combined_parts.pop
+                if previous.class == String && part.class == String
+                    combined_parts << previous + part
+                else
+                    combined_parts << previous << part
+                end
+            end
+
+            parts.reject! {|part| part.empty? }
+
+            if parts.size == 1
+                parts.first
+            else
+                { "Fn::Join" => [ "", parts ] }
+            end
+        end
+    end
+end

data/lib/cfoo/file_system.rb

@@ -0,0 +1,28 @@
+require 'cfoo/yaml_parser'
+
+module Cfoo
+    class FileSystem
+        def initialize(project_root, yaml_parser)
+            @project_root, @yaml_parser = project_root, yaml_parser
+        end
+
+        def resolve_file(file_name)
+            "#{@project_root}/#{file_name}"
+        end
+
+        def parse_file(file_name)
+            @yaml_parser.load_file(resolve_file file_name)
+        end
+
+        def glob_relative(path)
+            absolute_files = Dir.glob(resolve_file path)
+            absolute_files.map do |file|
+                file.gsub(@project_root + '/', '')
+            end
+        end
+
+        def list(path)
+            Dir.glob("#{resolve_file path}/*")
+        end
+    end
+end

data/lib/cfoo/module.rb

@@ -0,0 +1,25 @@
+module Cfoo
+    class Module
+        attr_reader :dir
+
+        def initialize(dir, file_system)
+            @dir, @file_system = dir, file_system
+        end
+
+        def files
+            @file_system.glob_relative("#{dir}/*.yml")
+        end
+
+        def ==(other)
+            eql? other
+        end
+
+        def eql?(other)
+            dir = other.dir
+        end
+        
+        def to_s
+            "Module[#{dir}]"
+        end
+    end
+end

data/lib/cfoo/parser.rb

@@ -0,0 +1,82 @@
+require 'cfoo/el_parser'
+require 'cfoo/yaml'
+
+class Object
+    def expand_el
+        raise Cfoo::Parser::ElParseError, "Couldn't parse object '#{self}'. I don't know how to parse an instance of '#{self.class}'"
+    end
+end
+
+class Fixnum
+    def expand_el
+        self
+    end
+end
+
+class FalseClass
+    def expand_el
+        to_s
+    end
+end
+
+class TrueClass
+    def expand_el
+        to_s
+    end
+end
+
+class String
+    def expand_el
+        Cfoo::ElParser.parse(self)
+    end
+end
+
+class Array
+    def expand_el
+        map {|element| element.expand_el }
+    end
+end
+
+class Hash
+    def expand_el
+        Hash[map do |key, value|
+            [ key, value.expand_el ]
+        end]
+    end
+end
+
+module YAML
+   class DomainType
+      def expand_el
+         case type_id
+         when "Ref"
+            { "Ref" => value.expand_el }
+         when /^(Base64|FindInMap|GetAtt|GetAZs|Join)$/
+            { "Fn::#{type_id}" => value.expand_el }
+         when "Concat"
+            { "Fn::Join" => ['', value.expand_el] }
+         else
+            super
+         end 
+      end
+   end
+end
+
+module Cfoo
+    class Parser
+        class ElParseError < RuntimeError
+        end
+
+        def initialize(file_system)
+            @file_system = file_system
+        end
+
+        def parse_file(file_name)
+            @file_system.parse_file(file_name).expand_el
+        rescue Parslet::ParseFailed => failure
+           puts "Failed to parse '#{file_name}':"
+           puts failure.cause.ascii_tree
+           raise failure
+        end
+    end
+end

data/lib/cfoo/processor.rb

@@ -0,0 +1,38 @@
+
+class Hash
+    def deep_merge(other)                                                            
+        merge(other) do |key, our_item, their_item|                                  
+            if our_item.respond_to? :deep_merge                                      
+                our_item.deep_merge(their_item)                                      
+            elsif our_item.respond_to? :concat                                       
+                our_item.concat(their_item).uniq                                     
+            else                                                                     
+                their_item                                                           
+            end                                                                      
+        end                                                                          
+    end
+end
+
+module Cfoo
+    class Processor
+        def initialize(parser, project)
+            @parser, @project = parser, project
+        end
+
+        def process(*filenames)
+            project_map = { "AWSTemplateFormatVersion" => "2010-09-09" }
+            filenames.each do |filename|
+                module_map = @parser.parse_file filename
+                project_map = project_map.deep_merge module_map
+            end
+            project_map
+        end
+
+        def process_all
+            project_files = @project.modules.inject([]) do |all_files, mod|
+                all_files += mod.files
+            end
+            process *project_files
+        end
+    end
+end

data/lib/cfoo/project.rb

@@ -0,0 +1,16 @@
+require 'cfoo/module'
+
+module Cfoo
+    class Project
+        def initialize(file_system)
+            @file_system = file_system 
+        end
+
+        def modules
+            module_dirs = @file_system.glob_relative("modules/*")
+            module_dirs.map do |dir|
+                Module.new(dir, @file_system)
+            end
+        end
+    end
+end

data/lib/cfoo/renderer.rb

@@ -0,0 +1,9 @@
+require 'json'
+
+module Cfoo
+    class Renderer
+        def render(hash)
+            JSON.pretty_unparse hash
+        end
+    end
+end

data/lib/cfoo/version.rb

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

data/lib/cfoo/yaml.rb

@@ -0,0 +1,34 @@
+require 'yaml'
+
+module YAML
+
+    def self.add_domain_type_that_gets_loaded_like_in_ruby_1_8(domain_type)
+        add_domain_type "", domain_type do |tag, value|
+            DomainType.create(domain_type, value)
+        end
+    end
+
+    class DomainType
+        attr_accessor :domain, :type_id, :value
+
+        def self.create(type_id, value)
+            type = self.allocate
+            type.domain = "yaml.org,2002"
+            type.type_id = type_id
+            type.value = value
+            type
+        end
+
+        def ==(other)
+            eq? other
+        end
+
+        def eq?(other)
+            if other.respond_to?(:domain) && other.respond_to?(:type_id) && other.respond_to?(:value)
+                domain == other.domain && type_id == other.type_id && value == other.value
+            else
+                false
+            end
+        end
+    end
+end

data/lib/cfoo/yaml_parser.rb

@@ -0,0 +1,16 @@
+require 'cfoo/yaml'
+
+module Cfoo
+    class YamlParser
+
+        CFN_DOMAIN_TYPES = [ "GetAZs", "Ref", "Join", "Concat", "GetAtt", "FindInMap", "Base64" ]
+
+        def load_file(file_name)
+            #TODO: raise errors if "value" isn't the right type
+            CFN_DOMAIN_TYPES.each do |domain_type|
+                YAML.add_domain_type_that_gets_loaded_like_in_ruby_1_8(domain_type)
+            end
+            YAML.load_file(file_name)
+        end
+    end
+end

data/spec/cfoo/cfoo_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+module Cfoo
+    describe Cfoo do
+        let(:processor) { double('processor') }
+        let(:renderer) { double('renderer') }
+        let(:stdout) { double('stdout') }
+        let(:cfoo) { Cfoo.new(processor, renderer, stdout) }
+
+        describe "#process" do
+            it "processes the specified files" do
+                output_map = double("output_map")
+                processor.should_receive(:process).with("1.yml", "2.yml").and_return output_map
+                renderer.should_receive(:render).with(output_map).and_return "cfn_template"
+                stdout.should_receive(:puts).with "cfn_template"
+                cfoo.process("1.yml", "2.yml")
+            end
+        end
+
+        describe "#build_project" do
+            # TODO: but it doesn't know about the project!
+            it "processes all files in the project" do
+                output_map = double("output_map")
+                processor.should_receive(:process_all).and_return output_map
+                renderer.should_receive(:render).with(output_map).and_return "cfn_template"
+                stdout.should_receive(:puts).with "cfn_template"
+                cfoo.build_project
+            end
+        end
+    end
+end

data/spec/cfoo/el_parser_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+module Cfoo
+    describe ElParser do
+        let(:parser) { ElParser }
+        it 'turns simple EL references into CloudFormation "Ref" maps' do
+            parser.parse("$(orange)").should == {"Ref" => "orange"}
+        end
+
+        it 'turns EL references embedded in strings into appended arrays' do
+            parser.parse("large $(MelonType) melon").should == {"Fn::Join" => [ "" , [ "large ", { "Ref" => "MelonType" }, " melon" ]]}
+        end
+
+        it 'turns multiple EL references embedded in strings into single appended arrays' do
+            parser.parse("I have $(number) apples and $(otherNumber) oranges").should == {"Fn::Join" => [ "" , ["I have ", { "Ref" => "number" }, " apples and ", { "Ref" => "otherNumber" }, " oranges" ]]}
+        end
+
+        it 'turns EL attribute references into CloudFormation "GetAtt" maps' do
+            parser.parse("$(apple.color)").should == {"Fn::GetAtt" => ["apple", "color"]}
+        end
+
+        it 'turns EL attribute map references into CloudFormation "GetAtt" maps' do
+            parser.parse("$(apple[color])").should == {"Fn::GetAtt" => ["apple", "color"]}
+        end
+
+        it 'turns EL map references into CloudFormation "FindInMap" maps' do
+            parser.parse("$(fruit[apple][color])").should == {"Fn::FindInMap" => ["fruit", "apple", "color"]}
+        end
+
+        it "doesn't expand escaped EL" do
+            parser.parse("\\$(apple.color) apple").should == "$(apple.color) apple"
+        end
+
+        it "copes with lone backslashes" do
+            parser.parse("\\ apple").should == "\\ apple"
+        end
+
+        it "copes with EL in maps" do
+            parser.parse("$(Fruit[$(AWS::FruitType)][$(FruitProperty)])").should == {"Fn::FindInMap" => ["Fruit", {"Ref" => "AWS::FruitType"}, {"Ref" => "FruitProperty"}]}
+        end
+
+        it "copes with EL in references" do
+            parser.parse("$($(appleProperty))").should == {"Ref" => {"Ref" => "appleProperty"}}
+        end
+    end
+end
+