terrafying-components 1.11.15 → 1.11.16

data/lib/terrafying/components/templates/ignition.yaml

@@ -1,7 +1,6 @@
 ---
 ignition:
-  version: "2.1.0"
-
+  version: "2.2.0"
 
 passwd:
   users:
@@ -37,15 +36,37 @@ systemd:
 
     <% units.each { |unit| %>
     - name: "<%= unit[:name] %>"
-      enabled: true<% if unit.has_key?(:contents) %>
-      contents: "<%= unit[:contents].dump[1..-2] %>"<% end %><% if unit.has_key?(:dropins) %>
+      enabled: <%= unit.fetch(:enabled, 'true') %>
+      <% if unit.has_key?(:mask) %>
+      mask: <%= unit[:mask] %>
+      <% end %>
+      <% if unit.has_key?(:contents) %>
+      contents: "<%= unit[:contents].dump[1..-2] %>"
+      <% end %>
+      <% if unit.has_key?(:dropins) %>
       dropins:
         <% unit[:dropins].each { |dropin| %>
         - contents: "<%= dropin[:contents].dump[1..-2] %>"
           name: "<%= dropin[:name] %>"
-        <% } %><% end %>
+        <% } %>
+      <% end %>
     <% } %>
 
+networkd:
+  units:
+    <% networkd_units.each { |unit| %>
+    - name: "<%= unit[:name] %>"
+      <% if unit.has_key?(:contents) %>
+      contents: "<%= unit[:contents].dump[1..-2] %>"
+      <% end %>
+      <% if unit.has_key?(:dropins) %>
+      dropins:
+        <% unit[:dropins].each { |dropin| %>
+        - contents: "<%= dropin[:contents].dump[1..-2] %>"
+          name: "<%= dropin[:name] %>"
+        <% } %>
+      <% end %>
+    <% } %>
 
 storage:
   <% if volumes.count > 0 %>

data/lib/terrafying/components/usable.rb

@@ -1,10 +1,8 @@
+# frozen_string_literal: true
 
 module Terrafying
-
   module Components
-
     module Usable
-
       def security_group
         @security_group
       end
@@ -18,112 +16,100 @@ module Terrafying
       end
 
       def path_mtu_setup!
-        resource :aws_security_group_rule, "#{@name}-path-mtu", {
-                     security_group_id: self.egress_security_group,
-                     type: "ingress",
-                     protocol: 1, # icmp
-                     from_port: 3, # icmp type
-                     to_port: 4, # icmp code
-                     cidr_blocks: ["0.0.0.0/0"],
-                   }
+        resource :aws_security_group_rule, "#{@name}-path-mtu",
+                 security_group_id: egress_security_group,
+                 type: 'ingress',
+                 protocol: 1, # icmp
+                 from_port: 3, # icmp type
+                 to_port: 4, # icmp code
+                 cidr_blocks: ['0.0.0.0/0']
       end
 
       def pingable_by_cidr(*cidrs)
         ident = Digest::SHA2.hexdigest cidrs.to_s
 
-        resource :aws_security_group_rule, "#{@name}-to-#{ident}-ping", {
-                     security_group_id: self.ingress_security_group,
-                     type: "ingress",
-                     protocol: 1, # icmp
-                     from_port: 8, # icmp type
-                     to_port: 0, # icmp code
-                     cidr_blocks: cidrs,
-                   }
+        resource :aws_security_group_rule, "#{@name}-to-#{ident}-ping",
+                 security_group_id: ingress_security_group,
+                 type: 'ingress',
+                 protocol: 1, # icmp
+                 from_port: 8, # icmp type
+                 to_port: 0, # icmp code
+                 cidr_blocks: cidrs
       end
 
       def used_by_cidr(*cidrs, &block)
