aws-sdk-code-generator 0.1.0.pre → 0.2.4.pre

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

@@ -1,24 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,49 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,28 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

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

@@ -1,65 +0,0 @@
-module AwsSdkCodeGenerator
-  module Generators
-    module Resource
-      class LoadMethod < Dsl::Method
-
-        LOAD_NOT_IMPLEMENTED =
-          "#load is not implemented, data only available via enumeration"
-
-        # @option options [required, String] :resource_name
-        # @option options [required, Hash] :definition
-        def initialize(options = {})
-          @resource_name = options.fetch(:resource_name)
-          @load = options.fetch(:definition)
-          super('load')
-          alias_as('reload')
-          if @load
-            docstring(load_docstring)
-            code do |c|
-              c << client_request
-              c << "@data = resp.#{load_path}"
-              c << "self"
-            end
-          else
-            docstring('@raise [Errors::ResourceNotLoadable]')
-            docstring('@api private')
-            code do |c|
-              c << "msg = #{LOAD_NOT_IMPLEMENTED.inspect}"
-              c << "raise Errors::ResourceNotLoadable, msg"
-            end
-          end
-        end
-
-        private
-
-        def client_request
-          ClientRequest.new(request: @load['request'], resp: true, merge: false)
-        end
-
-        def load_path
-          if @load['path'] == '@'
-            'data'
-          else
-            @load['path'].downcase
-          end
-        end
-
-        def operation_name
-          underscore(@load['request']['operation'])
-        end
-
-        def load_docstring
-          <<-MARKDOWN
-Loads, or reloads {#data} for the current {#{@resource_name}}.
-Returns `self` making it possible to chain methods.
-
-    #{underscore(@resource_name)}.reload.data
-
-@return [self]
-          MARKDOWN
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,68 +0,0 @@
-module AwsSdkCodeGenerator
-  module Generators
-    module Resource
-      class ValueSource < String
-
-        def initialize(value)
-          super(send("param_#{underscore(value['source'])}", value))
-        end
-
-        private
-
-        def param_identifier(param)
-          "@" + underscore(param['name'])
-        end
-
-        def param_data(param)
-          path = param['path']
-          if path == '@'
-            'data'
-          elsif path.match(/^(\w(\[0\])?)+(\.\w+)*$/)
-            'data.' + underscore_path(path)
-          else
-            raise "unsupported path: #{path.inspect}"
-          end
-        end
-
-        def param_response(param)
-          if param['path'] == '@'
-            'resp.data'
-          else
-            'resp.data.' + underscore_path(param['path'])
-          end
-        end
-
-        def param_request_parameter(param)
-          if param['path'].match(/^\w+(\.\w+)*$/)
-            "options" + path_parts(param['path']).map { |part| "[:#{part}]" }.join
-          else
-            raise "unsupported path expression: #{param['path']}"
-          end
-        end
-
-        def param_string(param)
-          param['value'].inspect
-        end
-        alias param_integer param_string
-        alias param_boolean param_string
-
-        def param_input(param)
-          underscore(param['target'])
-        end
-
-        def underscore(str)
-          Underscore.underscore(str)
-        end
-
-        def underscore_path(path)
-          path.gsub(/\w+/) { |part| underscore(part) }
-        end
-
-        def path_parts(path)
-          path.split('.').map { |part| underscore(part) }
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,61 +0,0 @@
-module AwsSdkCodeGenerator
-  module Generators
-    module Resource
-      class WaiterMethod < Dsl::Method
-
-        # @option options [required, String] :resource_name
-        # @option options [required, Hash] :resource
-        # @option options [required, String] :resource_waiter_name
-        # @option options [required, Hash] :resource_waiter
-        # @option options [required, Hash] :waiter
-        def initialize(options)
-          resource_name = options.fetch(:resource_name)
-          @resource = options.fetch(:resource)
-          @resource_waiter = options.fetch(:resource_waiter)
-          @waiter_name = @resource_waiter['waiterName']
-          waiter = options.fetch(:waiter)
-          super("wait_until_#{underscore(options.fetch(:resource_waiter_name))}")
-          param('options', type: 'Hash', default:{})
-          option(name: 'max_attempts', type:Integer, default: waiter['maxAttempts'])
-          option(name: 'delay', type:Float, default: waiter['delay'])
-          option(name: 'before_attempt', type:Proc)
-          option(name: 'before_wait', type:Proc)
-
-          returns(resource_name)
-
-          resp = @resource_waiter['path'] ? 'resp = ' : ''
-          code(<<-CODE)
-options, params = separate_params_and_options(options)
-waiter = Waiters::#{@waiter_name}.new(options)
-yield_waiter_and_warn(waiter, &Proc.new) if block_given?
-#{resp}waiter.wait(params.merge(#{args}))
-#{resource_name}.new(#{constructor_args})
-          CODE
-        end
-
-        private
-
-        def args
-          ClientRequestParams.new(params: @resource_waiter['params']).to_s.strip
-        end
-
-        def constructor_args
-          args = {}
-          (@resource['identifiers'] || []).each do |i|
-            name = underscore(i['name']).to_sym
-            args[name] = "@#{name}"
-          end
-          if @resource_waiter['path']
-            args[:data] = ValueSource.new(
-              'source' => 'response',
-              'path' => @resource_waiter['path']
-            )
-          end
-          args[:client] = '@client'
-          HashFormatter.new.format(args)
-        end
-
-      end
-    end
-  end
-end