cfoo 0.0.1 → 0.0.2

data/lib/cfoo/constants.rb

@@ -0,0 +1,3 @@
+module Cfoo
+    CLOUDFORMATION_FUNCTIONS = %w[Base64 FindInMap GetAtt GetAZs Join]
+end

data/lib/cfoo/el_parser.rb

@@ -1,5 +1,6 @@
 require 'rubygems'
 require 'parslet'
+require 'cfoo/array'
 
 module Cfoo
     class ElParser < Parslet::Parser
@@ -16,17 +17,20 @@ module Cfoo
         #    #TODO: handle this properly
         end
 
-        rule(:space) { match('\s') }
+        rule(:space) { match('\s').repeat(1) }
         rule(:space?) { space.maybe }
         rule(:escaped_dollar) { str('\$').as(:escaped_dollar) }
         rule(:lone_backslash) { str('\\').as(:lone_backslash) }
-        rule(:lparen) { str('(') }
+        rule(:lparen) { str('(') >> space? }
         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(:comma) { str(",") >> space? }
+        rule(:text_character) { match['^\\\\$'] }
+        rule(:identifier) { match['a-zA-Z0-9_\-:'].repeat(1).as(:identifier) >> space? }
+        rule(:text) { text_character.repeat(1).as(:text) }
+
         rule(:attribute_reference) do
             (
                 expression.as(:reference) >> (
@@ -42,13 +46,21 @@ module Cfoo
                 str("[") >> expression.as(:value) >> str("]")
             ).as(:mapping)
         end
+        rule(:function_call) do
+            (
+                identifier.as(:function) >>
+                lparen >>
+                (expression >> (comma >> expression).repeat).as(:arguments).maybe >>
+                rparen
+            ).as(:function_call)
+        end
         rule(:reference) do
             expression.as(:reference)
         end
 
         rule(:expression) { el | identifier }
         rule(:el) do
-            str("$(") >> ( mapping | attribute_reference | reference ) >> str(")")
+            str("$(") >> ( mapping | attribute_reference | function_call | reference ) >> str(")")
         end
         rule(:string) do
             ( escaped_dollar | lone_backslash | el | text ).repeat.as(:string)
@@ -74,26 +86,29 @@ module Cfoo
             { "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
+        rule(:function_call => { :function => simple(:function) }) do
+            { "Fn::#{function}" => "" }
+        end
+
+        rule(:function_call => { :function => simple(:function), :arguments => simple(:argument) }) do
+            { "Fn::#{function}" => argument }
+        end
+
+        rule(:function_call => { :function => simple(:function), :arguments => subtree(:arguments) }) do
+            { "Fn::#{function}" => arguments }
+        end
+
+        rule(:mapping => { :map => subtree(:map), :key => subtree(:key), :value => subtree(:value)}) do
+            { "Fn::FindInMap" => [map, key, value] }
+        end
 
-            parts.reject! {|part| part.empty? }
+        rule(:string => subtree(:string_parts)) do
+            # EL is parsed separately from other strings
+            parts = string_parts.join_adjacent_strings
 
             if parts.size == 1
                 parts.first

data/lib/cfoo/factory.rb

@@ -0,0 +1,25 @@
+require "cfoo/cfoo"
+require "cfoo/file_system"
+require "cfoo/parser"
+require "cfoo/processor"
+require "cfoo/project"
+require "cfoo/renderer"
+require "cfoo/yaml_parser"
+
+module Cfoo
+    class Factory
+        def initialize(stdout, stderr)
+            @stdout, @stderr = stdout, stderr
+        end
+
+        def cfoo
+            yaml_parser = YamlParser.new
+            file_system = FileSystem.new(".", yaml_parser)
+            project = Project.new(file_system)
+            parser = Parser.new(file_system)
+            processor = Processor.new(parser, project)
+            renderer = Renderer.new
+            cfoo = Cfoo.new(processor, renderer, @stdout, @stderr)
+        end
+    end
+end

data/lib/cfoo/file_system.rb

@@ -14,6 +14,26 @@ module Cfoo
             @yaml_parser.load_file(resolve_file file_name)
         end
 
+        def open(file_name, &block)
+            File.open(resolve_file(file_name), &block)
+        end
+
+        def find_coordinates(string, file_name)
+            matching_lines = []
+            open(file_name) do |file|
+                file.each_with_index do|line, row_index|
+                    if line.include? string
+                        column_index = line.index(string)
+                        row = row_index + 1
+                        column = column_index + 1
+                        return [row, column]
+                    end
+                end
+            end
+            #TODO test this
+            raise "Couldn't find '#{string}' in '#{file}'"
+        end
+
         def glob_relative(path)
             absolute_files = Dir.glob(resolve_file path)
             absolute_files.map do |file|

data/lib/cfoo/module.rb

@@ -17,9 +17,5 @@ module Cfoo
         def eql?(other)
             dir = other.dir
         end
-        
-        def to_s
-            "Module[#{dir}]"
-        end
     end
 end

data/lib/cfoo/parser.rb

@@ -1,9 +1,20 @@
+require 'cfoo/constants'
 require 'cfoo/el_parser'
 require 'cfoo/yaml'
+require 'rubygems'
+require 'parslet'
+
+module Parslet
+    class Source
+        def str
+            @str
+        end
+    end
+end
 
 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}'"
+        raise Cfoo::Parser::ElExpansionError, "Couldn't parse object '#{self}'. I don't know how to parse an instance of '#{self.class}'"
     end
 end
 
@@ -46,25 +57,55 @@ class Hash
 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
+    class DomainType
+
+        CLOUDFORMATION_FUNCTION_REGEX = %r[^(#{::Cfoo::CLOUDFORMATION_FUNCTIONS.join '|'})$]
+
+        def expand_el
+            case type_id
+            when "Ref"
+                { "Ref" => value.expand_el }
+            when CLOUDFORMATION_FUNCTION_REGEX
+                { "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
+        class ParseError < RuntimeError
+        end
+
+        class CfooParseError < ParseError
+            attr_reader :file_name, :cause
+
+            def initialize(file_name, failure)
+                super("Failed to parse '#{file_name}':\n#{failure}")
+                @file_name = file_name
+                @cause = cause
+            end
+        end
+
+        class ElExpansionError < ParseError
+        end
+
+        class ElParseError < ParseError
+            attr_accessor :file_name, :cause, :source, :line, :column
+
+            def initialize(file_name, cause, source, line, column)
+                super("Failed to parse '#{file_name}':\nSource: #{source}\nLocation: #{file_name} line #{line}, column #{column} \nCause: #{cause.ascii_tree}")
+
+                @file_name = file_name
+                @cause = cause
+                @source = source
+                @line = line
+                @column = column
+            end
         end
 
         def initialize(file_system)
@@ -74,9 +115,15 @@ module Cfoo
         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
+            #TODO: spec this somehow
+            cause = failure.cause
+            source = cause.source.str
+            row, column = @file_system.find_coordinates(source, file_name)
+            raise ElParseError.new(file_name, cause, source, row, column)
+        rescue ElExpansionError => failure
+            raise failure
+        rescue Exception => failure
+            raise CfooParseError.new(file_name, failure)
         end
     end
 end

data/lib/cfoo/processor.rb

@@ -1,15 +1,15 @@
 
 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                                                                          
+    def deep_merge(other)
+        merge(other) do |key, our_item, their_item|
+            if [our_item, their_item].all? {|item| item.respond_to? :deep_merge }
+                our_item.deep_merge(their_item)
+            elsif [our_item, their_item].all? {|item| item.respond_to?(:+) && item.respond_to?(:uniq) }
+                our_item.concat(their_item).uniq
+            else
+                their_item
+            end
+        end
     end
 end
 

data/lib/cfoo/version.rb

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

data/lib/cfoo/yaml_parser.rb

@@ -1,9 +1,10 @@
+require 'cfoo/constants'
 require 'cfoo/yaml'
 
 module Cfoo
     class YamlParser
 
-        CFN_DOMAIN_TYPES = [ "GetAZs", "Ref", "Join", "Concat", "GetAtt", "FindInMap", "Base64" ]
+        CFN_DOMAIN_TYPES = ::Cfoo::CLOUDFORMATION_FUNCTIONS + %w[Ref Concat]
 
         def load_file(file_name)
             #TODO: raise errors if "value" isn't the right type

data/spec/cfoo/array_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Array do
+    describe "#join_adjacent_strings" do
+        context "when the array is empty" do
+            it "returns an array with an empty string in it" do
+                [].join_adjacent_strings.should == []
+            end
+        end
+
+        context "when array has only strings" do
+            it "returns an array with them all joined together" do
+                ["j", "oi", "nme"].join_adjacent_strings.should == ["joinme"]
+            end
+        end
+
+        context "when array has some strings and other things" do
+            it "returns an array with all the adjacent strings joined together" do
+                [["1"], "a", "bc", ["2", "3"], "d", " ", { "e" => "f"}, ""].join_adjacent_strings.should == [["1"], "abc", ["2", "3"], "d ", { "e"=> "f" }, ""]
+            end
+        end
+    end
+end

data/spec/cfoo/cfoo_spec.rb

@@ -5,7 +5,8 @@ module Cfoo
         let(:processor) { double('processor') }
         let(:renderer) { double('renderer') }
         let(:stdout) { double('stdout') }
-        let(:cfoo) { Cfoo.new(processor, renderer, stdout) }
+        let(:stderr) { double('stderr') }
+        let(:cfoo) { Cfoo.new(processor, renderer, stdout, stderr) }
 
         describe "#process" do
             it "processes the specified files" do
@@ -15,6 +16,15 @@ module Cfoo
                 stdout.should_receive(:puts).with "cfn_template"
                 cfoo.process("1.yml", "2.yml")
             end
+
+            context "when an error is raised" do
+                it "prints it to stderr" do
+                    error = RuntimeError.new("parse fail")
+                    processor.should_receive(:process).with("1.yml").and_raise error
+                    stderr.should_receive(:puts).with error
+                    cfoo.process("1.yml")
+                end
+            end
         end
 
         describe "#build_project" do
@@ -26,6 +36,15 @@ module Cfoo
                 stdout.should_receive(:puts).with "cfn_template"
                 cfoo.build_project
             end
+
+            context "when an error is raised" do
+                it "prints it to stderr" do
+                    error = RuntimeError.new("parse fail")
+                    processor.should_receive(:process_all).and_raise error
+                    stderr.should_receive(:puts).with error
+                    cfoo.build_project
+                end
+            end
         end
     end
 end

data/spec/cfoo/el_parser_spec.rb

@@ -27,6 +27,33 @@ module Cfoo
             parser.parse("$(fruit[apple][color])").should == {"Fn::FindInMap" => ["fruit", "apple", "color"]}
         end
 
+        context "parsing function calls" do
+            it 'turns no-arg function calls into "Fn" maps with an empty string as the value' do
+                parser.parse("$(Fruit())").should == {"Fn::Fruit" => ""}
+            end
+
+            it 'turns single-arg function calls into "Fn" maps with the string as the value' do
+                parser.parse("$(Fruit(Favorite))").should == {"Fn::Fruit" => "Favorite"}
+            end
+
+            it 'turns multi-arg function calls into "Fn" maps with the an array of the arg strings as the value' do
+                parser.parse("$(Fruit(One, Two, Three))").should == {"Fn::Fruit" => [ "One", "Two", "Three" ]}
+            end
+
+            it 'copes with no spaces between function arguments' do
+                parser.parse("$(Fruit(One,Two,Three))").should == {"Fn::Fruit" => [ "One", "Two", "Three" ]}
+            end
+
+            it 'copes with spaces between around function arguments' do
+                parser.parse("$(Fruit(  One   , Two ,Three   ))").should == {"Fn::Fruit" => [ "One", "Two", "Three" ]}
+            end
+
+            it 'copes with EL as arguments' do
+                parser.parse("$(FindInMap(AWSRegionArch2AMI, $(AWS::Region), $(AWSInstanceType2Arch[FrontendInstanceType][Arch])))").
+                    should == {"Fn::FindInMap" => ["AWSRegionArch2AMI", {"Ref" => "AWS::Region"}, { "Fn::FindInMap" => ["AWSInstanceType2Arch", "FrontendInstanceType", "Arch"] }]}
+            end
+        end
+
         it "doesn't expand escaped EL" do
             parser.parse("\\$(apple.color) apple").should == "$(apple.color) apple"
         end
@@ -42,6 +69,10 @@ module Cfoo
         it "copes with EL in references" do
             parser.parse("$($(appleProperty))").should == {"Ref" => {"Ref" => "appleProperty"}}
         end
+
+        it "handles letters, numbers, underscores, and colons in identifiers" do
+            parser.parse("$(AWS::Hip_2_the_groove_identifier)").should == {"Ref" => "AWS::Hip_2_the_groove_identifier"}
+        end
     end
 end
 

data/spec/cfoo/factory_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Cfoo
+    describe Factory do
+        let(:stdout) { double('stderr') }
+        let(:stderr) { double('stderr') }
+        let(:factory) { Factory.new(stdout, stderr) }
+
+        describe "#cfoo" do
+            it "builds a Cfoo instance with its dependencies" do
+                cfoo = factory.cfoo
+                cfoo.class.should be Cfoo
+
+                cfoo.instance_eval{ @stdout }.should be stdout
+                cfoo.instance_eval{ @stderr }.should be stderr
+                cfoo.instance_eval{ @processor }.class.should be Processor
+                cfoo.instance_eval{ @renderer }.class.should be Renderer
+            end
+        end
+
+    end
+end