terraforming 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f2efd2fcc749aae8e786423ae3e8d46be4cf852
-  data.tar.gz: b99a7cfe20ed485d646fe455b1e38c225bdbbf9d
+  metadata.gz: e0d4e58b3e575b0651e800cad36a2fb8c58780cc
+  data.tar.gz: 12a4b4fb459f47b28089fcd063bad8b4e720b94f
 SHA512:
-  metadata.gz: 1caa9dd2b3d02d284643323c9cc0c3977e7765dec2efe61b517e9da24d084313b5b20e6731d5a691cf967576a870ce41d23c57d38c0f70eb9da18a42e40a145a
-  data.tar.gz: a369651650377159062123d710077bc9529177a110c94488d33ca41fc9dd59e55396e686de6f59b0d237479508614bfff8747a69e46bd09d12aa3135bb693d5b
+  metadata.gz: 0a56a65bff72645122cfd3191dd5354fb9c133528e4d3c4374e84a356ab8621bb31ec5d64d1371d8fa4294484f719f8f3981e9b6825c6f074bd0be105a861270
+  data.tar.gz: 347f65090624c3eac681ed58a8e66dcd0c84a4d47606811e428261449dae95232037d48e2f19db3adba69ce6e0178978dce55ac17e404a53b9a53fd8470678c3

data/CHANGELOG.md

@@ -1,3 +1,10 @@
+# [v0.1.4](https://github.com/dtan4/terraforming/releases/tag/v0.1.4) (2015-08-07)
+
+### Fixed
+
+- Refactor internal implements to reduce code #106
+- Add tests and improvement for Security Group #105
+
 # [v0.1.3](https://github.com/dtan4/terraforming/releases/tag/v0.1.3) (2015-08-01)
 
 ### Fixed

data/lib/terraforming/cli.rb

@@ -126,20 +126,35 @@ module Terraforming
     private
 
     def execute(klass, options)
-      result = if options[:tfstate]
-                 tfstate(klass, options[:merge])
-               else
-                 klass.tf
-               end
-
+      result = options[:tfstate] ? tfstate(klass, options[:merge]) : tf(klass)
       puts result
     end
 
-    def tfstate(klass, tfstate_path)
-      return klass.tfstate unless tfstate_path
+    def tf(klass)
+      klass.tf
+    end
 
-      tfstate_base = JSON.parse(open(tfstate_path).read)
-      klass.tfstate(tfstate_base: tfstate_base)
+    def tfstate(klass, tfstate_path)
+      tfstate = tfstate_path ? JSON.parse(open(tfstate_path).read) : tfstate_skeleton
+      tfstate["serial"] = tfstate["serial"] + 1
+      tfstate["modules"][0]["resources"] = tfstate["modules"][0]["resources"].merge(klass.tfstate)
+      JSON.pretty_generate(tfstate)
+    end
+
+    def tfstate_skeleton
+      {
+        "version" => 1,
+        "serial" => 0,
+        "modules" => [
+          {
+            "path" => [
+              "root"
+            ],
+            "outputs" => {},
+            "resources" => {},
+          }
+        ]
+      }
     end
   end
 end

data/lib/terraforming/resource/db_parameter_group.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::RDS::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::RDS::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/db_parameter_group")
       end
 
-      def tfstate(tfstate_base)
-        resources = db_parameter_groups.inject({}) do |result, parameter_group|
+      def tfstate
+        db_parameter_groups.inject({}) do |resources, parameter_group|
           attributes = {
             "description" => parameter_group.description,
             "family" => parameter_group.db_parameter_group_family,
@@ -28,7 +28,7 @@ module Terraforming
             "name" => parameter_group.db_parameter_group_name,
             "parameter.#" => db_parameters_in(parameter_group).length.to_s
           }
