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

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

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

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

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

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

@@ -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