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

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

@@ -1,25 +0,0 @@
-module AwsSdkCodeGenerator
-  module Generators
-    class ErrorsModule < Dsl::Module
-
-      include Helper
-
-      def initialize(options)
-        @api = options.fetch(:api)
-        super('Errors')
-        self.extend('Aws::Errors::DynamicErrors')
-        self.class('ResourceNotLoadable', extends: 'RuntimeError') do |c|
-          c.docstring(<<-DOCSTRING)
-Raised when calling #load or #data on a resource class that can not be
-loaded.  This can happen when:
-
-* A resource class has identifiers, but no data attributes.
-* Resource data is only available when making an API call that
-enumerates all resources of that type.
-          DOCSTRING
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,88 +0,0 @@
-module AwsSdkCodeGenerator
-  module Generators
-    module Resource
-      class Action < Dsl::Method
-
-        include Helper
-
-        # @option options [required, String] :name
-        # @option options [required, Hash] :action
-        # @option options [required, Hash] :api
-        # @option options [String] :var_name ('')
-        def initialize(options = {})
-          @api = options.fetch(:api)
-          @request = options.fetch(:action).fetch('request')
-          @resource = options.fetch(:action).fetch('resource', nil)
-          @var_name = options.fetch(:var_name, '')
-          super(underscore(options.fetch(:name)))
-          param('options', type:Hash, default:{})
-          apply_client_request_docs
-          apply_response
-          apply_return_tag
-        end
-
-        private
-
-        def apply_client_request_docs
-          ClientRequestDocs.new(
-            request: @request,
-            api: @api,
-            var_name: @var_name,
-            returns: @resource ? @resource['type'].downcase : nil
-          ).apply(self)
-        end
-
-        def apply_response
-          if @resource && batch?(@resource)
-            code('batch = []')
-            add(client_request)
-            code(BatchBuilder.new(resource: @resource))
-            code("#{resource_type}::Collection.new([batch], size: batch.size)")
-          elsif @resource
-            add(client_request)
-            code(Builder.new(resource: @resource, request_made: true))
-          else
-            add(client_request)
-            code('resp.data')
-          end
-        end
-
-        def client_request
-          ClientRequest.new(
-            request: @request,
-            resp: true
-          )
-        end
-
-        def apply_return_tag
-          if @resource && batch?(@resource)
-            returns("#{resource_type}::Collection")
-          elsif @resource
-            returns(resource_type)
-          else
-            returns(request_return_type)
-          end
-        end
-
-        def resource_type
-          @resource['type']
-        end
-
-        def request_return_type
-          operation = @api['operations'][@request['operation']]
-          if operation['output']
-            "Types::#{operation['output']['shape']}"
-          else
-            'EmptyStructure'
-          end
-        end
-
-        def batch?(resource)
-          paths = (@resource['identifiers'] || []).map {|i| i['path'] }
-          paths << @resource['path']
-          paths.compact.any? { |path| path.match(/\[/) }
-        end
-      end
-    end
-  end
-end

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

@@ -1,211 +0,0 @@
-require 'set'
-
-module AwsSdkCodeGenerator
-  module Generators
-    module Resource
-      class BatchBuilder < Dsl::CodeLiteral
-
-        include Helper
-
-        # @option options [required, Hash] :resource
-        # @option options [String] :resp_var_name ('resp')
-        def initialize(options)
-          @resource = options.fetch(:resource)
-          @resp_var_name = options.fetch(:resp_var_name, 'resp')
-          verify_resource!
-          @context = loop_context
-          super()
-
-          # create nested blocks from each loop expression
-          stack = [self]
-          loops.each do |loop_expression|
-            stack.last.append(loop_expression)
-            stack << stack.last.indent
-          end
-
-          # add resource to the batch
-          stack.last.append("batch << #{resource_class}.new(#{constructor_args})")
-
-          # add closing end tags
-          stack.pop
-          stack.each { |c| c.append('end') }
-        end
-
-        private
-
-        def resource_class
-          @resource['type']
-        end
-
-        def constructor_args
-          hash = {}
-          hash.update(identifiers)
-          hash[:data] = data_path if @resource['path']
-          hash[:client] = "@client"
-          HashFormatter.new(wrap:false, inline:true).format(hash)
-        end
-
-        def identifiers
-          (@resource['identifiers'] || []).inject({}) do |hash, identifier|
-            value = relative_identifier_path(identifier)
-            hash[underscore(identifier['target']).to_sym] = value
-            hash
-          end
-        end
-
-        def data_path
-          relative_identifier_path({
-            'source' => 'data',
-            'path' => @resource['path'],
-          })
-        end
-
-        def relative_identifier_path(identifier)
-          path = identifier['path']
-          if path && path.include?('[]')
-            prefix = loops.last.match(/\|(.+)\|/)[1]
-            suffix = underscore(path[common_prefix.length..-1])
-            if @context == :options
-              suffix = suffix.gsub(/\.\w+/) { |word| "[:#{word[1..-1]}]" }
-            end
-            suffix.length == 0 ? prefix : prefix + suffix
-          else
-            ValueSource.new(identifier).to_s
-          end
-        end
-
-        def common_prefix
-          paths = plural_paths
-          if paths.empty?
-            ''
-          elsif paths.size == 1
-            # grab everything upto and including the final []
-            paths.first.match(/(.+\[\]).*?$/)[1]
-          else
-            prefix = find_prefix(paths)
-            prefix = prefix.sub(/\[\].+?$/, '[]')
-            if prefix[-2..-1] != '[]'
-              msg = 'response paths must have a common prefix ending in [], got :'
-              msg << paths.inspect
-              raise ArgumentError, msg
-            else
-              prefix
-            end
-          end
-        end
-
-        def find_prefix(paths)
-          prefix = ''
-          loop.with_index do |_, n|
-            return prefix if paths.empty?
-            letter = paths[0][n]
-            paths.each do |path|
-              return prefix if path[n].nil?
-              return prefix if path[n] != letter
-            end
-            prefix += letter
-          end
-        end
-
-        def loops
-          loop_var =
-            case @context
-            when :data then 'data.'
-            when :options then 'options'
-            when :response then "#{@resp_var_name}.data."
-            end
-
-          used_vars = Set.new
-          used_vars << loop_var
-
-          parts = common_prefix.split('[]')
-          parts = parts.map.with_index do |part,n|
-            part = underscore(part)
-            if @context == :options
-              part = part.gsub(/\w+/) { |word| "[:#{word}]" }
-              part = part.gsub(/\./, '')
-            end
-            part = "#{loop_var}#{part}"
-            loop_var = loop_letter(part, used_vars)
-            part = part + ".each do |#{loop_var}|"
-            part
-          end
-          parts
-        end
-
-        def loop_letter(str, used_vars)
-          letter = if @context == :options
-            str.scan(/:\w/).last[1]
-          else
-            str.split('.').last[0]
-          end
-          n = 1
-          var = letter
-          while used_vars.include?(var)
-            n += 1
-            var = "#{letter}#{n}"
-          end
-          used_vars << var
-          var
-        end
-
-        def all_plural_paths
-          paths = {}
-          @resource['identifiers'].each do |i|
-            if i['path'] && i['path'].include?('[]')
-              paths[i['source']] ||= []
-              paths[i['source']] << i['path']
-            end
-          end
-          #if @resource['path'] && @resource['path'].include?('[]')
-          #  type = @context == :data ? 'data' : 'response'
-          #  paths[type] ||= []
-          #  paths[type] << @resource['path']
-          #end
-          paths
-        end
-
-        def plural_paths
-          all_plural_paths.values.first
-        end
-
-        def verify_resource!
-          verify_plural_paths!
-        end
-
-        def verify_plural_paths!
-          paths = all_plural_paths
-          case paths.size
-          when 0
-            msg = 'expected at least one plural identifier path, got none'
-            raise ArgumentError, msg
-          when 1
-            case paths.keys.first
-            when 'requestParameter'
-            when 'response'
-            when 'data'
-            else
-              msg = "unsupported identifier source #{paths.keys.first.inspect}"
-              raise ArgumentError, msg
-            end
-          else
-            msg = 'mixing plural source types is not supported'
-            raise ArgumentError, msg
-          end
-        end
-
-        def loop_context
-          case all_plural_paths.keys
-          when ['response'] then :response
-          when ['data'] then :data
-          when ['requestParameter'] then :options
-          else
-            msg = "unable to determine loop context: #{@resource.inspect}"
-            raise msg
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-module AwsSdkCodeGenerator
-  module Generators
-    module Resource
-      class Builder < Dsl::CodeLiteral
-
-        include Helper
-
-        # @option options [required, Hash] :resource
-        # @option options [required, Boolean] :request_made
-        def initialize(options = {})
-          super()
-          @resource = options.fetch(:resource)
-          @request_made = options.fetch(:request_made)
-          append("#{resource_class}.new(#{constructor_options})")
-        end
-
-        private
-
-        def resource_class
-          @resource['type']
-        end
-
-        def constructor_options
-          options = {}
-          options.update(identifiers)
-          options[:data] = data_path if @resource['path']
-          options[:client] = "@client"
-          HashFormatter.new(wrap:false, inline:true).format(options)
-        end
-
-        def identifiers
-          (@resource['identifiers'] || []).inject({}) do |hash, identifier|
-            value = ValueSource.new(identifier).to_s
-            hash[underscore(identifier['target']).to_sym] = value
-            hash
-          end
-        end
-
-        def data_path
-          if @request_made
-            ValueSource.new('source' => 'response', 'path' => @resource['path'])
-          else
-            ValueSource.new('source' => 'data', 'path' => @resource['path'])
-          end
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,15 +0,0 @@
-module AwsSdkCodeGenerator
-  module Generators
-    module Resource
-      class ClientGetter < Dsl::Method
-
-        def initialize
-          super('client')
-          returns('Client')
-          code('@client')
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,49 +0,0 @@
-module AwsSdkCodeGenerator
-  module Generators
-    module Resource
-      class ClientRequest < Dsl::CodeLiteral
-
-        include Helper
-
-        # @option options [required, Hash] :request
-        # @option options [Boolean] :resp (false)
-        # @option options [Boolean] :merge (true)
-        def initialize(options = {})
-          @request = options.fetch(:request)
-          @params = ClientRequestParams.new(params: @request['params'])
-          @resp = options.fetch(:resp, false)
-          if options.fetch(:merge, true)
-            super("#{request_options}#{assignement}@client.#{operation_name}(options)")
-          else
-            super("#{assignement}@client.#{operation_name}#{params}")
-          end
-        end
-
-        private
-
-        def request_options
-          if @params.empty?
-            ''
-          elsif @params.simple?
-            "options = options.merge(#{@params})\n"
-          else
-            "options = Aws::Util.deep_merge(options, #{@params})\n"
-          end
-        end
-
-        def params
-          @params.empty? ? @params : "(#{@params})"
-        end
-
-        def assignement
-          "resp = " if @resp
-        end
-
-        def operation_name
-          underscore(@request['operation'])
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,97 +0,0 @@
-require 'set'
-
-module AwsSdkCodeGenerator
-  module Generators
-    module Resource
-      class ClientRequestDocs
-
-        include Helper
-
-        # @option options [required, Hash] :api
-        # @option options [required, Hash] :request
-        # @option options [Array<String>] :skip ([])
-        # @option options [required, String] :var_name
-        # @option options [required, String] :returns
-        def initialize(options)
-          @api = options.fetch(:api)
-          @request = options.fetch(:request)
-          @skip = Set.new(options.fetch(:skip, []))
-          @var_name = options.fetch(:var_name)
-          @returns = options.fetch(:returns)
-        end
-
-        # @param [Dsl::Method] method
-        def apply(method)
-          apply_request_syntax_example(method)
-          apply_option_tags(method)
-        end
-
-        private
-
-        def apply_option_tags(method)
-          input_members.each do |member_name, member_ref, required|
-            method.option(
-              name: underscore(member_name),
-              type: ruby_input_type(member_ref),
-              required: required,
-              docstring: documentation(member_ref)
-            )
-          end
-        end
-
-        def apply_request_syntax_example(method)
-          if input_shape
-            syntax = SyntaxExample.new(
-              struct_shape: input_shape,
-              api: @api,
-              indent: '  '
-            ).format.strip
-            method.docstring.append("@example Request syntax with placeholder values")
-            if @returns
-              method.docstring.append("\n  #{@returns} = #{@var_name}.#{method.name}(#{syntax})")
-            else
-              method.docstring.append("\n  #{@var_name}.#{method.name}(#{syntax})")
-            end
-          end
-        end
-
-        def input_members
-          if input_shape
-            Enumerator.new do |y|
-              input_shape['members'].each_pair do |member_name, member_ref|
-                required = (input_shape['required'] || []).include?(member_name)
-                y.yield(member_name, member_ref, required)
-              end
-            end
-          else
-            []
-          end
-        end
-
-        def operation
-          @api['operations'][@request['operation']]
-        end
-
-        def input_shape
-          struct = shape(operation['input'])
-          if struct
-            struct = deep_copy(struct)
-            struct['members'].keys.each do |member_name|
-              struct['members'].delete(member_name) if request_param?(member_name)
-              struct['members'].delete(member_name) if @skip.include?(member_name)
-            end
-          end
-          struct
-        end
-
-        def request_param?(member_name)
-          params = @request['params'] || []
-          params.any? do |param|
-            param['target'].match(/^#{member_name}\b/) && !(param['target'].include?('[') && param['target'].include?('.'))
-          end
-        end
-
-      end
-    end
-  end
-end