-          result["aws_db_parameter_group.#{module_name_of(parameter_group)}"] = {
+          resources["aws_db_parameter_group.#{module_name_of(parameter_group)}"] = {
             "type" => "aws_db_parameter_group",
             "primary" => {
               "id" => parameter_group.db_parameter_group_name,
@@ -36,10 +36,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/db_security_group.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::RDS::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::RDS::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,15 +19,15 @@ module Terraforming
         apply_template(@client, "tf/db_security_group")
       end
 
-      def tfstate(tfstate_base)
-        resources = db_security_groups.inject({}) do |result, security_group|
+      def tfstate
+        db_security_groups.inject({}) do |resources, security_group|
           attributes = {
             "db_subnet_group_name" => security_group.db_security_group_name,
             "id" => security_group.db_security_group_name,
             "ingress.#" => (security_group.ec2_security_groups.length + security_group.ip_ranges.length).to_s,
             "name" => security_group.db_security_group_name,
           }
-          result["aws_db_security_group.#{module_name_of(security_group)}"] = {
+          resources["aws_db_security_group.#{module_name_of(security_group)}"] = {
             "type" => "aws_db_security_group",
             "primary" => {
               "id" => security_group.db_security_group_name,
@@ -35,10 +35,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/db_subnet_group.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::RDS::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::RDS::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,14 +19,14 @@ module Terraforming
         apply_template(@client, "tf/db_subnet_group")
       end
 
-      def tfstate(tfstate_base)
-        resources = db_subnet_groups.inject({}) do |result, subnet_group|
+      def tfstate
+        db_subnet_groups.inject({}) do |resources, subnet_group|
           attributes = {
             "description" => subnet_group.db_subnet_group_description,
             "name" => subnet_group.db_subnet_group_name,
             "subnet_ids.#" => subnet_group.subnets.length.to_s
           }
-          result["aws_db_subnet_group.#{module_name_of(subnet_group)}"] = {
+          resources["aws_db_subnet_group.#{module_name_of(subnet_group)}"] = {
             "type" => "aws_db_subnet_group",
             "primary" => {
               "id" => subnet_group.db_subnet_group_name,
@@ -34,10 +34,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/ec2.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::EC2::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::EC2::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/ec2")
       end
 
-      def tfstate(tfstate_base)
-        resources = instances.inject({}) do |result, instance|
+      def tfstate
+        instances.inject({}) do |resources, instance|
           in_vpc = in_vpc?(instance)
           block_devices = block_devices_of(instance)
 
@@ -46,7 +46,7 @@ module Terraforming
 
           attributes["subnet_id"] = instance.subnet_id if in_vpc?(instance)
 
-          result["aws_instance.#{module_name_of(instance)}"] = {
+          resources["aws_instance.#{module_name_of(instance)}"] = {
             "type" => "aws_instance",
             "primary" => {
               "id" => instance.instance_id,
@@ -57,10 +57,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/elasti_cache_cluster.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::ElastiCache::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::ElastiCache::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/elasti_cache_cluster")
       end
 
-      def tfstate(tfstate_base)
-        resources = cache_clusters.inject({}) do |result, cache_cluster|
+      def tfstate
+        cache_clusters.inject({}) do |resources, cache_cluster|
           attributes = {
             "cache_nodes.#" => cache_cluster.cache_nodes.length.to_s,
             "cluster_id" => cache_cluster.cache_cluster_id,
@@ -36,7 +36,7 @@ module Terraforming
             "subnet_group_name" => cache_cluster.cache_subnet_group_name,
             "tags.#" => "0",
           }
-          result["aws_elasticache_cluster.#{cache_cluster.cache_cluster_id}"] = {
+          resources["aws_elasticache_cluster.#{cache_cluster.cache_cluster_id}"] = {
             "type" => "aws_elasticache_cluster",
             "primary" => {
               "id" => cache_cluster.cache_cluster_id,
@@ -44,10 +44,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/elasti_cache_subnet_group.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::ElastiCache::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::ElastiCache::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,14 +19,14 @@ module Terraforming
         apply_template(@client, "tf/elasti_cache_subnet_group")
       end
 
-      def tfstate(tfstate_base)
-        resources = cache_subnet_groups.inject({}) do |result, cache_subnet_group|
+      def tfstate
+        cache_subnet_groups.inject({}) do |resources, cache_subnet_group|
           attributes = {
             "description" => cache_subnet_group.cache_subnet_group_description,
             "name" => cache_subnet_group.cache_subnet_group_name,
             "subnet_ids.#" => subnet_ids_of(cache_subnet_group).length.to_s,
           }
-          result["aws_elasticache_subnet_group.#{cache_subnet_group.cache_subnet_group_name}"] = {
+          resources["aws_elasticache_subnet_group.#{cache_subnet_group.cache_subnet_group_name}"] = {
             "type" => "aws_elasticache_subnet_group",
             "primary" => {
               "id" => cache_subnet_group.cache_subnet_group_name,
@@ -34,10 +34,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/elb.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::ElasticLoadBalancing::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::ElasticLoadBalancing::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/elb")
       end
 
-      def tfstate(tfstate_base)
-        resources = load_balancers.inject({}) do |result, load_balancer|
+      def tfstate
+        load_balancers.inject({}) do |resources, load_balancer|
           load_balancer_attributes = load_balancer_attributes_of(load_balancer)
           attributes = {
             "availability_zones.#" => load_balancer.availability_zones.length.to_s,
@@ -43,7 +43,7 @@ module Terraforming
           attributes.merge!(tags_attributes_of(load_balancer))
 
 
-          result["aws_elb.#{module_name_of(load_balancer)}"] = {
+          resources["aws_elb.#{module_name_of(load_balancer)}"] = {
             "type" => "aws_elb",
             "primary" => {
               "id" => load_balancer.load_balancer_name,
@@ -51,10 +51,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       def healthcheck_attributes_of(elb)

data/lib/terraforming/resource/iam_group.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::IAM::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::IAM::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/iam_group")
       end
 
-      def tfstate(tfstate_base)
-        resources = iam_groups.inject({}) do |result, group|
+      def tfstate
+        iam_groups.inject({}) do |resources, group|
           attributes = {
             "arn"=> group.arn,
             "id" => group.group_name,
@@ -28,7 +28,7 @@ module Terraforming
             "path" => group.path,
             "unique_id" => group.group_id,
           }
-          result["aws_iam_group.#{group.group_name}"] = {
+          resources["aws_iam_group.#{group.group_name}"] = {
             "type" => "aws_iam_group",
             "primary" => {
               "id" => group.group_name,
@@ -36,10 +36,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/iam_group_membership.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::IAM::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::IAM::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/iam_group_membership")
       end
 
-      def tfstate(tfstate_base)
-        resources = iam_groups.inject({}) do |result, group|
+      def tfstate
+        iam_groups.inject({}) do |resources, group|
           membership_name = membership_name_of(group)
 
           attributes = {
@@ -29,7 +29,7 @@ module Terraforming
             "name" => membership_name,
             "users.#" => group_members_of(group).length.to_s,
           }
-          result["aws_iam_group_membership.#{group.group_name}"] = {
+          resources["aws_iam_group_membership.#{group.group_name}"] = {
             "type" => "aws_iam_group_membership",
             "primary" => {
               "id" => membership_name,
@@ -37,10 +37,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/iam_group_policy.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::IAM::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::IAM::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,15 +19,15 @@ module Terraforming
         apply_template(@client, "tf/iam_group_policy")
       end
 
-      def tfstate(tfstate_base)
-        resources = iam_group_policies.inject({}) do |result, policy|
+      def tfstate
+        iam_group_policies.inject({}) do |resources, policy|
           attributes = {
             "group" => policy.group_name,
             "id" => iam_group_policy_id_of(policy),
             "name" => policy.policy_name,
             "policy" => prettify_policy(policy.policy_document, true)
           }
-          result["aws_iam_group_policy.#{policy.policy_name}"] = {
+          resources["aws_iam_group_policy.#{policy.policy_name}"] = {
             "type" => "aws_iam_group_policy",
             "primary" => {
               "id" => iam_group_policy_id_of(policy),
@@ -35,10 +35,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/iam_instance_profile.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::IAM::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::IAM::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/iam_instance_profile")
       end
 
-      def tfstate(tfstate_base)
-        resources = iam_instance_profiles.inject({}) do |result, profile|
+      def tfstate
+        iam_instance_profiles.inject({}) do |resources, profile|
           attributes = {
             "arn" => profile.arn,
             "id" => profile.instance_profile_name,
@@ -28,7 +28,7 @@ module Terraforming
             "path" => profile.path,
             "roles.#" => profile.roles.length.to_s,
           }
-          result["aws_iam_instance_profile.#{profile.instance_profile_name}"] = {
+          resources["aws_iam_instance_profile.#{profile.instance_profile_name}"] = {
             "type" => "aws_iam_instance_profile",
             "primary" => {
               "id" => profile.instance_profile_name,
@@ -36,10 +36,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/iam_policy.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::IAM::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::IAM::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/iam_policy")
       end
 
-      def tfstate(tfstate_base)
-        resources = iam_policies.inject({}) do |result, policy|
+      def tfstate
+        iam_policies.inject({}) do |resources, policy|
           version = iam_policy_version_of(policy)
           attributes = {
             "id" => policy.arn,
@@ -28,7 +28,7 @@ module Terraforming
             "path" => policy.path,
             "policy" => prettify_policy(version.document, true),
           }
-          result["aws_iam_policy.#{policy.policy_name}"] = {
+          resources["aws_iam_policy.#{policy.policy_name}"] = {
             "type" => "aws_iam_policy",
             "primary" => {
               "id" => policy.arn,
@@ -36,10 +36,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/iam_role.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::IAM::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::IAM::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/iam_role")
       end
 
-      def tfstate(tfstate_base)
-        resources = iam_roles.inject({}) do |result, role|
+      def tfstate
+        iam_roles.inject({}) do |resources, role|
           attributes = {
             "arn" => role.arn,
             "assume_role_policy" => prettify_policy(role.assume_role_policy_document, true),
@@ -29,7 +29,7 @@ module Terraforming
             "path" => role.path,
             "unique_id" => role.role_id,
           }
-          result["aws_iam_role.#{role.role_name}"] = {
+          resources["aws_iam_role.#{role.role_name}"] = {
             "type" => "aws_iam_role",
             "primary" => {
               "id" => role.role_name,
@@ -37,10 +37,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/iam_role_policy.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::IAM::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::IAM::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,15 +19,15 @@ module Terraforming
         apply_template(@client, "tf/iam_role_policy")
       end
 
-      def tfstate(tfstate_base)
-        resources = iam_role_policies.inject({}) do |result, policy|
+      def tfstate
+        iam_role_policies.inject({}) do |resources, policy|
           attributes = {
             "id" => iam_role_policy_id_of(policy),
             "name" => policy.policy_name,
             "policy" => prettify_policy(policy.policy_document, true),
             "role" => policy.role_name,
           }
-          result["aws_iam_role_policy.#{policy.policy_name}"] = {
+          resources["aws_iam_role_policy.#{policy.policy_name}"] = {
             "type" => "aws_iam_role_policy",
             "primary" => {
               "id" => iam_role_policy_id_of(policy),
@@ -35,10 +35,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/iam_user.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::IAM::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::IAM::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/iam_user")
       end
 
-      def tfstate(tfstate_base)
-        resources = iam_users.inject({}) do |result, user|
+      def tfstate
+        iam_users.inject({}) do |resources, user|
           attributes = {
             "arn"=> user.arn,
             "id" => user.user_name,
@@ -28,7 +28,7 @@ module Terraforming
             "path" => user.path,
             "unique_id" => user.user_id,
           }
-          result["aws_iam_user.#{user.user_name}"] = {
+          resources["aws_iam_user.#{user.user_name}"] = {
             "type" => "aws_iam_user",
             "primary" => {
               "id" => user.user_name,
@@ -36,10 +36,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/iam_user_policy.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::IAM::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::IAM::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,15 +19,15 @@ module Terraforming
         apply_template(@client, "tf/iam_user_policy")
       end
 
-      def tfstate(tfstate_base)
-        resources = iam_user_policies.inject({}) do |result, policy|
+      def tfstate
+        iam_user_policies.inject({}) do |resources, policy|
           attributes = {
             "id" => iam_user_policy_id_of(policy),
             "name" => policy.policy_name,
             "policy" => prettify_policy(policy.policy_document, true),
             "user" => policy.user_name,
           }
-          result["aws_iam_user_policy.#{policy.policy_name}"] = {
+          resources["aws_iam_user_policy.#{policy.policy_name}"] = {
             "type" => "aws_iam_user_policy",
             "primary" => {
               "id" => iam_user_policy_id_of(policy),
@@ -35,10 +35,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/network_acl.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::EC2::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::EC2::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/network_acl")
       end
 
-      def tfstate(tfstate_base)
-        resources = network_acls.inject({}) do |result, network_acl|
+      def tfstate
+        network_acls.inject({}) do |resources, network_acl|
           attributes = {
             "egress.#" => egresses_of(network_acl).length.to_s,
             "id" => network_acl.network_acl_id,
@@ -29,7 +29,7 @@ module Terraforming
             "tags.#" => network_acl.tags.length.to_s,
             "vpc_id" => network_acl.vpc_id,
           }
-          result["aws_network_acl.#{module_name_of(network_acl)}"] = {
+          resources["aws_network_acl.#{module_name_of(network_acl)}"] = {
             "type" => "aws_network_acl",
             "primary" => {
               "id" => network_acl.network_acl_id,
@@ -37,10 +37,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/rds.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::RDS::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::RDS::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/rds")
       end
 
-      def tfstate(tfstate_base)
-        resources = db_instances.inject({}) do |result, instance|
+      def tfstate
+        db_instances.inject({}) do |resources, instance|
           attributes = {
             "address" => instance.endpoint.address,
             "allocated_storage" => instance.allocated_storage.to_s,
@@ -48,7 +48,7 @@ module Terraforming
             "username" => instance.master_username,
             "vpc_security_group_ids.#" => instance.vpc_security_groups.length.to_s,
           }
-          result["aws_db_instance.#{module_name_of(instance)}"] = {
+          resources["aws_db_instance.#{module_name_of(instance)}"] = {
             "type" => "aws_db_instance",
             "primary" => {
               "id" => instance.db_instance_identifier,
@@ -56,10 +56,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/route53_record.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::Route53::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::Route53::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/route53_record")
       end
 
-      def tfstate(tfstate_base)
-        resources = records.inject({}) do |result, r|
+      def tfstate
+        records.inject({}) do |resources, r|
           record, zone_id = r[:record], r[:zone_id]
           record_id = record_id_of(record, zone_id)
 
@@ -37,7 +37,7 @@ module Terraforming
           attributes["weight"] = record.weight.to_s if record.weight
           attributes["set_identifier"] = record.set_identifier if record.set_identifier
 
-          result["aws_route53_record.#{module_name_of(record)}"] = {
+          resources["aws_route53_record.#{module_name_of(record)}"] = {
             "type" => "aws_route53_record",
             "primary" => {
               "id" => record_id,
@@ -45,10 +45,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/route53_zone.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::Route53::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::Route53::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/route53_zone")
       end
 
-      def tfstate(tfstate_base)
-        resources = hosted_zones.inject({}) do |result, hosted_zone|
+      def tfstate
+        hosted_zones.inject({}) do |resources, hosted_zone|
           zone_id = zone_id_of(hosted_zone)
 
           attributes = {
@@ -30,7 +30,7 @@ module Terraforming
             "tags.#" => tags_of(hosted_zone).length.to_s,
             "zone_id" => zone_id,
           }
-          result["aws_route53_zone.#{module_name_of(hosted_zone)}"] = {
+          resources["aws_route53_zone.#{module_name_of(hosted_zone)}"] = {
             "type" => "aws_route53_zone",
             "primary" => {
               "id" => zone_id,
@@ -38,10 +38,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/s3.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::S3::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::S3::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,9 +19,9 @@ module Terraforming
         apply_template(@client, "tf/s3")
       end
 
-      def tfstate(tfstate_base)
-        resources = buckets.inject({}) do |result, bucket|
-          result["aws_s3_bucket.#{module_name_of(bucket)}"] = {
+      def tfstate
+        buckets.inject({}) do |resources, bucket|
+          resources["aws_s3_bucket.#{module_name_of(bucket)}"] = {
             "type" => "aws_s3_bucket",
             "primary" => {
               "id" => bucket.name,
@@ -33,10 +33,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/security_group.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::EC2::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::EC2::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/security_group")
       end
 
-      def tfstate(tfstate_base)
-        resources = security_groups.inject({}) do |result, security_group|
+      def tfstate
+        security_groups.inject({}) do |resources, security_group|
           attributes = {
             "description" => security_group.description,
             "id" => security_group.group_id,
@@ -33,7 +33,7 @@ module Terraforming
           attributes.merge!(egress_attributes_of(security_group))
           attributes.merge!(ingress_attributes_of(security_group))
 
-          result["aws_security_group.#{module_name_of(security_group)}"] = {
+          resources["aws_security_group.#{module_name_of(security_group)}"] = {
             "type" => "aws_security_group",
             "primary" => {
               "id" => security_group.group_id,
@@ -41,18 +41,17 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private
 
       def ingress_attributes_of(security_group)
-        attributes = { "ingress.#" => security_group.ip_permissions.length.to_s }
+        ingresses = dedup_permissions(security_group.ip_permissions, security_group.group_id)
+        attributes = { "ingress.#" => ingresses.length.to_s }
 
-        dedup_permissions(security_group).ip_permissions.each do |permission|
+        ingresses.each do |permission|
           attributes.merge!(permission_attributes_of(security_group, permission, "ingress"))
         end
 
@@ -60,9 +59,10 @@ module Terraforming
       end
 
       def egress_attributes_of(security_group)
-        attributes = { "egress.#" => security_group.ip_permissions_egress.length.to_s }
+        egresses = dedup_permissions(security_group.ip_permissions_egress, security_group.group_id)
+        attributes = { "egress.#" => egresses.length.to_s }
 
-        dedup_permissions(security_group).ip_permissions_egress.each do |permission|
+        egresses.each do |permission|
           attributes.merge!(permission_attributes_of(security_group, permission, "egress"))
         end
 
@@ -101,48 +101,33 @@ module Terraforming
         attributes
       end
 
-      def dedup_permissions(security_group)
-        grouped_ingress = security_group.ip_permissions.group_by {|perm| [perm.ip_protocol, perm.to_port, perm.from_port]}
-        grouped_egress = security_group.ip_permissions_egress.group_by {|perm| [perm.ip_protocol, perm.to_port, perm.from_port]}
-
-        security_group.ip_permissions = []
-        security_group.ip_permissions_egress = []
+      def dedup_permissions(permissions, group_id)
+        group_permissions(permissions).inject([]) do |result, (_, perms)|
+          group_ids = perms.map(&:user_id_group_pairs).flatten.map(&:group_id)
 
-        grouped_ingress.each do |range, perms|
-          if perms.length == 1
-            security_group.ip_permissions << perms.first
+          if group_ids.length == 1 && group_ids.first == group_id
+            result << merge_permissions(perms)
           else
-            g_ids = perms.map {|perm| perm.user_id_group_pairs}.flatten.map {|gp| gp.group_id}
-            if g_ids.length == 1 && g_ids.first == security_group.group_id
-              security_group.ip_permissions << merge_perms(perms)
-            else
-              security_group.ip_permissions.concat(perms)
-            end
+            result.concat(perms)
           end
-        end
 
-        grouped_egress.each do |range, perms|
-          if perms.length == 1
-            security_group.ip_permissions_egress << perms.first
-          else
-            g_ids = perms.map {|perm| perm.user_id_group_pairs}.flatten.map {|gp| gp.group_id}
-            if g_ids.length == 1 && g_ids.first == security_group.group_id
-              security_group.ip_permissions_egress << merge_perms(perms)
-            else
-              security_group.ip_permissions_egress.concat(perms)
-            end
-          end
+          result
         end
-        security_group
       end
 
-      def merge_perms(permissions)
-        master_perm = permissions.pop
-        permissions.each do |perm|
-          master_perm.user_id_group_pairs.concat(perm.user_id_group_pairs)
-          master_perm.ip_ranges.concat(perm.ip_ranges)
+      def group_permissions(permissions)
+        permissions.group_by { |permission| [permission.ip_protocol, permission.to_port, permission.from_port] }
+      end
+
+      def merge_permissions(permissions)
+        master_permission = permissions.pop
+
+        permissions.each do |permission|
+          master_permission.user_id_group_pairs.concat(permission.user_id_group_pairs)
+          master_permission.ip_ranges.concat(permission.ip_ranges)
         end
-        master_perm
+
+        master_permission
       end
 
       def permission_hashcode_of(security_group, permission)

data/lib/terraforming/resource/subnet.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::EC2::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::EC2::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/subnet")
       end
 
-      def tfstate(tfstate_base)
-        resources = subnets.inject({}) do |result, subnet|
+      def tfstate
+        subnets.inject({}) do |resources, subnet|
           attributes = {
             "availability_zone" => subnet.availability_zone,
             "cidr_block" => subnet.cidr_block,
@@ -29,7 +29,7 @@ module Terraforming
             "tags.#" => subnet.tags.length.to_s,
             "vpc_id" => subnet.vpc_id,
           }
-          result["aws_subnet.#{module_name_of(subnet)}"] = {
+          resources["aws_subnet.#{module_name_of(subnet)}"] = {
             "type" => "aws_subnet",
             "primary" => {
               "id" => subnet.subnet_id,
@@ -37,10 +37,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/resource/vpc.rb

@@ -7,8 +7,8 @@ module Terraforming
         self.new(client).tf
       end
 
-      def self.tfstate(client: Aws::EC2::Client.new, tfstate_base: nil)
-        self.new(client).tfstate(tfstate_base)
+      def self.tfstate(client: Aws::EC2::Client.new)
+        self.new(client).tfstate
       end
 
       def initialize(client)
@@ -19,8 +19,8 @@ module Terraforming
         apply_template(@client, "tf/vpc")
       end
 
-      def tfstate(tfstate_base)
-        resources = vpcs.inject({}) do |result, vpc|
+      def tfstate
+        vpcs.inject({}) do |resources, vpc|
           attributes = {
             "cidr_block" => vpc.cidr_block,
             "enable_dns_hostnames" => enable_dns_hostnames?(vpc).to_s,
@@ -29,7 +29,7 @@ module Terraforming
             "instance_tenancy" => vpc.instance_tenancy,
             "tags.#" => vpc.tags.length.to_s,
           }
-          result["aws_vpc.#{module_name_of(vpc)}"] = {
+          resources["aws_vpc.#{module_name_of(vpc)}"] = {
             "type" => "aws_vpc",
             "primary" => {
               "id" => vpc.vpc_id,
@@ -37,10 +37,8 @@ module Terraforming
             }
           }
 
-          result
+          resources
         end
-
-        generate_tfstate(resources, tfstate_base)
       end
 
       private

data/lib/terraforming/template/tf/security_group.erb

@@ -4,7 +4,7 @@ resource "aws_security_group" "<%= module_name_of(security_group) %>" {
     description = "<%= security_group.description %>"
     vpc_id      = "<%= security_group.vpc_id || '' %>"
 
-<% dedup_permissions(security_group).ip_permissions.each do |permission| -%>
+<% dedup_permissions(security_group.ip_permissions, security_group.group_id).each do |permission| -%>
   <%- security_groups = security_groups_in(permission).reject { |group_id| group_id == security_group.group_id } -%>
     ingress {
         from_port       = <%= permission.from_port || 0 %>
@@ -24,7 +24,7 @@ resource "aws_security_group" "<%= module_name_of(security_group) %>" {
 
 <% end -%>
 
-<% dedup_permissions(security_group).ip_permissions_egress.each do |permission| -%>
+<% dedup_permissions(security_group.ip_permissions_egress, security_group.group_id).each do |permission| -%>
     egress {
         from_port       = <%= permission.from_port || 0 %>
         to_port         = <%= permission.to_port || 0 %>

data/lib/terraforming/util.rb

@@ -17,13 +17,6 @@ module Terraforming
       File.join(File.expand_path(File.dirname(__FILE__)), "template", template_name) << ".erb"
     end
 
-    def generate_tfstate(resources, tfstate_base = nil)
-      tfstate = tfstate_base || tfstate_skeleton
-      tfstate["serial"] = tfstate["serial"] + 1
-      tfstate["modules"][0]["resources"] = tfstate["modules"][0]["resources"].merge(resources)
-      JSON.pretty_generate(tfstate)
-    end
-
     def prettify_policy(policy_document, breakline = false)
       json = JSON.pretty_generate(JSON.parse(CGI.unescape(policy_document)))
 
@@ -33,21 +26,5 @@ module Terraforming
         json.strip
       end
     end
-
-    def tfstate_skeleton
-      {
-        "version" => 1,
-        "serial" => 0,
-        "modules" => [
-          {
-            "path" => [
-              "root"
-            ],
-            "outputs" => {},
-            "resources" => {},
-          }
-        ]
-      }
-    end
   end
 end

data/lib/terraforming/version.rb

@@ -1,3 +1,3 @@
 module Terraforming
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: terraforming
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Daisuke Fujita
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-01 00:00:00.000000000 Z
+date: 2015-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -258,8 +258,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: Export existing AWS resources to Terraform style (tf, tfstate)
 test_files: []
+has_rdoc: