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

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

@@ -1,95 +0,0 @@
-module AwsSdkCodeGenerator
-  module Generators
-    class StructureTypeClass < Dsl::CodeLiteral
-
-      include Helper
-
-      # @option options [required, String] :name
-      # @option options [required, Hash] :api
-      # @option options [required, Boolean] :used_as_input
-      def initialize(options)
-        @name = options.fetch(:name)
-        @api = options.fetch(:api)
-        @shape = @api['shapes'][@name]
-        super()
-
-        apply_class_docs
-        apply_input_example if options.fetch(:used_as_input)
-        apply_returned_by
-        document_members
-        if @shape['members'].empty?
-          apply_empty_structure
-        else
-          apply_structure_with_members
-        end
-      end
-
-      private
-
-      def apply_class_docs
-        if class_docs = documentation(@shape)
-          append(Dsl::Docstring.new(class_docs).to_s)
-        end
-      end
-
-      def apply_input_example
-        if @shape['members'].empty?
-          note = '@api private'
-        else
-          note = "@note When making an API call, pass #{@name}\n"
-          note += "  data as a hash:\n\n"
-          note += SyntaxExample.new(
-            struct_shape: @shape,
-            api: @api,
-            indent: ' ' * 6
-          ).format
-        end
-        append(Dsl::Docstring.new(note).to_s)
-      end
-
-      def apply_returned_by
-        # TODO : implement this
-      end
-
-      def apply_empty_structure
-        append("class #{@name} < Aws::EmptyStructure; end")
-      end
-
-      def apply_structure_with_members
-        append("class #{@name} < Struct.new(")
-        @shape['members'].keys.each.with_index do |member_name, n|
-          comma = n == @shape['members'].size - 1 ? ')' : ','
-          append("  :#{underscore(member_name)}#{comma}")
-        end
-        append("  include Aws::Structure")
-        append("end")
-      end
-
-      def document_members
-        @shape['members'].each.with_index do |(name, ref), n|
-          append("#") unless n == 0
-          append(Dsl::Docstring.new(attribute_macro(name, ref)).to_s)
-        end
-      end
-
-      def attribute_macro(member_name, member_ref)
-        docs = documentation(member_ref, line_width:68).lines.to_a.join("  ")
-        macro = "@!attribute [rw] #{underscore(member_name)}\n"
-        macro << "  #{docs}\n" unless docs == ''
-        macro << "  @return [#{ruby_type(member_ref)}]"
-        macro
-      end
-
-      private
-
-      def needs_defaults?
-        @shape['members'].any? do |_, member_ref|
-          type = shape(member_ref)['type']
-
-          type == 'list' || type == 'map'
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,169 +0,0 @@
-module AwsSdkCodeGenerator
-  module Generators
-    class SyntaxExample < Dsl::Docstring
-
-      include Helper
-
-      # @option options [required, Hash] :struct_shape
-      # @option options [required, Hash] :api
-      # @option options [String] :indent ('')
-      def initialize(options = {})
-        @indent = options.fetch(:indent, '')
-        @api = options.fetch(:api)
-        @struct_shape = options.fetch(:struct_shape)
-      end
-
-      def format
-        if @struct_shape && @struct_shape['members'].length > 0
-          @indent + struct(@struct_shape, @indent, [])
-        else
-          ''
-        end
-      end
-
-      private
-
-      def ref_value(ref, i, visited)
-        if visited.include?(ref['shape'])
-          return "{\n#{i}  # recursive #{ref['shape']}\n#{i}}"
-        else
-          visited  = visited + [ref['shape']]
-        end
-
-        s = shape(ref)
-        case s['type']
-        when 'structure'
-          if ref['shape'] == 'AttributeValue'
-            '"value"'
-          else
-            struct(s, i, visited)
-          end
-
-        when 'blob'
-          if ref['streaming']
-            'source_file'
-          else
-            '"data"'
-          end
-
-        when 'list' then list(s, i, visited)
-        when 'map' then map(s, i, visited)
-        when 'boolean' then "false"
-        when 'integer', 'long' then '1'
-        when 'float', 'double' then '1.0'
-        when 'byte' then '97'
-        when 'character' then '"a"'
-        when 'string' then string(ref)
-        when 'timestamp' then 'Time.now'
-        else raise "unsupported shape #{s['type'].inspect}"
-        end
-      end
-
-      def struct(struct_shape, i, visited)
-        lines = ['{']
-        struct_shape['members'].each_pair do |member_name, member_ref|
-          lines << struct_member(struct_shape, member_name, member_ref, i, visited)
-        end
-        lines << "#{i}}"
-        lines.join("\n")
-      end
-
-      def struct_member(struct, member_name, member_ref, i, visited)
-        entry = "#{i}  #{underscore(member_name)}: #{ref_value(member_ref, i + '  ', visited)},"
-        required = (struct['required'] || []).include?(member_name)
-        apply_comments(member_ref, entry, required: required)
-      end
-
-      def list(list_shape, i, visited)
-        member_ref = list_shape['member']
-        if complex?(member_ref)
-          complex_list(member_ref, i, visited)
-        else
-          scalar_list(member_ref, i, visited)
-        end
-      end
-
-      def scalar_list(member_ref, i, visited)
-        "[#{ref_value(member_ref, i, visited)}]"
-      end
-
-      def complex_list(member_ref, i, visited)
-        "[\n#{i}  #{ref_value(member_ref, i + '  ', visited)},\n#{i}]"
-      end
-
-      def map(map_shape, i, visited)
-        key = string(map_shape['key'])
-        value = ref_value(map_shape['value'], i + '  ', visited)
-        "{\n#{i}  #{key} => #{value},#{comments(map_shape['value'], false)}\n#{i}}"
-      end
-
-      def string(ref)
-        string_shape = shape(ref)
-        if string_shape['enum']
-          string_shape['enum'].first.inspect
-        else ref['shape']
-          ref['shape'].inspect
-        end
-      end
-
-      def apply_comments(ref, text, options = {})
-        required = options.fetch(:required)
-        lines = text.lines.to_a
-        if lines[0].match(/\n$/)
-          lines[0] = lines[0].sub(/\n$/, comments(ref, required) + "\n")
-        else
-          lines[0] += comments(ref, required)
-        end
-        lines.join
-      end
-
-      def comments(ref, required)
-        comments = []
-        if ref[:response_target]
-          comments << 'where to write response data, file path, or IO object'
-        end
-        if ref[:streaming]
-          comments << 'file/IO object, or string data'
-        end
-        if required
-          comments << 'required'
-        end
-        if enum = enum_values(ref)
-          comments << "accepts #{enum.to_a.join(', ')}"
-        end
-        if ddb_av?(ref)
-          comments << 'value <Hash,Array,String,Numeric,Boolean,IO,Set,nil>'
-        end
-        comments == [] ? '' : " # #{comments.join(', ')}"
-      end
-
-      def enum_values(ref)
-        s = shape(ref)
-        case s['type']
-        when 'list' then enum_values(s['member'])
-        when 'string' then s['enum']
-        else nil
-        end
-      end
-
-      def complex?(ref)
-        s = shape(ref)
-        if s['type'] == 'structure'
-          !ddb_av?(ref)
-        else
-          s['type'] == 'list' || s['type'] == 'map'
-        end
-      end
-
-      def ddb_av?(ref)
-        s = shape(ref)
-        case s['type']
-        when 'list' then ddb_av?(s['member'])
-        when 'structure' then ref['shape'] == 'AttributeValue'
-        else false
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-require 'set'
-
-module AwsSdkCodeGenerator
-  module Generators
-    class TypesModule < Dsl::Module
-
-      include Helper
-
-      # @option options [required, Hash] :api
-      def initialize(options)
-        @api = options.fetch(:api)
-        super('Types')
-        input_shapes = compute_input_shapes(@api)
-        structures.each do |shape_name, shape|
-          add(StructureTypeClass.new(
-            name: shape_name,
-            api: @api,
-            used_as_input: input_shapes.include?(shape_name)
-          ))
-        end
-      end
-
-      private
-
-      def compute_input_shapes(api)
-        inputs = Set.new
-        (api['operations'] || {}).each do |_, operation|
-          visit_inputs(operation['input'], inputs) if operation['input']
-        end
-        inputs
-      end
-
-      def visit_inputs(shape_ref, inputs)
-        return if inputs.include?(shape_ref['shape']) # recursion
-        inputs << shape_ref['shape']
-        s = shape(shape_ref)
-        case s['type']
-        when 'structure'
-          s['members'].each_pair do |_, member_ref|
-            visit_inputs(member_ref, inputs)
-          end
-        when 'list'
-          visit_inputs(s['member'], inputs)
-        when 'map'
-          visit_inputs(s['key'], inputs)
-          visit_inputs(s['value'], inputs)
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-module AwsSdkCodeGenerator
-  module Generators
-    class WaiterClass < Dsl::Class
-
-      # @option options [required, String] :waiter_name
-      # @option options [required, Hash] :waiter
-      def initialize(options)
-        waiter = options.fetch(:waiter)
-        client_method = underscore(waiter['operation'])
-        super(options.fetch(:waiter_name))
-        code <<-CODE
-# @param [Hash] options
-# @option options [required, Client] :client
-# @option options [Integer] :max_attempts (#{waiter['maxAttempts']})
-# @option options [Integer] :delay (#{waiter['delay']})
-# @option options [Proc] :before_attempt
-# @option options [Proc] :before_wait
-def initialize(options)
-  @client = options.fetch(:client)
-  @waiter = Aws::Waiters::Waiter.new({
-    max_attempts: #{waiter['maxAttempts']},
-    delay: #{waiter['delay']},
-    poller: Aws::Waiters::Poller.new(#{poller_args(waiter)}    )
-  }.merge(options))
-end
-
-# @option (see Client##{client_method})
-# @return (see Client##{client_method})
-def wait(params = {})
-  @waiter.wait(client: @client, params: params)
-end
-
-# @api private
-attr_reader :waiter
-        CODE
-      end
-
-      private
-
-      def poller_args(hash)
-        hash = hash.dup
-        hash.delete('delay')
-        hash.delete('maxAttempts')
-        hash[:operation_name] = Underscore.underscore(hash.delete('operation')).to_sym
-        hash[:acceptors] = hash.delete('acceptors').map do |acceptor|
-          if acceptor['argument']
-            acceptor['argument'] = Underscore.underscore_jmespath(acceptor['argument'])
-          end
-          acceptor
-        end
-        formatter = HashFormatter.new(
-          wrap: false,
-          inline: false,
-          quote_strings: true
-        )
-        lines = formatter.format(hash).lines
-        lines.map { |line| "    #{line}" }.join
-      end
-
-    end
-  end
-end

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

@@ -1,20 +0,0 @@
-module AwsSdkCodeGenerator
-  module Generators
-    class WaitersModule < Dsl::Module
-
-      include Helper
-
-      # @option options [required, Module] :parent
-      # @option options [required, Hash, nil] :waiters
-      def initialize(options)
-        waiters = options.fetch(:waiters)
-        super('Waiters', parent: options.fetch(:parent))
-        require_statement('aws-sdk-core/waiters')
-        waiters['waiters'].each do |waiter_name, waiter|
-          add(WaiterClass.new(waiter_name: waiter_name, waiter: waiter))
-        end
-      end
-
-    end
-  end
-end