sparkle_formation 0.1.0

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## v0.1.0
+* Initial release

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,23 @@
+PATH
+  remote: .
+  specs:
+    sparkle_formation (0.1.0)
+      attribute_struct (~> 0.1.6)
+
+PATH
+  remote: /home/spox/Projects/chrisroberts/attribute_struct
+  specs:
+    attribute_struct (0.1.7)
+      hashie (>= 2.0.0)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    hashie (2.0.5)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  attribute_struct!
+  sparkle_formation!

data/README.md

@@ -0,0 +1,262 @@
+# SparkleFormation
+
+AWS CloudFormation template building tools for Ruby. Yay!
+
+## What's it do?
+
+Provides a very loose DSL to describe an AWS CloudFormation
+in Ruby.
+
+## Is that it?
+
+Yes. Well, kinda. It also has some extra features, like defining
+components, dynamics, merging, AWS builtin function helpers, and
+conjouring magic (to get unicorns).
+
+## What's it look like?
+
+Lets use one of the example CF templates that creates an EC2 instance. First
+we can just convert it into a single file (ec2_example.rb):
+
+```ruby
+SparkleFormation.new('ec2_example') do
+  description "AWS CloudFormation Sample Template EC2InstanceSample: Create an Amazon EC2 instance running the Amazon Linux AMI. The AMI is chosen based on the region in which the stack is run. This example uses the default security group, so to SSH to the new instance using the KeyPair you enter, you will need to have port 22 open in your default security group. **WARNING** This template an Amazon EC2 instances. You will be billed for the AWS resources used if you create a stack from this template."
+
+  parameters do
+    key_name do
+      description 'Name of an existing EC2 KeyPair to enable SSH access to the instance'
+      type 'String'
+    end
+  end
+
+  mappings.region_map do
+    _set('us-east-1', :ami => 'ami-7f418316')
+    _set('us-east-1', :ami => 'ami-7f418316')
+    _set('us-west-1', :ami => 'ami-951945d0')
+    _set('us-west-2', :ami => 'ami-16fd7026')
+    _set('eu-west-1', :ami => 'ami-24506250')
+    _set('sa-east-1', :ami => 'ami-3e3be423')
+    _set('ap-southeast-1', :ami => 'ami-74dda626')
+    _set('ap-northeast-1', :ami => 'ami-dcfa4edd')
+  end
+
+  resources do
+    my_instance do
+      type 'AWS::EC2::Instance'
+      properties do
+        key_name _cf_ref(:key_name)
+        image_id _cf_map(:region_map, 'AWS::Region', :ami)
+        user_data _cf_base64('80')
+      end
+    end
+  end
+
+  outputs do
+    instance_id do
+      description 'InstanceId of the newly created EC2 instance'
+      value _cf_ref(:my_instance)
+    end
+    az do
+      description 'Availability Zone of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :availability_zone)
+    end
+    public_ip do
+      description 'Public IP address of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :public_ip)
+    end
+    private_ip do
+      description 'Private IP address of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :private_ip)
+    end
+    public_dns do
+      description 'Public DNSName of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :public_dns_name)
+    end
+    private_dns do
+      description 'Private DNSName of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :private_dns_name)
+    end
+  end
+end
+```
+
+And once compiled we get a nice Hash that we can then convert to JSON which
+is ready for AWS. To print:
+
+```ruby
+require 'sparkle_formation'
+require 'json'
+
+puts JSON.pretty_generate(
+  SparkleFormation.compile('ec2_example.rb')
+)
+```
+
+Easy!
+
+## Why not just write JSON?
+
+Because, who in their right mind would want to write all of that in JSON? Also,
+we can start applying some of the underlying features in `SparkleFormation` to
+make this easier to maintain.
+
+# Components
+
+Lets say we have a handful of CF templates we want to maintain, and all of those
+templates use the same AMI. Instead of copying that information into all the
+templates, lets create an AMI component instead, and then load it into the actual
+templates.
+
+First, create the component (components/ami.rb):
+
+```ruby
+SparkleFormation.build do
+
+  parameters do
+    key_name do
+      description 'Name of an existing EC2 KeyPair to enable SSH access to the instance'
+      type 'String'
+    end
+  end
+
+  mappings.region_map do
+    _set('us-east-1', :ami => 'ami-7f418316')
+    _set('us-east-1', :ami => 'ami-7f418316')
+    _set('us-west-1', :ami => 'ami-951945d0')
+    _set('us-west-2', :ami => 'ami-16fd7026')
+    _set('eu-west-1', :ami => 'ami-24506250')
+    _set('sa-east-1', :ami => 'ami-3e3be423')
+    _set('ap-southeast-1', :ami => 'ami-74dda626')
+    _set('ap-northeast-1', :ami => 'ami-dcfa4edd')
+  end
+end
+```
+
+Now, we can modify our initial example to use this component (ec2_example.rb):
+
+```ruby
+SparkleFormation.new('ec2_example').load(:ami).overrides do
+
+  description "AWS CloudFormation Sample Template EC2InstanceSample: Create an Amazon EC2 instance running the Amazon Linux AMI. The AMI is chosen based on the region in which the stack is run. This example uses the default security group, so to SSH to the new instance using the KeyPair you enter, you will need to have port 22 open in your default security group. **WARNING** This template an Amazon EC2 instances. You will be billed for the AWS resources used if you create a stack from this template."
+
+  resources do
+    my_instance do
+      type 'AWS::EC2::Instance'
+      properties do
+        key_name _cf_ref(:key_name)
+        image_id _cf_map(:region_map, 'AWS::Region', :ami)
+        user_data _cf_base64('80')
+      end
+    end
+  end
+
+  outputs do
+    instance_id do
+      description 'InstanceId of the newly created EC2 instance'
+      value _cf_ref(:my_instance)
+    end
+    az do
+      description 'Availability Zone of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :availability_zone)
+    end
+    public_ip do
+      description 'Public IP address of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :public_ip)
+    end
+    private_ip do
+      description 'Private IP address of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :private_ip)
+    end
+    public_dns do
+      description 'Public DNSName of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :public_dns_name)
+    end
+    private_dns do
+      description 'Private DNSName of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :private_dns_name)
+    end
+  end
+end
+```
+
+Now a few things have changed. Instead of passing a block directly to the
+instance instantiation, we are loading a component (the `ami` component)
+into the formation, and then applying an override block on top of the `ami`
+component. The result is the same as the initial example, but now we have
+a DRY component to use. Great!
+
+## Dynamics
+
+Okay, so lets say we want to have two ec2 instances. We could duplicate the
+resource and outputs, renaming where required. This would get ugly quick,
+especially as more instances are added. Making a component for the ec2 resource
+won't really help since components are static, used to apply the same common
+parts to multiple templates. So what do we use?
+
+Enter `dynamics`. These are much like components, except that instead of simply
+being merged, they allow passing of arguments which makes them reusable to create
+unique resources. So, from our last example, lets move the ec2 related items
+into a dynamic (dynamics/ec2.rb):
+
+```ruby
+SparkleFormation.dynamic(:ec2) do |_name|
+  resources("#{_name}_instance".to_sym)
+    type 'AWS::EC2::Instance'
+    properties do
+      key_name _cf_ref(:key_name)
+      image_id _cf_map(:region_map, 'AWS::Region', :ami)
+      user_data _cf_base64('80')
+    end
+  end
+
+  outputs("#{_name}_instance_id".to_sym) do
+    description 'InstanceId of the newly created EC2 instance'
+    value _cf_ref("#{_name}_instance".to_sym)
+  end
+  outputs("#{_name}_az".to_sym) do
+    description 'Availability Zone of the newly created EC2 instance'
+    value _cf_attr("#{_name}_instance".to_sym, :availability_zone)
+  end
+  outputs("#{_name}_public_ip".to_sym) do
+    description 'Public IP address of the newly created EC2 instance'
+    value _cf_attr("#{_name}_instance".to_sym, :public_ip)
+  end
+  outputs("#{_name}_private_ip".to_sym) do
+    description 'Private IP address of the newly created EC2 instance'
+    value _cf_attr("#{_name}_instance".to_sym, :private_ip)
+  end
+  outputs("#{_name}_public_dns".to_sym) do
+    description 'Public DNSName of the newly created EC2 instance'
+    value _cf_attr("#{_name}_instance".to_sym, :public_dns_name)
+  end
+  outputs("#{_name}_private_dns".to_sym) do
+    description 'Private DNSName of the newly created EC2 instance'
+    value _cf_attr("#{_name}_instance".to_sym, :private_dns_name)
+  end
+end
+```
+
+Now we can put all of these together, and create multiple ec2 instance
+resource easily:
+
+```ruby
+SparkleFormation.new('ec2_example').load(:ami).overrides do
+
+  description "AWS CloudFormation Sample Template EC2InstanceSample: Create an Amazon EC2 instance running the Amazon Linux AMI. The AMI is chosen based on the region in which the stack is run. This example uses the default security group, so to SSH to the new instance using the KeyPair you enter, you will need to have port 22 open in your default security group. **WARNING** This template an Amazon EC2 instances. You will be billed for the AWS resources used if you create a stack from this template."
+
+  [:node1, :node2, :node3].each do |_node_name|
+    SparkleFormation.insert(:ec2, self, _node_name)
+  end
+
+end
+```
+
+## TODO
+* Add information about symbol importance
+* Add examples of camel case control
+* Add examples of complex merge strategies
+* Add examples of accessing parent hash elements
+
+# Infos
+* Repository: https://github.com/heavywater/sparkle_formation
+* IRC: Freenode @ #heavywater