-        cidrs.map { |cidr|
+        cidrs.map do |cidr|
           cidr_ident = cidr.tr('./', '-')
 
-          @ports.select(&block).map { |port|
-            resource :aws_security_group_rule, "#{@name}-to-#{cidr_ident}-#{port[:name]}", {
-                       security_group_id: ingress_security_group,
-                       type: "ingress",
-                       from_port: from_port(port[:upstream_port]),
-                       to_port: to_port(port[:upstream_port]),
-                       protocol: port[:type] == "udp" ? "udp" : "tcp",
-                       cidr_blocks: [cidr]
-                     }
-          }
-        }
+          @ports.select(&block).map do |port|
+            resource :aws_security_group_rule, "#{@name}-to-#{cidr_ident}-#{port[:name]}",
+                     security_group_id: ingress_security_group,
+                     type: 'ingress',
+                     from_port: from_port(port[:upstream_port]),
+                     to_port: to_port(port[:upstream_port]),
+                     protocol: port[:type] == 'udp' ? 'udp' : 'tcp',
+                     cidr_blocks: [cidr]
+          end
+        end
       end
 
       def pingable_by(*other_resources)
-        other_resources.map { |other_resource|
-          resource :aws_security_group_rule, "#{@name}-to-#{other_resource.name}-ping", {
-                     security_group_id: self.ingress_security_group,
-                     type: "ingress",
-                     protocol: 1, # icmp
-                     from_port: 8, # icmp type
-                     to_port: 0, # icmp code
-                     source_security_group_id: other_resource.egress_security_group,
-                   }
-
-          resource :aws_security_group_rule, "#{@name}-to-#{other_resource.name}-pingv6", {
-                     security_group_id: self.ingress_security_group,
-                     type: "ingress",
-                     protocol: 58, # icmpv6
-                     from_port: 128, # icmp type
-                     to_port: 0, # icmp code
-                     source_security_group_id: other_resource.egress_security_group,
-                   }
-
-          resource :aws_security_group_rule, "#{other_resource.name}-to-#{@name}-ping", {
-                     security_group_id: other_resource.egress_security_group,
-                     type: "egress",
-                     protocol: 1, # icmp
-                     from_port: 8, # icmp type
-                     to_port: 0, # icmp code
-                     source_security_group_id: self.ingress_security_group,
-                   }
-
-          resource :aws_security_group_rule, "#{other_resource.name}-to-#{@name}-pingv6", {
-                     security_group_id: other_resource.egress_security_group,
-                     type: "egress",
-                     protocol: 58, # icmpv6
-                     from_port: 128, # icmp type
-                     to_port: 0, # icmp code
-                     source_security_group_id: self.ingress_security_group,
-                   }
-        }
+        other_resources.map do |other_resource|
+          resource :aws_security_group_rule, "#{@name}-to-#{other_resource.name}-ping",
+                   security_group_id: ingress_security_group,
+                   type: 'ingress',
+                   protocol: 1, # icmp
+                   from_port: 8, # icmp type
+                   to_port: 0, # icmp code
+                   source_security_group_id: other_resource.egress_security_group
+
+          resource :aws_security_group_rule, "#{@name}-to-#{other_resource.name}-pingv6",
+                   security_group_id: ingress_security_group,
+                   type: 'ingress',
+                   protocol: 58, # icmpv6
+                   from_port: 128, # icmp type
+                   to_port: 0, # icmp code
+                   source_security_group_id: other_resource.egress_security_group
+
+          resource :aws_security_group_rule, "#{other_resource.name}-to-#{@name}-ping",
+                   security_group_id: other_resource.egress_security_group,
+                   type: 'egress',
+                   protocol: 1, # icmp
+                   from_port: 8, # icmp type
+                   to_port: 0, # icmp code
+                   source_security_group_id: ingress_security_group
+
+          resource :aws_security_group_rule, "#{other_resource.name}-to-#{@name}-pingv6",
+                   security_group_id: other_resource.egress_security_group,
+                   type: 'egress',
+                   protocol: 58, # icmpv6
+                   from_port: 128, # icmp type
+                   to_port: 0, # icmp code
+                   source_security_group_id: ingress_security_group
+        end
       end
 
       def used_by(*other_resources, &block)
