cloud_compose 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8d01e1a9806a945e7b31002083f917ce6879392eb6238d0e26558a81f567b9b4
+  data.tar.gz: 004dac72cc30a68a8cd21bdc4be8b11aa7e28c7b6f9a45b9bfd83e94043008cc
+SHA512:
+  metadata.gz: 9a60c29f02ec15e8297b1c46a72a1a6b0c95cf6756f48dfa99929fd67bba81588cd5fc7d0bd8e1c2117c8a7eefbbc79b57234785af301908c274d9ca57d40a23
+  data.tar.gz: d585de3c2d5eccd3fef396a54701457021beb05422042d4f5facd1f51ed151b63c946bf817f1b1872ac4adc0fbc63b21b990fc1dc64ecf70708bd4d8229caf45

data/README.md

@@ -0,0 +1,74 @@
+# CloudCompose
+
+Compose multiple cloud formation templates into one file.
+
+`cloud-compose ./template.yml ./output`
+
+```yaml
+# template.yml
+---
+$cloud_compose:
+  parameters:
+    GlobalName: 'TestTemplate'
+  imports:
+    - name: SubTemplateOne
+      path: ./sub_readme.yml
+    - name: SubTemplateTwo
+      path: ./sub_readme.yml
+---
+
+Resources:
+  $(GlobalName)MainResource:
+    Type: AWS::Fake::Thing
+    Properties:
+      Name: My Main Resource
+  SecondaryResource:
+    Type: AWS::Fake::Thing
+    Properties:
+      ParentThing: !Ref $(GlobalName)MainResource
+```
+
+```yaml
+# sub_readme.yml
+---
+$cloud_compose:
+  partial: true
+---
+
+Resources:
+  $(name)Resource:
+    Type: AWS::Fake::Thing
+    Properties:
+      ParentThing: !Ref $(GlobalName)MainResource
+Outputs:
+  $(name)ResourceOutput:
+    Value: !Ref $(name)Resource
+
+```
+
+```yaml
+# Output
+---
+Resources:
+  TestTemplateMainResource:
+    Type: AWS::Fake::Thing
+    Properties:
+      Name: My Main Resource
+  SecondaryResource:
+    Type: AWS::Fake::Thing
+    Properties:
+      ParentThing: !Ref TestTemplateMainResource
+  SubTemplateOneResource:
+    Type: AWS::Fake::Thing
+    Properties:
+      ParentThing: !Ref TestTemplateMainResource
+  SubTemplateTwoResource:
+    Type: AWS::Fake::Thing
+    Properties:
+      ParentThing: !Ref TestTemplateMainResource
+Outputs:
+  SubTemplateOneResourceOutput:
+    Value: !Ref SubTemplateOneResource
+  SubTemplateTwoResourceOutput:
+    Value: !Ref SubTemplateTwoResource
+```

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler/gem_tasks'
+task default: :spec

data/lib/cloud_compose/config.rb

@@ -0,0 +1,41 @@
+require_relative 'parser'
+
+module CloudCompose
+  class Config
+    Import = Struct.new(:name, :path, :parameters)
+
+    def initialize(config, root)
+      @root = root
+      params = CloudCompose::Parser.load_yaml(config)
+      @config = params.fetch('$cloud_compose')
+    end
+
+    def partial?
+      @config.fetch('partial', false) == true
+    end
+
+    def imports
+      @config.fetch('imports', []).map do |obj|
+        Import.new(
+          obj.fetch('name'),
+          import_path(obj),
+          obj.fetch('parameters', {})
+        )
+      end
+    end
+
+    def parameters
+      @config.fetch('parameters', {})
+    end
+
+    def required_parameters
+      @config.fetch('require', [])
+    end
+
+    private
+
+    def import_path(obj)
+      File.expand_path(obj.fetch('path'), @root)
+    end
+  end
+end

data/lib/cloud_compose/parser.rb