data/examples/allinone/cloudformation/ec2_example.rb

@@ -0,0 +1,59 @@
+SparkleFormation.new('ec2_example') do
+  description "AWS CloudFormation Sample Template EC2InstanceSample: Create an Amazon EC2 instance running the Amazon Linux AMI. The AMI is chosen based on the region in which the stack is run. This example uses the default security group, so to SSH to the new instance using the KeyPair you enter, you will need to have port 22 open in your default security group. **WARNING** This template an Amazon EC2 instances. You will be billed for the AWS resources used if you create a stack from this template."
+
+  parameters do
+    key_name do
+      description 'Name of an existing EC2 KeyPair to enable SSH access to the instance'
+      type 'String'
+    end
+  end
+
+  mappings.region_map do
+    _set('us-east-1', :ami => 'ami-7f418316')
+    _set('us-east-1', :ami => 'ami-7f418316')
+    _set('us-west-1', :ami => 'ami-951945d0')
+    _set('us-west-2', :ami => 'ami-16fd7026')
+    _set('eu-west-1', :ami => 'ami-24506250')
+    _set('sa-east-1', :ami => 'ami-3e3be423')
+    _set('ap-southeast-1', :ami => 'ami-74dda626')
+    _set('ap-northeast-1', :ami => 'ami-dcfa4edd')
+  end
+
+  resources do
+    my_instance do
+      type 'AWS::EC2::Instance'
+      properties do
+        key_name _cf_ref(:key_name)
+        image_id _cf_map(:region_map, 'AWS::Region', :ami)
+        user_data _cf_base64('80')
+      end
+    end
+  end
+
+  outputs do
+    instance_id do
+      description 'InstanceId of the newly created EC2 instance'
+      value _cf_ref(:my_instance)
+    end
+    az do
+      description 'Availability Zone of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :availability_zone)
+    end
+    public_ip do
+      description 'Public IP address of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :public_ip)
+    end
+    private_ip do
+      description 'Private IP address of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :private_ip)
+    end
+    public_dns do
+      description 'Public DNSName of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :public_dns_name)
+    end
+    private_dns do
+      description 'Private DNSName of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :private_dns_name)
+    end
+  end
+end