-        other_resources.map { |other_resource|
-          @ports.select(&block).map.map {|port|
-            resource :aws_security_group_rule, "#{@name}-to-#{other_resource.name}-#{port[:name]}", {
-                       security_group_id: self.ingress_security_group,
-                       type: "ingress",
-                       from_port: from_port(port[:upstream_port]),
-                       to_port: to_port(port[:upstream_port]),
-                       protocol: port[:type] == "udp" ? "udp" : "tcp",
-                       source_security_group_id: other_resource.egress_security_group,
-                     }
-
-            resource :aws_security_group_rule, "#{other_resource.name}-to-#{@name}-#{port[:name]}", {
-                       security_group_id: other_resource.egress_security_group,
-                       type: "egress",
-                       from_port: from_port(port[:downstream_port]),
-                       to_port: to_port(port[:downstream_port]),
-                       protocol: port[:type] == "udp" ? "udp" : "tcp",
-                       source_security_group_id: self.ingress_security_group,
-                     }
-          }
-        }
+        other_resources.map do |other_resource|
+          @ports.select(&block).map.map do |port|
+            resource :aws_security_group_rule, "#{@name}-to-#{other_resource.name}-#{port[:name]}",
+                     security_group_id: ingress_security_group,
+                     type: 'ingress',
+                     from_port: from_port(port[:upstream_port]),
+                     to_port: to_port(port[:upstream_port]),
+                     protocol: port[:type] == 'udp' ? 'udp' : 'tcp',
+                     source_security_group_id: other_resource.egress_security_group
+
+            resource :aws_security_group_rule, "#{other_resource.name}-to-#{@name}-#{port[:name]}",
+                     security_group_id: other_resource.egress_security_group,
+                     type: 'egress',
+                     from_port: from_port(port[:downstream_port]),
+                     to_port: to_port(port[:downstream_port]),
+                     protocol: port[:type] == 'udp' ? 'udp' : 'tcp',
+                     source_security_group_id: ingress_security_group
+          end
+        end
       end
-
     end
-
   end
-
 end

data/lib/terrafying/components/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module Terrafying
   module Components
-    VERSION = "1.11.15"
+    VERSION = '1.11.16'
   end
 end

data/lib/terrafying/components/vpc.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 require 'netaddr'
 
@@ -6,28 +7,25 @@ require 'terrafying/components/zone'
 require 'terrafying/generator'
 
 module Terrafying
-
   module Components
     DEFAULT_SSH_GROUP = 'cloud-team'
-    DEFAULT_ZONE = "vpc.usw.co"
+    DEFAULT_ZONE = 'vpc.usw.co'
 
     class VPC < Terrafying::Context
-
       attr_reader :id, :name, :cidr, :zone, :azs, :subnets, :internal_ssh_security_group, :ssh_group
 
       def self.find(name)
         VPC.new.find name
       end
 
-      def self.create(name, cidr, options={})
+      def self.create(name, cidr, options = {})
         VPC.new.create name, cidr, options
       end
 
-      def initialize()
+      def initialize
         super
       end
 
-
       def find(name)
         vpc = aws.vpc(name)
 
@@ -35,51 +33,49 @@ module Terrafying
         @id = vpc.vpc_id
         @cidr = vpc.cidr_block
         @tags = {}
-        @zone = Terrafying::Components::Zone.find_by_tag({vpc: @id})
-        if @zone.nil?
-          raise "Failed to find zone"
-        end
+        @zone = Terrafying::Components::Zone.find_by_tag(vpc: @id)
+        raise 'Failed to find zone' if @zone.nil?
 
-        @subnets = aws.subnets_for_vpc(vpc.vpc_id).each_with_object({}) { |subnet, subnets|
+        @subnets = aws.subnets_for_vpc(vpc.vpc_id).each_with_object({}) do |subnet, subnets|
           subnet_inst = Subnet.find(subnet.subnet_id)
 
-          subnet_name_tag = subnet.tags.detect { |tag| tag.key == "subnet_name" }
+          subnet_name_tag = subnet.tags.detect { |tag| tag.key == 'subnet_name' }
 
-          if subnet_name_tag
-            key = subnet_name_tag.value.to_sym
-          else
-            key = subnet_inst.public ? :public : :private
-          end
+          key = if subnet_name_tag
+                  subnet_name_tag.value.to_sym
+                else
+                  subnet_inst.public ? :public : :private
+                end
 
-          if subnets.has_key?(key)
+          if subnets.key?(key)
             subnets[key] << subnet_inst
           else
-            subnets[key] = [ subnet_inst ]
+            subnets[key] = [subnet_inst]
           end
-        }
+        end
 
         # need to sort subnets so they are in az order
         @subnets.each { |_, s| s.sort! { |a, b| a.az <=> b.az } }
 