@@ -0,0 +1,45 @@
+require 'psych'
+
+require_relative 'tags/simple_type'
+
+require_relative 'tags/get_att'
+require_relative 'tags/sub'
+
+module CloudCompose
+  class Parser
+    CUSTOM_TAGS = {
+      '!And' => CloudCompose::Tags::And,
+      '!Base64' => CloudCompose::Tags::Base64,
+      '!Cidr' => CloudCompose::Tags::Cidr,
+      '!Condition' => CloudCompose::Tags::Condition,
+      '!Equals' => CloudCompose::Tags::Equals,
+      '!FindInMap' => CloudCompose::Tags::FindInMap,
+      '!GetAZs' => CloudCompose::Tags::GetAzs,
+      '!GetAtt' => CloudCompose::Tags::GetAtt,
+      '!If' => CloudCompose::Tags::If,
+      '!ImportValue' => CloudCompose::Tags::ImportValue,
+      '!Join' => CloudCompose::Tags::Join,
+      '!Not' => CloudCompose::Tags::Not,
+      '!Or' => CloudCompose::Tags::Or,
+      '!Ref' => CloudCompose::Tags::Ref,
+      '!Select' => CloudCompose::Tags::Select,
+      '!Split' => CloudCompose::Tags::Split,
+      '!Sub' => CloudCompose::Tags::Sub,
+      '!Transform' => CloudCompose::Tags::Transform
+    }.freeze
+
+    class << self
+      def load_yaml(content)
+        Psych.safe_load(content, CUSTOM_TAGS.values)
+      end
+
+      def dump_yaml(object)
+        Psych.dump(object)
+      end
+    end
+  end
+end
+
+CloudCompose::Parser::CUSTOM_TAGS.each do |key, klass|
+  Psych.add_tag(key, klass)
+end

data/lib/cloud_compose/processor.rb

@@ -0,0 +1,15 @@
+module CloudCompose
+  class Processor
+    PRE_PROCESSOR_PARAMETER_REGEXP = Regexp.new('\$\((?:[a-zA-Z0-9_]+)\)?').freeze
+    PRE_PROCESSOR_PARAMETER_NAME_REGEXP = Regexp.new('\A\$\((?<token>[a-zA-Z0-9_]+)\)?\z').freeze
+
+    class << self
+      def preprocess(content, context)
+        content.gsub(PRE_PROCESSOR_PARAMETER_REGEXP) do |matched|
+          key = PRE_PROCESSOR_PARAMETER_NAME_REGEXP.match(matched)['token']
+          context.fetch(key)
+        end
+      end
+    end
+  end
+end

data/lib/cloud_compose/tags/base.rb

@@ -0,0 +1,46 @@
+module CloudCompose
+  module Tags
+    class InvalidTypeError < StandardError
+      attr_reader :tag
+      attr_reader :type
+
+      def initialize(tag, type)
+        @tag = tag
+        @type = type
+        super("Invalid Type (#{type}) for tag `#{tag}`")
+      end
+    end
+
+    class Base
+      attr_reader :type
+
+      attr_reader :value
+
+      def type_from_coder(coder)
+        coder.type
+      end
+
+      def value_from_coder(_coder)
+        raise NotImplementedError, "Missing #{__method__} override."
+      end
+
+      def init_with(coder)
+        initialize(
+          type_from_coder(coder),
+          value_from_coder(coder)
+        )
+      end
+
+      def encode_with(coder)
+        coder.send("#{type.to_sym}=", value)
+      end
+
+      private
+
+      def initialize(type, value)
+        @type = type
+        @value = value
+      end
+    end
+  end
+end

data/lib/cloud_compose/tags/get_att.rb

@@ -0,0 +1,22 @@
+require_relative 'base'
+
+module CloudCompose
+  module Tags
+    class GetAtt < Base
+      def type_from_coder(_coder)
+        :seq
+      end
+
+      def value_from_coder(coder)
+        case coder.type
+        when :seq
+          coder.seq
+        when :scalar
+          coder.scalar.split('.', 2)
+        else
+          raise InvalidTypeError.new(coder.tag, coder.type)
+        end
+      end
+    end
+  end
+end

data/lib/cloud_compose/tags/map_type.rb

@@ -0,0 +1,16 @@
+require_relative 'base'
+
+module CloudCompose
+  module Tags
+    class MapType < Base
+      def value_from_coder(coder)
+        case coder.type
+        when :map
+          coder.map
+        else
+          raise InvalidTypeError.new(coder.tag, coder.type)
+        end
+      end
+    end
+  end
+end