data/examples/allinone/parse.rb

@@ -0,0 +1,12 @@
+require 'sparkle_formation'
+require 'pp'
+require 'json'
+
+puts JSON.pretty_generate(
+  SparkleFormation.compile(
+    File.join(
+      File.dirname(__FILE__),
+      'cloudformation/ec2_example.rb'
+    )
+  )
+)

data/examples/ami_component/cloudformation/components/ami.rb

@@ -0,0 +1,21 @@
+SparkleFormation.build do
+
+  parameters do
+    key_name do
+      description 'Name of an existing EC2 KeyPair to enable SSH access to the instance'
+      type 'String'
+    end
+  end
+
+  mappings.region_map do
+    _set('us-east-1', :ami => 'ami-7f418316')
+    _set('us-east-1', :ami => 'ami-7f418316')
+    _set('us-west-1', :ami => 'ami-951945d0')
+    _set('us-west-2', :ami => 'ami-16fd7026')
+    _set('eu-west-1', :ami => 'ami-24506250')
+    _set('sa-east-1', :ami => 'ami-3e3be423')
+    _set('ap-southeast-1', :ami => 'ami-74dda626')
+    _set('ap-northeast-1', :ami => 'ami-dcfa4edd')
+  end
+
+end

data/examples/ami_component/cloudformation/ec2_example.rb