-        tags = vpc.tags.select { |tag| tag.key == "ssh_group"}
-        if tags.count > 0
-          @ssh_group = tags[0].value
-        else
-          @ssh_group = DEFAULT_SSH_GROUP
-        end
+        tags = vpc.tags.select { |tag| tag.key == 'ssh_group' }
+        @ssh_group = if tags.count > 0
+                       tags[0].value
+                     else
+                       DEFAULT_SSH_GROUP
+                     end
 
         @internal_ssh_security_group = aws.security_group("#{tf_safe(name)}-internal-ssh")
         self
       end
 
-      def create(name, raw_cidr, options={})
+      def create(name, raw_cidr, options = {})
         options = {
           subnet_size: 24,
           internet_access: true,
           nat_eips: [],
           azs: aws.availability_zones,
           tags: {},
-          ssh_group: DEFAULT_SSH_GROUP,
+          ssh_group: DEFAULT_SSH_GROUP
         }.merge(options)
 
         if options[:parent_zone].nil?
@@ -87,16 +83,16 @@ module Terrafying
         end
 
         if options[:subnets].nil?
-          if options[:internet_access]
-            options[:subnets] = {
-              public: { public: true },
-              private: { internet: true },
-            }
-          else
-            options[:subnets] = {
-              private: { },
-            }
-          end
+          options[:subnets] = if options[:internet_access]
+                                {
+                                  public: { public: true },
+                                  private: { internet: true }
+                                }
+                              else
+                                {
+                                  private: {}
+                                }
+                              end
         end
 
         @name = name
@@ -112,148 +108,136 @@ module Terrafying
         @subnet_size = options[:subnet_size]
         @subnets = {}
 
-        per_az_subnet_size = options[:subnets].values.reduce(0) { |memo, s|
+        per_az_subnet_size = options[:subnets].values.reduce(0) do |memo, s|
           memo + (1 << (32 - s.fetch(:bit_size, @subnet_size)))
-        }
+        end
         total_subnet_size = per_az_subnet_size * @azs.count
 
         if total_subnet_size > cidr.size
-          raise "Not enough space for subnets in CIDR"
+          raise 'Not enough space for subnets in CIDR'
         end
 
-        @id = resource :aws_vpc, name, {
-                         cidr_block: cidr.to_s,
-                         enable_dns_hostnames: true,
-                         tags: { Name: name, ssh_group: @ssh_group }.merge(@tags),
-                       }
-
-        @zone = add! Terrafying::Components::Zone.create("#{name}.#{options[:parent_zone].fqdn}", {
-                                                           parent_zone: options[:parent_zone],
-                                                           tags: { vpc: @id }.merge(@tags),
-                                                         })
+        @id = resource :aws_vpc, name,
+                       cidr_block: cidr.to_s,
+                       enable_dns_hostnames: true,
+                       tags: { Name: name, ssh_group: @ssh_group }.merge(@tags)
 
-        dhcp = resource :aws_vpc_dhcp_options, name, {
-                          domain_name: @zone.fqdn,
-                          domain_name_servers: ["AmazonProvidedDNS"],
-                          tags: { Name: name }.merge(@tags),
-                        }
+        @zone = add! Terrafying::Components::Zone.create("#{name}.#{options[:parent_zone].fqdn}",
+                                                         parent_zone: options[:parent_zone],
+                                                         tags: { vpc: @id }.merge(@tags))
 
