aws-sdk-code-generator 0.1.0.pre

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

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

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

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

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

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

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