@@ -0,0 +1,41 @@
+SparkleFormation.new('ec2_example').load(:ami).overrides do
+  description "AWS CloudFormation Sample Template EC2InstanceSample: Create an Amazon EC2 instance running the Amazon Linux AMI. The AMI is chosen based on the region in which the stack is run. This example uses the default security group, so to SSH to the new instance using the KeyPair you enter, you will need to have port 22 open in your default security group. **WARNING** This template an Amazon EC2 instances. You will be billed for the AWS resources used if you create a stack from this template."
+
+  resources do
+    my_instance do
+      type 'AWS::EC2::Instance'
+      properties do
+        key_name _cf_ref(:key_name)
+        image_id _cf_map(:region_map, 'AWS::Region', :ami)
+        user_data _cf_base64('80')
+      end
+    end
+  end
+
+  outputs do
+    instance_id do
+      description 'InstanceId of the newly created EC2 instance'
+      value _cf_ref(:my_instance)
+    end
+    az do
+      description 'Availability Zone of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :availability_zone)
+    end
+    public_ip do
+      description 'Public IP address of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :public_ip)
+    end
+    private_ip do
+      description 'Private IP address of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :private_ip)
+    end
+    public_dns do
+      description 'Public DNSName of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :public_dns_name)
+    end
+    private_dns do
+      description 'Private DNSName of the newly created EC2 instance'
+      value _cf_attr(:my_instance, :private_dns_name)
+    end
+  end
+end

data/examples/ami_component/parse.rb

@@ -0,0 +1,12 @@
+require 'sparkle_formation'
+require 'pp'
+require 'json'
+
+puts JSON.pretty_generate(
+  SparkleFormation.compile(
+    File.join(
+      File.dirname(__FILE__),
+      'cloudformation/ec2_example.rb'
+    )
+  )
+)

data/lib/sparkle_formation/sparkle_attribute.rb

@@ -0,0 +1,84 @@
+require 'attribute_struct'
+
+module SparkleAttribute
+
+  def _cf_join(*args)
+    options = args.detect{|i| i.is_a?(Hash) && i[:options]} || {:options => {}}
+    args.delete(options)
+    unless(args.size == 1)
+      args = [args]
+    end
+    {'Fn::Join' => [options[:options][:delimiter] || '', *args]}
+  end
+
+  def _cf_ref(thing)
+    thing = _process_key(thing, :force) if thing.is_a?(Symbol)
+    {'Ref' => thing}
+  end
+  alias_method :_ref, :_cf_ref
+
+  def _cf_map(thing, key, *suffix)
+    suffix = suffix.map do |item|
+      if(item.is_a?(Symbol))
+        _process_key(item, :force)
+      else
+        item
+      end
+    end
+    thing = _process_key(thing, :force) if thing.is_a?(Symbol)
+    key = _process_key(key, :force) if key.is_a?(Symbol)
+    {'Fn::FindInMap' => [_process_key(thing), {'Ref' => _process_key(key)}, *suffix]}
+  end
+  alias_method :_cf_find_in_map, :_cf_map
+
+  def _cf_attr(*args)
+    args = args.map do |thing|
+      if(thing.is_a?(Symbol))
+        _process_key(thing, :force)
+      else
+        thing
+      end
+
+    end
+    {'Fn::GetAtt' => args}
+  end
+  alias_method :_cf_get_att, :_cf_attr
+
+  def _cf_base64(arg)
+    {'Fn::Base64' => arg}
+  end
+
+  def _cf_get_azs(region=nil)
+    region = case region
+             when Symbol
+               _cf_ref(region)
+             when NilClass
+               ''
+             else
+               region
+             end
+    {'Fn::GetAZs' => region}
+  end
+
+  def _cf_select(index, item)
+    item = _cf_ref(item) if item.is_a?(Symbol)
+    {'Fn::Select', [index.to_i.to_s, item]}
+  end
+
+  def rhel?
+    !!@platform[:rhel]
+  end
+
+  def debian?
+    !!@platform[:debian]
+  end
+
+  def _platform=(plat)
+    @platform || __hashish
+    @platform.clear
+    @platform[plat.to_sym] = true
+  end
+
+end
+
+AttributeStruct.send(:include, SparkleAttribute)

data/lib/sparkle_formation/sparkle_formation.rb

@@ -0,0 +1,137 @@
+require 'attribute_struct'
+require 'sparkle_formation/sparkle_attribute'
+require 'sparkle_formation/utils'
+
+AttributeStruct.camel_keys = true
+
+class SparkleFormation
+
+  include SparkleFormation::Utils::AnimalStrings
+
+  class << self
+
+    attr_reader :dynamics
+    attr_reader :components_path
+    attr_reader :dynamics_path
+
+    def custom_paths
+      @_paths ||= {}
+      @_paths
+    end
+
+    def components_path=(path)
+      custom_paths[:sparkle_path] = path
+    end
+
+    def dynamics_path=(path)
+      custom_paths[:dynamics_directory] = path
+    end
+
+    def compile(path)
+      formation = self.instance_eval(IO.read(path), path, 1)
+      formation.compile._dump
+    end
+
+    def build(&block)
+      struct = AttributeStruct.new
+      struct.instance_exec(&block)
+      struct
+    end
+
+    def load_component(path)
+      self.instance_eval(IO.read(path), path, 1)
+    end
+
+    def load_dynamics!(directory)
+      @loaded_dynamics ||= []
+      Dir.glob(File.join(directory, '*.rb')).each do |dyn|
+        dyn = File.expand_path(dyn)
+        next if @loaded_dynamics.include?(dyn)
+        self.instance_eval(IO.read(dyn), dyn, 1)
+        @loaded_dynamics << dyn
+      end
+      @loaded_dynamics.uniq!
+      true
+    end
+
+    def dynamic(name, &block)
+      @dynamics ||= Mash.new
+      @dynamics[name] = block
+    end
+
+    def insert(dynamic_name, struct, *args)
+      if(@dynamics && @dynamics[dynamic_name])
+        struct.instance_exec(*args, &@dynamics[dynamic_name])
+        struct
+      else
+        raise "Failed to locate requested dynamic block for insertion: #{dynamic_name} (valid: #{@dynamics.keys.sort.join(', ')})"
+      end
+    end
+
+    def from_hash(hash)
+      struct = AttributeStruct.new
+      struct._camel_keys_set(:auto_discovery)
+      struct._load(hash)
+      struct._camel_keys_set(nil)
+      struct
+    end
+  end
+
+  attr_reader :name
+  attr_reader :sparkle_path
+  attr_reader :components
+  attr_reader :load_order
+
+  def initialize(name, options={}, &block)
+    @name = name
+    @sparkle_path = options[:sparkle_path] ||
+      self.class.custom_paths[:sparkle_path] ||
+      File.join(Dir.pwd, 'cloudformation/components')
+    @dynamics_directory = options[:dynamics_directory] ||
+      self.class.custom_paths[:dynamics_directory] ||
+      File.join(File.dirname(@sparkle_path), 'dynamics')
+    self.class.load_dynamics!(@dynamics_directory)
+    @components = AttributeStruct.hashish.new
+    @load_order = []
+    if(block)
+      load_block(block)
+    end
+  end
+
+  def load_block(block)
+    @components[:__base__] = self.class.build(&block)
+    @load_order << :__base__
+  end
+
+  def load(*args)
+    args.each do |thing|
+      if(thing.is_a?(Symbol))
+        path = File.join(sparkle_path, "#{thing}.rb")
+      else
+        path = thing
+      end
+      key = File.basename(path).sub('.rb', '')
+      components[key] = self.class.load_component(path)
+      @load_order << key
+    end
+    self
+  end
+
+  def overrides(&block)
+    @overrides = self.class.build(&block)
+    self
+  end
+
+  # Returns compiled Mash instance
+  def compile
+    compiled = AttributeStruct.new
+    @load_order.each do |key|
+      compiled._merge!(components[key])
+    end
+    if(@overrides)
+      compiled._merge!(@overrides)
+    end
+    compiled
+  end
+
+end