-        resource :aws_vpc_dhcp_options_association, name, {
-                   vpc_id: @id,
-                   dhcp_options_id: dhcp,
-                 }
+        dhcp = resource :aws_vpc_dhcp_options, name,
+                        domain_name: @zone.fqdn,
+                        domain_name_servers: ['AmazonProvidedDNS'],
+                        tags: { Name: name }.merge(@tags)
 
+        resource :aws_vpc_dhcp_options_association, name,
+                 vpc_id: @id,
+                 dhcp_options_id: dhcp
 
         if options[:internet_access]
 
-          if options[:nat_eips].size == 0
-            options[:nat_eips] = @azs.map{ |az| resource :aws_eip, "#{name}-nat-gateway-#{az}", { vpc: true } }
+          if options[:nat_eips].empty?
+            options[:nat_eips] = @azs.map { |az| resource :aws_eip, "#{name}-nat-gateway-#{az}", vpc: true }
           elsif options[:nat_eips].size != @azs.count
-            raise "The nubmer of nat eips has to match the number of AZs"
+            raise 'The nubmer of nat eips has to match the number of AZs'
           end
 
-          @internet_gateway = resource :aws_internet_gateway, name, {
-                                         vpc_id: @id,
-                                         tags: {
-                                           Name: name,
-                                         }.merge(@tags)
-                                       }
-          allocate_subnets!(:nat_gateway, { bit_size: 28, public: true })
-
-          @nat_gateways = @azs.zip(@subnets[:nat_gateway], options[:nat_eips]).map { |az, subnet, eip|
-            resource :aws_nat_gateway, "#{name}-#{az}", {
-                       allocation_id: eip,
-                       subnet_id: subnet.id,
-                     }
-          }
+          @internet_gateway = resource :aws_internet_gateway, name,
+                                       vpc_id: @id,
+                                       tags: {
+                                         Name: name
+                                       }.merge(@tags)
+          allocate_subnets!(:nat_gateway, bit_size: 28, public: true)
+
+          @nat_gateways = @azs.zip(@subnets[:nat_gateway], options[:nat_eips]).map do |az, subnet, eip|
+            resource :aws_nat_gateway, "#{name}-#{az}",
+                     allocation_id: eip,
+                     subnet_id: subnet.id
+          end
 
         end
 
         options[:subnets].each { |key, config| allocate_subnets! key, config }
 
-        @internal_ssh_security_group = resource :aws_security_group, "#{name}-internal-ssh", {
-                                                  name: "#{name}-internal-ssh",
-                                                  description: "Allows SSH between machines inside the VPC CIDR",
-                                                  tags: @tags,
-                                                  vpc_id: @id,
-                                                  ingress: [
-                                                    {
-                                                      from_port: 22,
-                                                      to_port: 22,
-                                                      protocol: "tcp",
-                                                      cidr_blocks: [@cidr],
-                                                    },
-                                                  ],
-                                                  egress: [
-                                                    {
-                                                      from_port: 22,
-                                                      to_port: 22,
-                                                      protocol: "tcp",
-                                                      cidr_blocks: [@cidr],
-                                                    },
-                                                  ],
-                                                }
+        @internal_ssh_security_group = resource :aws_security_group, "#{name}-internal-ssh",
+                                                name: "#{name}-internal-ssh",
+                                                description: 'Allows SSH between machines inside the VPC CIDR',
+                                                tags: @tags,
+                                                vpc_id: @id,
+                                                ingress: [
+                                                  {
+                                                    from_port: 22,
+                                                    to_port: 22,
+                                                    protocol: 'tcp',
+                                                    cidr_blocks: [@cidr]
+                                                  }
+                                                ],
+                                                egress: [
+                                                  {
+                                                    from_port: 22,
+                                                    to_port: 22,
+                                                    protocol: 'tcp',
+                                                    cidr_blocks: [@cidr]
+                                                  }
+                                                ]
         self
       end
 
-      def peer_with_external(account_id, vpc_id, cidrs, options={})
+      def peer_with_external(account_id, vpc_id, cidrs, options = {})
         options = {
-          region: "eu-west-1",
-          subnets: @subnets.values.flatten,
+          region: 'eu-west-1',
+          subnets: @subnets.values.flatten
         }.merge(options)
 
