aws-sdk-code-generator 0.1.0.pre

data/lib/aws-sdk-code-generator/generators/resource/data_attribute_getter.rb

@@ -0,0 +1,24 @@
+module AwsSdkCodeGenerator
+  module Generators
+    module Resource
+      class DataAttributeGetter < Dsl::Method
+
+        include Helper
+
+        # @option options [required, Hash] :api
+        # @option options [required, String] :member_name
+        # @option options [required, Hash] :member_ref
+        def initialize(options = {})
+          @api = options.fetch(:api)
+          name = underscore(options.fetch(:member_name))
+          member_ref = options.fetch(:member_ref)
+          super(name)
+          docstring(documentation(member_ref))
+          returns(ruby_type(member_ref))
+          code("data.#{name}")
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/generators/resource/data_loaded_method.rb

@@ -0,0 +1,18 @@
+module AwsSdkCodeGenerator
+  module Generators
+    module Resource
+      class DataLoadedMethod < Dsl::Method
+
+        def initialize
+          super('data_loaded?')
+          returns('Boolean', docstring:<<-DOCSTRING)
+Returns `true` if this resource is loaded.  Accessing attributes or
+{#data} on an unloaded resource will trigger a call to {#load}.
+          DOCSTRING
+          code('!!@data')
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/generators/resource/data_method.rb

@@ -0,0 +1,49 @@
+module AwsSdkCodeGenerator
+  module Generators
+    module Resource
+      class DataMethod < Dsl::Method
+
+        # @option options [required, String] :resource_name
+        # @option options [required, Hash] :resource
+        def initialize(options = {})
+          @resource_name = options.fetch(:resource_name)
+          resource = options.fetch(:resource)
+          @shape_name = resource['shape']
+          @load = resource['load'] && resource['load']['request']['operation']
+          super('data')
+          if @shape_name
+            returns("Types::#{@shape_name}", docstring:return_docstring)
+            code do |c|
+              c << 'load unless @data'
+              c << '@data'
+            end
+            if !@load
+              docstring(<<-DOCSTRING)
+@raise [Errors::ResourceNotLoadableError] Raises when {#data_loaded?} is `false`.
+              DOCSTRING
+            end
+          else
+            docstring('@api private')
+            returns('EmptyStructure')
+            code('@data')
+          end
+        end
+
+        private
+
+
+        def return_docstring
+          if @load
+            <<-DOCSTRING
+Returns the data for this {#{@resource_name}}. Calls
+{Client##{underscore(@load)}} if {#data_loaded?} is `false`.
+            DOCSTRING
+          else
+            "Returns the data for this {#{@resource_name}}."
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/generators/resource/exists_method.rb

@@ -0,0 +1,29 @@
+module AwsSdkCodeGenerator
+  module Generators
+    module Resource
+      class ExistsMethod < Dsl::Method
+
+        include Helper
+
+        # @option options [required, String] :resource_name
+        def initialize(options)
+          resource_name = options.fetch(:resource_name)
+          super('exists?')
+          param(:options, type: 'Hash', default: {})
+          returns('Boolean', docstring: "Returns `true` if the #{resource_name} exists.")
+          code <<-CODE
+begin
+  wait_until_exists(options.merge(max_attempts: 1))
+  true
+rescue Aws::Waiters::Errors::UnexpectedError => e
+  raise e.error
+rescue Aws::Waiters::Errors::WaiterFailed
+  false
+end
+          CODE
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/generators/resource/extract_identifier_method.rb

@@ -0,0 +1,32 @@
+module AwsSdkCodeGenerator
+  module Generators
+    module Resource
+      class ExtractIdentifierMethod < Dsl::Method
+
+        include Helper
+
+        # @option options [required, String] :identifier
+        # @option options [required, Integer] :index
+        def initialize(options = {})
+          identifier = options.fetch(:identifier)
+          name = underscore(identifier['name'])
+          type = identifier_type(identifier)
+          super("extract_#{name}", access: :private)
+          param('args')
+          param('options')
+          code(<<-CODE)
+value = args[#{options.fetch(:index)}] || options.delete(:#{name})
+case value
+when #{type} then value
+when nil then raise ArgumentError, "missing required option :#{name}"
+else
+  msg = "expected :#{name} to be a #{type}, got \#{value.class}"
+  raise ArgumentError, msg
+end
+          CODE
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/generators/resource/has_association.rb

@@ -0,0 +1,101 @@
+module AwsSdkCodeGenerator
+  module Generators
+    module Resource
+      class HasAssociation < Dsl::Method
+
+        # @option options [required, String] :name
+        # @option options [required, Hash] :has
+        def initialize(options = {})
+          @has = options.fetch(:has)
+          @data_identifiers = data_identifiers
+          @nullable = !@data_identifiers.empty?
+          @plural = plural?
+          super(underscore(options.fetch(:name)))
+          apply_params
+          apply_code
+          returns(return_type)
+        end
+
+        private
+
+        def return_type
+          if @plural
+            collection_type
+          elsif @nullable
+            "#{type}, nil"
+          else
+            type
+          end
+        end
+
+        def apply_params
+          (@has['resource']['identifiers'] || []).each do |identifier|
+            if identifier['source'] == 'input'
+              param(underscore(identifier['target']), type:'String')
+            end
+          end
+        end
+
+        def type
+          @has['resource']['type']
+        end
+
+        def collection_type
+          "#{type}::Collection"
+        end
+
+        def apply_code
+          if @plural
+            code("batch = []")
+            code(BatchBuilder.new(resource: @has['resource']))
+            code("#{collection_type}.new([batch], size: batch.size)")
+          elsif @nullable # singular association
+            code do |c|
+              c << "if #{null_checks}"
+              c.indent do |c2|
+                c2 << builder
+              end
+              c << "else"
+              c << "  nil"
+              c << "end"
+            end
+          else
+            code(builder)
+          end
+        end
+
+        def builder
+          Builder.new(resource: @has['resource'], request_made: false)
+        end
+
+        def plural?
+          plural = false
+          r = @has['resource']
+          (r['identifiers'] || []).each do |i|
+            if i['path'] && i['path'].include?('[]')
+              plural = true
+              break
+            end
+          end
+          plural = true if r['data'] && r['data'].include?('[]')
+          plural
+        end
+
+        def data_identifiers
+          identifiers = []
+          (@has['resource']['identifiers'] || []).each do |i|
+            identifiers << i if i['source'] == 'data'
+          end
+          identifiers
+        end
+
+        def null_checks
+          @data_identifiers.map do |i|
+            ValueSource.new(i)
+          end.join(' && ')
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/generators/resource/has_many_association.rb

@@ -0,0 +1,108 @@
+module AwsSdkCodeGenerator
+  module Generators
+    module Resource
+
+      # TODO : build and return collection
+      # TODO : filter @option tags related to pagination
+      # TODO : don't filter @option tags that can be merged, e.g. EC2 Filters
+      class HasManyAssociation < Dsl::Method
+
+        # @option options [required, String] :name
+        # @option options [required, Hash] :has_many
+        # @option options [required, Hash] :api
+        # @option options [required, Hash] :paginators
+        # @option options [String] :var_name ('')
+        def initialize(options = {})
+
+          name = options.fetch(:name)
+          @has_many = options.fetch(:has_many)
+          @paginators = options.fetch(:paginators)
+          @var_name = options.fetch(:var_name, '')
+
+          super(underscore(name))
+
+          param('options', type:Hash, default:{})
+
+          ClientRequestDocs.new(
+            request: @has_many['request'],
+            api: options.fetch(:api),
+            skip: paging_options,
+            var_name: @var_name,
+            returns: name.downcase,
+          ).apply(self)
+
+          paginated? ? paginated_reqeust : non_paginated_request
+
+          returns(collection_class)
+        end
+
+        private
+
+        def paginated_reqeust
+          code do |c1|
+            c1 << 'batches = Enumerator.new do |y|'
+            c1.indent do |c2|
+              c2 << client_request(true)
+              c2 << "resp.each_page do |page|"
+              c2.indent do |c3|
+                c3 << 'batch = []'
+                c3 << BatchBuilder.new(resource: @has_many['resource'], resp_var_name:'page')
+                c3 << 'y.yield(batch)'
+              end
+              c2 << 'end'
+            end
+            c1 << 'end'
+            c1 << "#{collection_class}.new(batches)"
+          end
+        end
+
+        def non_paginated_request
+          code do |code|
+            code << 'batches = Enumerator.new do |y|'
+            code.indent do |c|
+              c << 'batch = []'
+              c << client_request(true)
+              c << BatchBuilder.new(resource: @has_many['resource'])
+              c << 'y.yield(batch)'
+            end
+            code << 'end'
+            code << "#{collection_class}.new(batches)"
+          end
+        end
+
+        def client_request(resp)
+          ClientRequest.new(
+            request: @has_many['request'],
+            resp: resp
+          )
+        end
+
+        def collection_class
+          "#{@has_many['resource']['type']}::Collection"
+        end
+
+        def paginated?
+          @paginators &&
+          @paginators['pagination'][operation_name] &&
+          @paginators['pagination'][operation_name]['input_token']
+        end
+
+        def paging_options
+          if paginated?
+            skip = []
+            skip << @paginators['pagination'][operation_name]['input_token']
+            skip << @paginators['pagination'][operation_name]['limit_key']
+            skip.compact
+          else
+            []
+          end
+        end
+
+        def operation_name
+          @has_many['request']['operation']
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/generators/resource/identifier_getter.rb

@@ -0,0 +1,26 @@
+module AwsSdkCodeGenerator
+  module Generators
+    module Resource
+      class IdentifierGetter < Dsl::Method
+
+        include Helper
+
+        # @option options [required, Hash] :identifier
+        def initialize(options)
+          identifier = options.fetch(:identifier)
+          name = underscore(identifier.fetch('name'))
+          super(name)
+          returns(identifier_type(identifier))
+          code("@#{name}")
+          if
+            identifier['memberName'] &&
+            identifier['memberName'] != identifier['name']
+          then
+            alias_as(underscore(identifier['memberName']))
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/generators/resource/identifiers_method.rb

@@ -0,0 +1,28 @@
+module AwsSdkCodeGenerator
+  module Generators
+    module Resource
+      class IdentifiersMethod < Dsl::Method
+
+        # @option options [required, Array<Hash>] :identifiers
+        def initialize(options = {})
+          identifiers = options.fetch(:identifiers)
+          super('identifiers')
+          docstring('@deprecated')
+          docstring('@api private')
+          identifiers ||= []
+          identifiers = (identifiers || []).inject({}) do |hash, identifier|
+            name = underscore(identifier['name'])
+            hash[name.to_sym] = "@#{name}"
+            hash
+          end
+          code(HashFormatter.new(inline: true).format(identifiers))
+        end
+
+        def lines
+          super + ["deprecated(:#{name})"]
+        end
+
+      end
+    end
+  end
+end

data/lib/aws-sdk-code-generator/generators/resource/initialize_method.rb

@@ -0,0 +1,67 @@
+module AwsSdkCodeGenerator
+  module Generators
+    module Resource
+      class InitializeMethod < Dsl::Method
+
+        include Helper
+
+        # @option options [required, Hash] :resource]
+        def initialize(options = {})
+          resource = options.fetch(:resource)
+          @identifiers = resource["identifiers"] || []
+          @shape_name = resource["shape"]
+          super('initialize')
+          param('*args')
+          positional_docstring unless @identifiers.empty?
+          options_docstring
+          code('options = Hash === args.last ? args.pop.dup : {}')
+          extract_identifiers
+          if @shape_name
+            code('@data = options.delete(:data)')
+          else
+            code('@data = Aws::EmptyStructure.new')
+          end
+          code('@client = options.delete(:client) || Client.new(options)')
+        end
+
+        private
+
+        def positional_docstring
+          names = @identifiers.map { |i| underscore(i['name']) }.join(', ')
+          docstring("@overload def initialize(#{names}, options = {})")
+          identifiers.each do |name, type, n|
+            docstring("  @param [#{type}] #{name}")
+          end
+          apply_client_option
+        end
+
+        def options_docstring
+          docstring("@overload def initialize(options = {})")
+          identifiers.each do |name, type, n|
+            docstring("  @option options [required, #{type}] :#{name}")
+          end
+          apply_client_option
+        end
+
+        def apply_client_option
+          docstring("  @option options [Client] :client")
+        end
+
+        def extract_identifiers
+          identifiers.each do |name, type, n|
+            code("@#{name} = extract_#{name}(args, options)")
+          end
+        end
+
+        def identifiers
+          Enumerator.new do |y|
+            @identifiers.each.with_index do |i, n|
+              y.yield(underscore(i['name']), identifier_type(i), n)
+            end
+          end
+        end
+
+      end
+    end
+  end
+end