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

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

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