-        peering_connection = resource :aws_vpc_peering_connection, "#{@name}-to-#{account_id}-#{vpc_id}", {
-                                        peer_owner_id: account_id,
-                                        peer_vpc_id: vpc_id,
-                                        peer_region: options[:region],
-                                        vpc_id: @id,
-                                        auto_accept: false,
-                                        tags: { Name: "#{@name} to #{account_id}.#{vpc_id}" }.merge(@tags),
-                                      }
+        peering_connection = resource :aws_vpc_peering_connection, "#{@name}-to-#{account_id}-#{vpc_id}",
+                                      peer_owner_id: account_id,
+                                      peer_vpc_id: vpc_id,
+                                      peer_region: options[:region],
+                                      vpc_id: @id,
+                                      auto_accept: false,
+                                      tags: { Name: "#{@name} to #{account_id}.#{vpc_id}" }.merge(@tags)
 
         our_route_tables = options[:subnets].map(&:route_table).sort.uniq
 
-        our_route_tables.product(cidrs).each { |route_table, cidr|
+        our_route_tables.product(cidrs).each do |route_table, cidr|
           hash = Digest::SHA2.hexdigest "#{route_table}-#{tf_safe(cidr)}"
 
-          resource :aws_route, "#{@name}-to-#{account_id}-#{vpc_id}-peer-#{hash}", {
-                     route_table_id: route_table,
-                     destination_cidr_block: cidr,
-                     vpc_peering_connection_id: peering_connection,
-                   }
-        }
+          resource :aws_route, "#{@name}-to-#{account_id}-#{vpc_id}-peer-#{hash}",
+                   route_table_id: route_table,
+                   destination_cidr_block: cidr,
+                   vpc_peering_connection_id: peering_connection
+        end
       end
 
-      def peer_with_vpn(ip_address, cidrs, options={})
+      def peer_with_vpn(ip_address, cidrs, options = {})
         options = {
-          bgp_asn: 65000,
-          type: "ipsec.1",
+          bgp_asn: 65_000,
+          type: 'ipsec.1',
           tunnels: [],
           static_routes_only: true,
-          subnets: @subnets.values.flatten,
+          subnets: @subnets.values.flatten
         }.merge(options)
 
         ident = tf_safe(ip_address)
 
         if options[:tunnels].count > 2
-          raise "You can only define a max of two tunnels"
+          raise 'You can only define a max of two tunnels'
         end
 
-        customer_gateway = resource :aws_customer_gateway, ident, {
-                                      bgp_asn: options[:bgp_asn],
-                                      ip_address: ip_address,
-                                      type: options[:type],
-                                      tags: {
-                                        Name: "Connection to #{ip_address}"
-                                      }.merge(@tags),
-                                    }
-
-        vpn_gateway = resource :aws_vpn_gateway, ident, {
-                                 vpc_id: @id,
-                                 tags: {
-                                   Name: "Connection to #{ip_address}"
-                                 }.merge(@tags),
-                               }
+        customer_gateway = resource :aws_customer_gateway, ident,
+                                    bgp_asn: options[:bgp_asn],
+                                    ip_address: ip_address,
+                                    type: options[:type],
+                                    tags: {
+                                      Name: "Connection to #{ip_address}"
+                                    }.merge(@tags)
+
+        vpn_gateway = resource :aws_vpn_gateway, ident,
+                               vpc_id: @id,
+                               tags: {
+                                 Name: "Connection to #{ip_address}"
+                               }.merge(@tags)
 
         connection_config = {
           vpn_gateway_id: vpn_gateway,
@@ -262,101 +246,92 @@ module Terrafying
           static_routes_only: options[:static_routes_only],
           tags: {
             Name: "Connection to #{ip_address}"
-          }.merge(@tags),
+          }.merge(@tags)
         }
 