data/lib/cloud_compose/tags/scalar_type.rb

@@ -0,0 +1,16 @@
+require_relative 'base'
+
+module CloudCompose
+  module Tags
+    class ScalarType < Base
+      def value_from_coder(coder)
+        case coder.type
+        when :scalar
+          coder.scalar
+        else
+          raise InvalidTypeError.new(coder.tag, coder.type)
+        end
+      end
+    end
+  end
+end

data/lib/cloud_compose/tags/sequenced_type.rb

@@ -0,0 +1,16 @@
+require_relative 'base'
+
+module CloudCompose
+  module Tags
+    class SequencedType < Base
+      def value_from_coder(coder)
+        case coder.type
+        when :seq
+          coder.seq
+        else
+          raise InvalidTypeError.new(coder.tag, coder.type)
+        end
+      end
+    end
+  end
+end

data/lib/cloud_compose/tags/simple_type.rb

@@ -0,0 +1,24 @@
+require_relative 'map_type'
+require_relative 'scalar_type'
+require_relative 'sequenced_type'
+
+module CloudCompose
+  module Tags
+    class And < SequencedType; end
+    class Base64 < ScalarType; end
+    class Cidr < SequencedType; end
+    class Condition < ScalarType; end
+    class Equals < SequencedType; end
+    class FindInMap < SequencedType; end
+    class GetAzs < ScalarType; end
+    class If < SequencedType; end
+    class ImportValue < ScalarType; end
+    class Join < SequencedType; end
+    class Not < SequencedType; end
+    class Or < SequencedType; end
+    class Ref < ScalarType; end
+    class Select < SequencedType; end
+    class Split < SequencedType; end
+    class Transform < MapType; end
+  end
+end

data/lib/cloud_compose/tags/sub.rb

@@ -0,0 +1,23 @@
+require_relative 'base'
+
+module CloudCompose
+  module Tags
+    class Sub < Base
+      def type_from_coder(_coder)
+        :seq
+      end
+
+      def value_from_coder(coder)
+        case coder.type
+        when :seq
+          seq = coder.seq.dup
+          seq.fill({}, seq.length...2)
+        when :scalar
+          [coder.scalar, {}]
+        else
+          raise InvalidTypeError.new(coder.tag, coder.type)
+        end
+      end
+    end
+  end
+end

data/lib/cloud_compose/template.rb