data/lib/sparkle_formation/utils.rb

@@ -0,0 +1,17 @@
+class SparkleFormation
+  module Utils
+
+    module AnimalStrings
+
+      def camel(string)
+        string.to_s.split('_').map{|k| "#{k.slice(0,1).upcase}#{k.slice(1,k.length)}"}.join
+      end
+
+      def snake(string)
+        string.to_s.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym
+      end
+
+    end
+
+  end
+end

data/lib/sparkle_formation/version.rb

@@ -0,0 +1,5 @@
+class SparkleFormation
+  class Version < Gem::Version
+  end
+  VERSION = Version.new('0.1.0')
+end

data/lib/sparkle_formation.rb

@@ -0,0 +1,2 @@
+require 'sparkle_formation/version'
+require 'sparkle_formation/sparkle_formation'

data/sparkle_formation.gemspec

@@ -0,0 +1,14 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + '/lib/'
+require 'sparkle_formation/version'
+Gem::Specification.new do |s|
+  s.name = 'sparkle_formation'
+  s.version = SparkleFormation::VERSION.version
+  s.summary = 'Cloud Formation builder'
+  s.author = 'Chris Roberts'
+  s.email = 'chrisroberts.code@gmail.com'
+  s.homepage = 'http://github.com/heavywater/sparkle_formation'
+  s.description = 'Cloud Formation builder'
+  s.require_path = 'lib'
+  s.add_dependency 'attribute_struct', '~> 0.1.6'
+  s.files = Dir['**/*']
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: sparkle_formation
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Chris Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: attribute_struct
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.6
+description: Cloud Formation builder
+email: chrisroberts.code@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sparkle_formation/sparkle_attribute.rb
+- lib/sparkle_formation/version.rb
+- lib/sparkle_formation/sparkle_formation.rb
+- lib/sparkle_formation/utils.rb
+- lib/sparkle_formation.rb
+- examples/allinone/parse.rb
+- examples/allinone/cloudformation/ec2_example.rb
+- examples/ami_component/parse.rb
+- examples/ami_component/cloudformation/components/ami.rb
+- examples/ami_component/cloudformation/ec2_example.rb
+- Gemfile
+- sparkle_formation.gemspec
+- README.md
+- CHANGELOG.md
+- Gemfile.lock
+homepage: http://github.com/heavywater/sparkle_formation
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Cloud Formation builder
+test_files: []
+has_rdoc: