aws-sdk-code-generator 0.1.0.pre

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

@@ -0,0 +1,83 @@
+require 'set'
+
+module AwsSdkCodeGenerator
+  module Generators
+    class ResponseStructureExample
+
+      include Helper
+
+      # @option options [required, Hash] :shape_ref
+      # @option options [required, Hash] :api
+      def initialize(options = {})
+        @shape_ref = options.fetch(:shape_ref)
+        @api = options.fetch(:api)
+      end
+
+      def to_str
+        "\n@example Response structure\n  #{entry(@shape_ref, "resp", Set.new).join("\n  ")}"
+      end
+      alias to_s to_str
+
+      private
+
+      def structure(ref, context, visited)
+        lines = []
+        shape(ref)['members'].each_pair do |member_name, member_ref|
+          lines += entry(member_ref, "#{context}.#{underscore(member_name)}", visited)
+        end
+        lines
+      end
+
+      def list(ref, context, visited)
+        lines = []
+        lines << "#{context} #=> Array"
+        lines += entry(shape(ref)['member'], "#{context}[0]", visited)
+        lines
+      end
+
+      def map(ref, context, visited)
+        lines = []
+        lines << "#{context} #=> Hash"
+        lines += entry(shape(ref)['value'], "#{context}[#{map_key(ref)}]", visited)
+        lines
+      end
+
+      def map_key(ref)
+        shape(ref)['key']['shape'].inspect
+      end
+
+      def entry(ref, context, visited)
+        if ref['shape'] == 'AttributeValue'
+          return ["#{context} #=> <Hash,Array,String,Numeric,Boolean,IO,Set,nil>"]
+        elsif visited.include?(ref['shape'])
+          return ["#{context} #=> Types::#{ref['shape']}"]
+        else
+          visited  = visited + [ref['shape']]
+        end
+        case shape(ref)['type']
+        when 'structure' then structure(ref, context, visited)
+        when 'list' then list(ref, context, visited)
+        when 'map' then map(ref, context, visited)
+        else ["#{context} #=> #{type(ref)}"]
+        end
+      end
+
+      def type(ref)
+        if shape(ref)['type'] == 'string'
+          string(ref)
+        else
+          ruby_type(ref)
+        end
+      end
+
+      def string(ref)
+        if shape(ref)['enum']
+          "String, one of #{shape(ref)['enum'].map(&:inspect).join(', ')}"
+        else
+          'String'
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+module AwsSdkCodeGenerator
+  module Generators
+    class RootResourceClass < ResourceClass
+
+      include Helper
+
+      # @option options [required, Hash] :api
+      # @option options [required, String] :var_name
+      # @option options [Hash] :resources
+      # @option options [Hash] :paginators
+      def initialize(options)
+        resources = options.fetch(:resources) || {}
+        super(
+          api: options.fetch(:api),
+          name: 'Resource',
+          resource: resources.fetch('service', {}),
+          paginators: options.fetch(:paginators, nil) || {},
+          waiters:nil,
+          var_name: options.fetch(:var_name)
+        )
+      end
+
+      private
+
+      def build
+        add(initialize_method)
+        add(client_getter)
+        apply_actions
+        apply_associations
+      end
+
+      def initialize_method
+        Dsl::Method.new('initialize') do |m|
+          m.param('options', default:{})
+          m.option(name:'client', type:'Client')
+          m.code('@client = options[:client] || Client.new(options)')
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require 'erb'
+
+module AwsSdkCodeGenerator
+  module Generators
+    class ServiceDocumentation
+
+      include Helper
+
+      # @option options [required, Hash] :api
+      # @option options [required, Hash] :product_name
+      # @option options [required, Hash] :namespace
+      def initialize(options = {})
+        @api = options.fetch(:api)
+        @product_name = options.fetch(:product_name)
+        @namespace = options.fetch(:namespace)
+        @var_name = @namespace.split('::').last.downcase
+      end
+
+      def docstring
+        <<-MARKDOWN
+@service
+This module provides support for #{@product_name}, which shipped in `aws-sdk-#{@var_name}` gem.
+
+# #{@namespace}::Client
+
+The {#{@namespace}::Client} class provides one method for each API
+operation. Operation methods each accept a hash of request parameters
+and return a response object.#{example_operation}
+
+See {Client} for more information.
+
+# #{@namespace}::Errors
+
+Errors returned from #{@product_name} all
+extend {Errors::ServiceError}.
+
+    begin
+      # do stuff
+    rescue #{@namespace}::Errors::ServiceError
+      # rescues all service API errors
+    end
+
+See {Errors} for more information.
+        MARKDOWN
+      end
+
+      def example_operation
+        if @api['operations'] && @api['operations'].first
+          <<-EXAMPLE
+
+
+    #{@var_name} = #{@namespace}::Client.new
+    resp = #{@var_name}.#{example_operation_name}(params)
+          EXAMPLE
+        end
+      end
+
+      def example_operation_name
+        underscore(@api['operations'].keys.first)
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,132 @@
+module AwsSdkCodeGenerator
+  module Generators
+    class SharedExample
+
+      include Helper
+
+      # @option options [required, String] :operation_name
+      # @option options [required, Hash] api
+      # @option options [required, Hash] examples
+      # @option options [required, Integer] example
+      def initialize(options = {})
+        @operation_name = options.fetch(:operation_name)
+        @operation = options.fetch(:api)['operations'][@operation_name]
+        @example = options.fetch(:examples)['examples'][@operation_name][options.fetch(:example)]
+        @api = options.fetch(:api)
+        @method_name = underscore(@operation_name)
+      end
+
+      def to_s
+        lines = []
+        lines << ""
+        lines << "@example Example: #{@example['description']}"
+        lines << ""
+        apply_input_example(lines)
+        apply_output_example(lines)
+        lines.join("\n")
+      end
+
+      private
+
+      def apply_input_example(lines)
+        lines << "  resp = client.#{@method_name}(#{input_params})"
+      end
+
+      def input_params
+        if @example['input'] && @operation['input']
+          entry(
+            @example['input'],
+            @operation['input'],
+            indent = '  ',
+            path = [],
+            @example['comments']['input']
+          ).join("\n")
+        else
+          ''
+        end
+      end
+
+      def apply_output_example(lines)
+        if @example['output'] && @operation['output']
+          lines << ""
+          lines << "  # resp.to_h outputs the following:"
+          lines << "  " + entry(
+              @example['output'],
+              @operation['output'],
+              indent = '  ',
+              path = [],
+              @example['comments']['output']
+          ).join("\n")
+        end
+      end
+
+      def entry(json, ref, indent, path, comments)
+        case shape(ref)['type']
+        when 'structure' then structure(json, ref, indent, path, comments)
+        when 'map' then map(json, ref, indent, path, comments)
+        when 'list' then list(json, ref, indent, path, comments)
+        when 'timestamp' then "Time.parse(#{json.inspect})"
+        when 'string', 'blob', 'integer', 'long', 'float', 'double', 'boolean'
+          json.inspect
+        else
+          raise ArgumentError, "unhandled type #{shape(ref)['type'].inspect}"
+        end
+      end
+
+      def structure(json, ref, indent, path, comments)
+        lines = ["{"]
+        json.each_pair do |key, val|
+          path << ".#{key}"
+          shape_val = entry(val, shape(ref)['members'][key], "#{indent}  ", path, comments)
+          if shape_val.is_a?(Array)
+            shape_val = shape_val.join("\n")
+          end
+          lines << "#{indent}  #{underscore(key)}: #{shape_val},#{comments_for(path, comments)}"
+          path.pop
+        end
+        lines << "#{indent}}"
+        lines
+      end
+
+      def map(json, ref, indent, path, comments)
+        lines = ["{"]
+        json.each do |key, val|
+          path << ".#{key}"
+          shape_val = entry(val, shape(ref)['value'], "#{indent}  ", path, comments)
+          if shape_val.is_a?(Array)
+            shape_val = shape_val.join("\n")
+          end
+          lines << "#{indent}  \"#{key}\" => #{shape_val},#{comments_for(path, comments)}"
+          path.pop
+        end
+        lines << "#{indent}}"
+        lines
+      end
+
+      def list(json, ref, indent, path, comments)
+        lines = ["["]
+        json.each_with_index do |value, index|
+          path << "[#{index}]"
+          shape_val = entry(value, shape(ref)['member'], "#{indent}  ", path, comments)
+          if shape_val.is_a?(Array)
+            shape_val = shape_val.join("\n")
+          end
+          lines << "#{indent}  #{shape_val},#{comments_for(path, comments)}"
+          path.pop
+        end
+        lines << "#{indent}]"
+        lines
+      end
+
+      def comments_for(path, comments)
+        path = path.join().sub(/^\./, '')
+        if comments.key?(path)
+          " # #{comments[path]}"
+        else
+          ""
+        end
+      end
+
+    end
+  end
+end

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

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

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