@@ -0,0 +1,172 @@
+require 'pathname'
+require 'time'
+require 'digest'
+
+require_relative 'parser'
+require_relative 'config'
+require_relative 'processor'
+
+module CloudCompose
+  class Template
+    IMPORT_MERGE_KEYS = %w[
+      Metadata
+      Parameters
+      Mappings
+      Conditions
+      Transform
+      Resources
+      Outputs
+    ].freeze
+
+    class Error < StandardError; end
+
+    Partial = Struct.new(:name, :template, :parameters) do
+      def context
+        Hash(parameters).merge('name' => name)
+      end
+    end
+
+    attr_reader :root, :config, :content, :file_name
+
+    def initialize(path, pwd)
+      @pwd = pwd
+      @file_name = File.basename(path)
+      @root = Pathname.new(File.dirname(path))
+      content = File.read(path)
+      @checksum = Digest::SHA256.hexdigest(content)
+      parts = content.split(/^---/, 3)
+      @config = CloudCompose::Config.new(parts[1], @root)
+      @content = parts[2]
+    end
+
+    def to_h
+      template_body = create_hash(parameters)
+      imported.each do |imp|
+        formatted_imp = imp.template.send(:create_hash, imp.context)
+        merge_imported(template_body, formatted_imp, imp.name)
+      end
+
+      template_body.keys.each do |key|
+        template_body.delete(key) if template_body[key].empty?
+      end
+
+      template_body
+    end
+
+    def to_s
+      yaml = CloudCompose::Parser.dump_yaml(to_h)
+
+      <<~EOF
+        # This Template was generated on #{Time.now.utc.iso8601} by CloudCompose #{CloudCompose::VERSION}
+        #
+        # Structure
+        #{description(0)}
+        #
+        # Integrity
+        #{checksum_print}
+        #
+        #{yaml}
+      EOF
+    end
+
+    def imported
+      preload_imports!
+      @imported
+    end
+
+    def parameters
+      @config.parameters
+    end
+
+    def required_parameters
+      @config.required_parameters
+    end
+
+    def description(depth)
+      callouts = depth.zero? ? '├─' : '↳'
+      leading = depth.zero? ? '' : '|'
+      padding = ' ' * depth
+      joined = imported.map { |i| i.template.description(depth + 2) }
+      [
+        "# #{leading}#{padding}#{callouts} #{working_path}/#{file_name}",
+        *joined
+      ].join("\n")
+    end
+
+    def checksums
+      return @checksums if @checksums
+
+      checksums = {}
+      checksums["#{working_path}/#{file_name}"] = @checksum
+      imported.each do |imp|
+        imp.template.checksums.each do |key, value|
+          checksums[key] = value
+        end
+      end
+      @checksums = checksums
+      @checksums
+    end
+
+    private
+
+    def checksum_print
+      checksums.keys.sort.map do |key|
+        "#   #{checksums[key]} ✓ #{key}"
+      end.join("\n")
+    end
+
+    def working_path
+      root.to_s.gsub("#{@pwd}/", '')
+    end
+
+    def merge_imported(body, imported, name)
+      IMPORT_MERGE_KEYS.each do |merge_key|
+        current = body.fetch(merge_key, {})
+        imported_current = imported.fetch(merge_key, {})
+        imported_current.keys.each do |merging|
+          next unless current.key?(merging)
+
+          raise Error, "Template #{file_name} already contains a key #{merge_key}.#{merging}. Merging from #{name}"
+        end
+        body[merge_key] = current.merge(imported_current)
+      end
+    end
+
+    def create_hash(context)
+      CloudCompose::Parser.load_yaml(
+        CloudCompose::Processor.preprocess(content, context)
+      )
+    end
+
+    def preload_imports!
+      return if defined?(@imported)
+
+      @imported = @config.imports.map do |imported|
+        create_template(imported)
+      end
+    end
+
+    def validate_parameters!(imported, full_params, required)
+      required.each do |key|
+        next if full_params.key?(key)
+
+        raise Error, "Missing Required Parameter #{key} in #{imported.name}"
+      end
+    end
+
+    def create_template(imported)
+      template = CloudCompose::Template.new(imported.path, @pwd)
+      raise Error, "Template #{File.basename(imported.path)} imported from #{@file_name} is not a partial" unless template.config.partial?
+
+      full_params = parameters.merge(imported.parameters).merge(template.parameters)
+
+      validate_parameters!(imported, full_params, template.required_parameters)
+
+      Partial.new(
+        imported.name,
+        template,
+        full_params
+      )
+    end
+  end
+end

data/lib/cloud_compose/version.rb

@@ -0,0 +1,3 @@
+module CloudCompose
+  VERSION = '0.1.0'.freeze
+end

data/lib/cloud_compose.rb

@@ -0,0 +1,5 @@
+require 'cloud_compose/template'
+require 'cloud_compose/version'
+
+module CloudCompose
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: cloud_compose
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Maddie Schipper
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-03-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.8'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.16'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: ''
+email:
+- me@maddiesch.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- lib/cloud_compose.rb
+- lib/cloud_compose/config.rb
+- lib/cloud_compose/parser.rb
+- lib/cloud_compose/processor.rb
+- lib/cloud_compose/tags/base.rb
+- lib/cloud_compose/tags/get_att.rb
+- lib/cloud_compose/tags/map_type.rb
+- lib/cloud_compose/tags/scalar_type.rb
+- lib/cloud_compose/tags/sequenced_type.rb
+- lib/cloud_compose/tags/simple_type.rb
+- lib/cloud_compose/tags/sub.rb
+- lib/cloud_compose/template.rb
+- lib/cloud_compose/version.rb
+homepage: ''
+licenses:
+- MIT
+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: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: ''
+test_files: []