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

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

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

@@ -1,88 +0,0 @@
-module AwsSdkCodeGenerator
-  module Generators
-    module Resource
-      class ClientRequestParams < String
-
-        include Helper
-
-        # @option options [Array] :params ([])
-        def initialize(options = {})
-          @params = options.fetch(:params, nil) || []
-          super(format_params)
-        end
-
-        def simple?
-          @params.all? { |p| p['target'].match(/^\w+$/) }
-        end
-
-        def empty?
-          @params.empty?
-        end
-
-        def size
-          @params.size
-        end
-
-        private
-
-        def format_params
-          hash = {}
-          @params.each do |param|
-            ParamTarget.new(param).apply(hash, ValueSource.new(param))
-          end
-          formatter = HashFormatter.new(wrap:false, inline: @params.count == 1)
-          params = formatter.format(hash)
-          @params.size == 1 ? params.strip : params
-        end
-
-        class ParamTarget
-
-          def initialize(param)
-            @target = param['target']
-            @steps = []
-            @target.scan(/\w+|\[\]|\[\*\]|\[[0-9]+\]/) do |step|
-              case step
-              when /\[\d+\]/ then @steps += [:array, step[1..-2].to_i]
-              when /\[\*\]/ then @steps += [:array, :n]
-              when '[]' then @steps += [:array, -1]
-              else @steps += [:hash, Underscore.underscore(step).to_sym]
-              end
-            end
-            @steps.shift
-            @final = @steps.pop
-          end
-
-          # @return [String] target
-          attr_reader :target
-
-          def apply(hash, value, options = {})
-            resource_index = options.fetch(:resource_index, 0)
-            if @final == -1
-              build_context(hash, resource_index) << value
-            else
-              build_context(hash, resource_index)[@final] = value
-            end
-            hash
-          end
-
-          private
-
-          def build_context(params, n)
-            @steps.each_slice(2).inject(params) do |context, (key, type)|
-              entry = type == :array ? [] : {}
-              if key == -1
-                context << entry
-                entry
-              elsif key == :n
-                context[n] ||= entry
-              else
-                context[key] ||= entry
-              end
-            end
-          end
-
-        end
-      end
-    end
-  end
-end

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

@@ -1,180 +0,0 @@
-module AwsSdkCodeGenerator
-  module Generators
-    module Resource
-      class CollectionClass < Dsl::Class
-
-        include Helper
-
-        # @option options [required, String] :resource_name
-        # @option options [required, Hash] :resource
-        # @option options [required, Hash] :api
-        def initialize(options)
-          @resource_name = options.fetch(:resource_name)
-          @resource = options.fetch(:resource)
-          @variable_name = underscore(@resource_name)
-          @api = options.fetch(:api)
-          super('Collection', extends: 'Aws::Resources::Collection')
-          add(*batch_actions)
-        end
-
-        def apply(mod)
-          mod.class(@resource_name) do |m|
-            m.add(self)
-          end
-        end
-
-        private
-
-        def batch_actions
-          if @resource['batchActions']
-            actions = []
-            actions << '# @!group Batch Actions'
-            @resource['batchActions'].each do |name, action|
-              actions << Dsl::Method.new(batch_action_name(name, action)) do |m|
-                m.returns('void')
-                m.param('options', default: {})
-                param_hash(action)
-                apply_batch_action_doc(action, m)
-                m.code('batch_enum.each do |batch|')
-                m.code(initialize_params)
-                m.code(apply_params_per_batch)
-                m.code(batch_request(action))
-                m.code('end')
-                m.code(batch_response)
-              end
-            end
-            actions << '# @!endgroup'
-            actions
-          else
-            []
-          end
-        end
-
-        def param_hash(action)
-          @batch_obj = {}
-          @per_batch = {}
-          @action_prefix = false
-          action['request']['params'].each do |param|
-            if param['target'].include?('[')
-              parts = param['target'].split('[')
-              pair = parts[0].split('.')
-              if pair.length > 1
-                @action_prefix = pair.first
-              end
-              batch_name = pair.last
-              batch_param = underscore(parts[1].sub(/.*?\./, ''))
-              batch_param = batch_param == "" ? underscore(param['name']) : batch_param
-              (@batch_obj[batch_name] ||= []) << {
-                batch_param.to_sym => underscore(param['name'] || param['path'])
-              }
-            else
-              @per_batch[param['target']] = underscore(param['name'])
-            end
-          end
-        end
-
-        def apply_batch_action_doc(action, method)
-          skip = []
-          if @action_prefix
-            skip << @action_prefix
-          else
-            skip += @per_batch.keys
-            skip += @batch_obj.keys
-          end
-          ClientRequestDocs.new(
-            request: action['request'],
-            api: @api,
-            skip: skip,
-            var_name: @variable_name,
-            returns: nil
-          ).apply(method)
-        end
-
-        def initialize_params
-          param_block = []
-          param_block << "  params = Aws::Util.copy_hash(options)"
-          param_block << apply_param_hash
-          param_block.join("\n")
-        end
-
-        def apply_param_hash
-          block = []
-          @per_batch.each do |key, value|
-            block << "  params[:#{underscore(key)}] = batch[0].#{value}"
-          end
-          if @action_prefix
-            action = underscore(@action_prefix)
-            block << "  params[:#{action}] ||= {}"
-            @batch_obj.keys.each do |key|
-              block << "  params[:#{action}][:#{underscore(key)}] ||= []"
-            end
-          else
-            @batch_obj.keys.each {|key| block << "  params[:#{underscore(key)}] ||= []"}
-          end
-          block.join("\n")
-        end
-
-        def apply_params_per_batch
-          each_batch = []
-          each_batch << "  batch.each do |item|"
-          @batch_obj.each do |key, value|
-            hash = {}
-            value.each do |v|
-              param, identifier = v.first
-              hash[param.to_sym] = "item.#{identifier}"
-            end
-            # Construct hash block
-            if @action_prefix
-              each_batch << "    params[:#{underscore(@action_prefix)}][:#{underscore(key)}] << {"
-            else
-              each_batch << "    params[:#{underscore(key)}] << {"
-            end
-            # hashformatter treats this as inline, need extra indent
-            indent_count = hash.size == 1 ? 3 : 2
-            each_batch << indent_helper(HashFormatter.new(wrap: false).format(hash), indent_count)
-            each_batch << "    }"
-          end
-          each_batch << "  end"
-          each_batch.join("\n")
-        end
-
-        def batch_request(action)
-          "  batch[0].client.#{underscore(action['request']['operation'])}(params)"
-        end
-
-        def batch_response
-          "nil"
-        end
-
-        def indent_helper(lines, count)
-          block = []
-          lines.split("\n").each do |line|
-            next if line.strip == ""
-            block << "  " * count + line
-          end
-          block.join("\n")
-        end
-
-        def batch_action_name(name, action)
-          method_name = "batch_" + underscore(name)
-          method_name += '!' if dangerous?(name, action)
-          method_name
-        end
-
-        def dangerous?(name, action)
-          if
-            name.match(/delete/i) ||
-            name.match(/terminate/i) ||
-            action['request']['operation'].match(/delete/i) ||
-            action['request']['operation'].match(/terminate/i)
-          then
-            true
-          else
-            false
-          end
-        end
-
-      end
-    end
-  end
-end