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

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

data/lib/aws-sdk-code-generator/generators/resource_class.rb

@@ -1,325 +0,0 @@
-require 'set'
-
-module AwsSdkCodeGenerator
-  module Generators
-    class ResourceClass < Dsl::Class
-
-      extend Helper
-
-      # @option options [required, String] :name
-      # @option options [required, Hash] :resource
-      # @option options [required, Hash] :api
-      # @option options [Hash] :paginators
-      # @option options [Hash] :waiters
-      # @option options [String] :var_name (underscore(name))
-      def initialize(options)
-        @api = options.fetch(:api)
-        @name = options.fetch(:name)
-        @resource = options.fetch(:resource)
-        @paginators = options.fetch(:paginators, nil)
-        @waiters = options.fetch(:waiters, nil)
-        @var_name = options.fetch(:var_name, underscore(@name))
-        super(@name)
-        build
-        check_for_method_name_conflicts!
-      end
-
-      private
-
-      def build
-        extend_module('Aws::Deprecations')
-        add(initialize_method)
-        code('# @!group Read-Only Attributes')
-        add(*identifier_getters)
-        add(*data_attribute_getters)
-        code('# @!endgroup')
-        add(client_getter)
-        add(load_method)
-        add(data_method)
-        add(data_loaded_method)
-        add(exists_method)
-        add(*waiters)
-        apply_actions
-        apply_associations
-        add(identifiers_method)
-        add(*private_methods)
-        add(batch_action)
-      end
-
-      def initialize_method
-        Generators::Resource::InitializeMethod.new(resource: @resource)
-      end
-
-      def identifier_getters
-        identifiers.map do |i|
-          Generators::Resource::IdentifierGetter.new(identifier: i)
-        end
-      end
-
-      def data_attribute_getters
-        data_attribute_names.map do |member_name, member_ref|
-          Generators::Resource::DataAttributeGetter.new(
-            api: @api,
-            member_name: member_name,
-            member_ref: member_ref
-          )
-        end
-      end
-
-      def client_getter
-        Generators::Resource::ClientGetter.new
-      end
-
-      def load_method
-        Generators::Resource::LoadMethod.new(
-          resource_name: @name,
-          definition: @resource['load']
-        )
-      end
-
-      def data_method
-        Generators::Resource::DataMethod.new(
-          resource_name: @name,
-          resource: @resource
-        )
-      end
-
-      def data_loaded_method
-        Generators::Resource::DataLoadedMethod.new
-      end
-
-      def exists_method
-        if @resource['waiters'] && @resource['waiters']['Exists']
-          Generators::Resource::ExistsMethod.new(
-            resource_name: @name,
-            resource: @resource,
-            waiters: @waiters,
-          )
-        end
-      end
-
-      def waiters
-        (@resource['waiters'] || {}).map do |waiter_name, waiter|
-          Generators::Resource::WaiterMethod.new(
-            resource_name: @name,
-            resource: @resource,
-            resource_waiter_name: waiter_name,
-            resource_waiter: waiter,
-            waiter: @waiters['waiters'][waiter['waiterName']]
-          )
-        end
-      end
-
-      def apply_actions
-        actions = @resource['actions'] || {}
-        return if actions.empty?
-        code('# @!group Actions')
-        actions.each do |name, action|
-          add(Resource::Action.new(
-            api: @api,
-            name: name,
-            action: action,
-            var_name: @var_name,
-          ))
-        end
-      end
-
-      def apply_associations
-        associations = []
-        associations += has_associations
-        associations += has_many_associations
-
-        return if associations.empty?
-
-        code('# @!group Associations')
-        associations.sort_by(&:name).each do |association_method|
-          add(association_method)
-        end
-      end
-
-      def has_associations
-        (@resource['has'] || {}).map do |name, has|
-          Resource::HasAssociation.new(
-            api: @api,
-            name: name,
-            has: has
-          )
-        end
-      end
-
-      def has_many_associations
-        (@resource['hasMany'] || {}).map do |name, has_many|
-          Resource::HasManyAssociation.new(
-            name: name,
-            has_many: has_many,
-            api: @api,
-            paginators: @paginators,
-            var_name: @var_name,
-          )
-        end
-      end
-
-      def batch_action
-        Generators::Resource::CollectionClass.new(
-          resource_name: @name,
-          resource: @resource,
-          api: @api,
-        )
-      end
-
-      def identifiers_method
-        Generators::Resource::IdentifiersMethod.new(
-          identifiers: identifiers
-        )
-      end
-
-      def private_methods
-        methods = []
-        methods.concat(extract_identifier_methods)
-        methods << yield_waiter_and_warn_method
-        methods << separate_params_and_options
-        methods.compact
-      end
-
-      def extract_identifier_methods
-        identifiers.map.with_index do |identifier, n|
-          Generators::Resource::ExtractIdentifierMethod.new(
-            identifier: identifier,
-            index: n
-          )
-        end
-      end
-
-      def identifiers
-        @resource['identifiers'] || []
-      end
-
-      def data_attribute_names
-
-        skip = Set.new
-
-        # do no duplicate identifiers
-        identifiers.each do |i|
-          skip << i['name']
-          skip << i['memberName'] if i.key?('memberName')
-        end
-
-        # do no duplicate action names
-        (@resource['actions'] || {}).keys.each do |action_name|
-          skip << action_name
-        end
-
-        # do no duplicate has association names
-        (@resource['has'] || {}).keys.each do |association_name|
-          skip << association_name
-        end
-
-        # do no duplicate hasMany association names
-        (@resource['hasMany'] || {}).keys.each do |association_name|
-          skip << association_name
-        end
-
-        shape = (@api['shapes'] || {})[@resource['shape']] || {}
-        members = shape['members'] || {}
-        Enumerator.new do |y|
-          members.each do |member_name, member_ref|
-            unless skip.include?(member_name)
-              y.yield(member_name, member_ref)
-            end
-          end
-        end
-      end
-
-      def check_for_method_name_conflicts!
-
-        names = Set.new
-
-        # Ensure the resource does not have duplicate names. This
-        # includes comparing identifier names, action names, association
-        # names, e.g. anything that is exposed as a method.
-        @code_objects.each do |code_obj|
-          if Dsl::Method === code_obj || Dsl::AttributeAccessor === code_obj
-            check_for_duplicate_method!(code_obj.name, names)
-          end
-        end
-
-        # It is possible for Dsl::Method#aliases to collide with
-        # code object names. Remove aliases that collide.
-        @code_objects.each do |code_obj|
-          if Dsl::Method === code_obj
-            code_obj.aliases.each do |alias_name|
-              if names.include?(alias_name.to_s)
-                code_obj.aliases.delete(alias_name.to_s)
-              end
-            end
-          end
-        end
-
-        # Compare all resource methods against methods defined
-        # on Ruby's Object class as an instance method. We need to
-        # ensure we do not clobber built in Ruby functionality.
-        Object.instance_methods.each do |obj_method_name|
-          if names.include?(obj_method_name.to_s)
-            raise Errors::ResourceMethodConflict.new(
-              resource_name: @name,
-              method_name: obj_method_name
-            )
-          end
-        end
-      end
-
-      def check_for_duplicate_method!(method_name, names)
-        method_name = method_name.to_s
-        if names.include?(method_name)
-          raise Errors::ResourceMethodConflict.new(
-            resource_name: @name,
-            method_name: method_name
-          )
-        else
-          names << method_name
-        end
-      end
-
-      def yield_waiter_and_warn_method
-        if @resource['waiters'] && @resource['waiters'].size > 0
-          Dsl::Method.new(:yield_waiter_and_warn, access: :private) do |m|
-            m.param(:waiter)
-            m.block_param
-            m.code(<<-CODE)
-if !@waiter_block_warned
-  msg = "pass options to configure the waiter; "
-  msg << "yielding the waiter is deprecated"
-  warn(msg)
-  @waiter_block_warned = true
-end
-yield(waiter.waiter)
-            CODE
-          end
-        end
-      end
-
-      def separate_params_and_options
-        if @resource['waiters'] && @resource['waiters'].size > 0
-          Dsl::Method.new(:separate_params_and_options, access: :private) do |m|
-            m.param(:options)
-            m.code(<<-CODE)
-opts = Set.new([:client, :max_attempts, :delay, :before_attempt, :before_wait])
-waiter_opts = {}
-waiter_params = {}
-options.each_pair do |key, value|
-  if opts.include?(key)
-    waiter_opts[key] = value
-  else
-    waiter_params[key] = value
-  end
-end
-waiter_opts[:client] ||= @client
-[waiter_opts, waiter_params]
-            CODE
-          end
-        end
-      end
-
-    end
-  end
-end