-        options[:tunnels].each.with_index { |tunnel, i|
-          connection_config["tunnel#{i+1}_inside_cidr"] = tunnel[:cidr]
+        options[:tunnels].each.with_index do |tunnel, i|
+          connection_config["tunnel#{i + 1}_inside_cidr"] = tunnel[:cidr]
 
-          if tunnel.has_key?(:key)
-            connection_config["tunnel#{i+1}_preshared_key"] = tunnel[:key]
+          if tunnel.key?(:key)
+            connection_config["tunnel#{i + 1}_preshared_key"] = tunnel[:key]
           end
-        }
+        end
 
         connection = resource :aws_vpn_connection, ident, connection_config
 
-        cidrs.each { |cidr|
-          resource :aws_vpn_connection_route, "#{ident}-#{tf_safe(cidr)}", {
-                     destination_cidr_block: cidr,
-                     vpn_connection_id: connection,
-                   }
-        }
+        cidrs.each do |cidr|
+          resource :aws_vpn_connection_route, "#{ident}-#{tf_safe(cidr)}",
+                   destination_cidr_block: cidr,
+                   vpn_connection_id: connection
+        end
 
         route_tables = options[:subnets].map(&:route_table).sort.uniq
-        route_tables.product(cidrs).each { |route_table, cidr|
+        route_tables.product(cidrs).each do |route_table, cidr|
           hash = Digest::SHA2.hexdigest "#{route_table}-#{tf_safe(cidr)}"
 
-          resource :aws_route, "#{@name}-to-#{ident}-peer-#{hash}", {
-                     route_table_id: route_table,
-                     destination_cidr_block: cidr,
-                     gateway_id: vpn_gateway,
-                   }
-        }
-
+          resource :aws_route, "#{@name}-to-#{ident}-peer-#{hash}",
+                   route_table_id: route_table,
+                   destination_cidr_block: cidr,
+                   gateway_id: vpn_gateway
+        end
       end
 
-      def peer_with(other_vpc, options={})
+      def peer_with(other_vpc, options = {})
         options = {
           complete: false,
           peerings: [
             { from: @subnets.values.flatten, to: other_vpc.subnets.values.flatten },
-            { from: other_vpc.subnets.values.flatten, to: @subnets.values.flatten },
-          ],
+            { from: other_vpc.subnets.values.flatten, to: @subnets.values.flatten }
+          ]
         }.merge(options)
 
         other_vpc_ident = tf_safe(other_vpc.name)
 
         our_cidr = NetAddr::CIDR.create(@cidr)
         other_cidr = NetAddr::CIDR.create(other_vpc.cidr)
-        if our_cidr.contains? other_cidr[0] or our_cidr.contains? other_cidr.last
-          raise "VPCs to be peered have overlapping CIDRs"
+        if our_cidr.contains?(other_cidr[0]) || our_cidr.contains?(other_cidr.last)
+          raise 'VPCs to be peered have overlapping CIDRs'
         end
 
-        peering_connection = resource :aws_vpc_peering_connection, "#{@name}-to-#{other_vpc_ident}", {
-                                        peer_vpc_id: other_vpc.id,
-                                        vpc_id: @id,
-                                        auto_accept: true,
-                                        tags: { Name: "#{@name} to #{other_vpc.name}" }.merge(@tags),
-                                      }
+        peering_connection = resource :aws_vpc_peering_connection, "#{@name}-to-#{other_vpc_ident}",
+                                      peer_vpc_id: other_vpc.id,
+                                      vpc_id: @id,
+                                      auto_accept: true,
+                                      tags: { Name: "#{@name} to #{other_vpc.name}" }.merge(@tags)
 
         if options[:complete]
           our_route_tables = @subnets.values.flatten.map(&:route_table).sort.uniq
           their_route_tables = other_vpc.subnets.values.flatten.map(&:route_table).sort.uniq
 
-          (our_route_tables.product([other_vpc.cidr]) + their_route_tables.product([@cidr])).each { |route_table, cidr|
+          (our_route_tables.product([other_vpc.cidr]) + their_route_tables.product([@cidr])).each do |route_table, cidr|
             hash = Digest::SHA2.hexdigest "#{route_table}-#{tf_safe(cidr)}"
 
-            resource :aws_route, "#{@name}-#{other_vpc_ident}-peer-#{hash}", {
-              route_table_id: route_table,
-              destination_cidr_block: cidr,
-              vpc_peering_connection_id: peering_connection,
-            }
-          }
+            resource :aws_route, "#{@name}-#{other_vpc_ident}-peer-#{hash}",
+                     route_table_id: route_table,
+                     destination_cidr_block: cidr,
+                     vpc_peering_connection_id: peering_connection
+          end
         else
-          options[:peerings].each.with_index { |peering, i|
+          options[:peerings].each.with_index do |peering, _i|
             route_tables = peering[:from].map(&:route_table).sort.uniq
             cidrs = peering[:to].map(&:cidr).sort.uniq
 
-            route_tables.product(cidrs).each { |route_table, cidr|
-
+            route_tables.product(cidrs).each do |route_table, cidr|
               hash = Digest::SHA2.hexdigest "#{route_table}-#{tf_safe(cidr)}"
 
-              resource :aws_route, "#{@name}-#{other_vpc_ident}-peer-#{hash}", {
-                route_table_id: route_table,
-                destination_cidr_block: cidr,
-                vpc_peering_connection_id: peering_connection,
-              }
-            }
-          }
+              resource :aws_route, "#{@name}-#{other_vpc_ident}-peer-#{hash}",
+                       route_table_id: route_table,
+                       destination_cidr_block: cidr,
+                       vpc_peering_connection_id: peering_connection
+            end
+          end
         end
       end
 
       def extract_subnet!(bit_size)
-        if bit_size > 28  # aws can't have smaller
-          bit_size = 28
-        end
+        bit_size = 28 if bit_size > 28 # aws can't have smaller
 
-        targets = @remaining_ip_space.find_space({ Subnet: bit_size })
+        targets = @remaining_ip_space.find_space(Subnet: bit_size)
 
         if targets.count == 0
           raise "Run out of ip space to allocate a /#{bit_size}"
@@ -369,14 +344,14 @@ module Terrafying
         if target.bits == bit_size
           new_subnet = target
         else
-          new_subnet = target.subnet({ Bits: bit_size, Objectify: true })[0]
+          new_subnet = target.subnet(Bits: bit_size, Objectify: true)[0]
 
-          target.remainder(new_subnet).each { |rem|
+          target.remainder(new_subnet).each do |rem|
             @remaining_ip_space.add!(rem)
-          }
+          end
         end
 
-        return new_subnet.to_s
+        new_subnet.to_s
       end
 
       def allocate_subnets!(name, options = {})
@@ -384,20 +359,20 @@ module Terrafying
           public: false,
           bit_size: @subnet_size,
           internet: true,
-          tags: {},
+          tags: {}
         }.merge(options)
 
-        if options[:public]
-          gateways = [@internet_gateway] * @azs.count
-        elsif options[:internet] && @nat_gateways != nil
-          gateways = @nat_gateways
-        else
-          gateways = [nil] * @azs.count
-        end
+        gateways = if options[:public]
+                     [@internet_gateway] * @azs.count
+                   elsif options[:internet] && !@nat_gateways.nil?
+                     @nat_gateways
+                   else
+                     [nil] * @azs.count
+                   end
 
-        @subnets[name] = @azs.zip(gateways).map { |az, gateway|
+        @subnets[name] = @azs.zip(gateways).map do |az, gateway|
           subnet_options = { tags: { subnet_name: name }.merge(options[:tags]).merge(@tags) }
-          if gateway != nil
+          unless gateway.nil?
             if options[:public]
               subnet_options[:gateway] = gateway
             elsif options[:internet]
@@ -406,13 +381,10 @@ module Terrafying
           end
 
           add! Terrafying::Components::Subnet.create_in(
-                 self, name, az, extract_subnet!(options[:bit_size]), subnet_options
-               )
-        }
+            self, name, az, extract_subnet!(options[:bit_size]), subnet_options
+          )
+        end
       end
-
     end
-
   end
-
 end