aws-sdk-core 2.0.0.rc1

data/lib/aws/api/base_translator.rb

@@ -0,0 +1,72 @@
+module Aws
+  module Api
+    class BaseTranslator
+
+      include Util
+
+      DEFAULT_OPTIONS = {
+        documentation: true,
+        errors: true,
+        timestamp_format: 'iso8601',
+      }
+
+      def initialize(src, options)
+        @properties = {}
+        @options = options
+        DEFAULT_OPTIONS.each do |option, default|
+          @options[option] = default unless @options.key?(option)
+        end
+        src.each_pair do |property, value|
+          self.send("set_#{property}", value)
+        end
+      end
+
+      def set_timestamp_format(format)
+        @options = @options.merge(timestamp_format: format.sub(/Timestamp/, ''))
+      end
+
+      def set_documentation(docs)
+        if docs && @options[:documentation]
+          docs = docs.gsub(/<!--.*?-->/m, '')
+          docs = docs.gsub(/<a>(.+?)<\/a>/m, '\1')
+          docs = docs.gsub(/<examples?>.+?<\/examples?>/m, '')
+          docs = docs.gsub(/<\/?note>/m, '')
+          docs = docs.gsub(/\{(\S+)\}/, '`{\1}`')
+          docs = docs.gsub(/\s+/, ' ').strip
+          @properties['documentation'] = docs unless docs.empty?
+        end
+      end
+
+      def translated
+        raise NotImplementedError
+      end
+
+      class << self
+
+        def translate(src, options)
+          new(src, options).translated if src
+        end
+
+        def property(name, options = {})
+          method_name = "set_#{options[:from] || name}"
+          define_method(method_name) do |value|
+            @properties[name.to_s] = value
+          end
+        end
+
+        def metadata(name, options = {})
+          define_method("set_#{name}") do |value|
+            @properties['metadata'] ||= {}
+            @properties['metadata'][options[:as] || name.to_s] = value
+          end
+        end
+
+        def ignore(property)
+          define_method("set_#{property}") { |value| }
+        end
+
+      end
+
+    end
+  end
+end

data/lib/aws/api/doc_example.rb

@@ -0,0 +1,116 @@
+module Aws
+  module Api
+    class DocExample
+
+      include Seahorse::Model::Shapes
+
+      def initialize(obj_name, method_name, operation)
+        @obj_name = obj_name
+        @method_name = method_name
+        @operation = operation
+      end
+
+      def to_str
+        "resp = #{@obj_name}.#{@method_name}(#{params[1...-1]})"
+      end
+      alias to_s to_str
+      alias inspect to_str
+
+      private
+
+      def params
+        return '' if @operation.input.members.empty?
+        structure(@operation.input, '')
+      end
+
+      def structure(shape, i)
+        lines = ['{']
+        shape.members.each do |member_name, member_shape|
+          if member_shape.required
+            lines << "#{i}  # required"
+          end
+          lines << "#{i}  #{member_name}: #{member(member_shape, i + '  ')},"
+        end
+        lines << "#{i}}"
+        lines.join("\n")
+      end
+
+      def map(shape, i)
+        if multiline?(shape.members)
+          multiline_map(shape, i)
+        else
+          "{ #{key_name(shape)} => #{value(shape.members)} }"
+        end
+      end
+
+      def multiline_map(shape, i)
+        lines = ["{"]
+        lines << "#{i}  #{key_name(shape)} => #{member(shape.members, i + '  ')},"
+        lines << "#{i}  # repeated ..."
+        lines << "#{i}}"
+        lines.join("\n")
+      end
+
+      def list(shape, i)
+        if multiline?(shape.members)
+          multiline_list(shape, i)
+        else
+          "[#{value(shape.members)}, '...']"
+        end
+      end
+
+      def multiline_list(shape, i)
+        lines = ["["]
+        lines << "#{i}  #{member(shape.members, i + '  ')},"
+        lines << "#{i}  # repeated ... "
+        lines << "#{i}]"
+        lines.join("\n")
+      end
+
+      def member(shape, i)
+        case shape
+        when StructureShape then structure(shape, i)
+        when MapShape then map(shape, i)
+        when ListShape then list(shape, i)
+        else value(shape)
+        end
+      end
+
+      def value(shape)
+        case shape
+        when StringShape then string_value(shape)
+        when IntegerShape then 'Integer'
+        when FloatShape then 'Float'
+        when BooleanShape then 'true || false'
+        when TimestampShape then '<Time,DateTime,Date,Integer,String>'.inspect
+        when BlobShape then "#{shape_name(shape, false)}<String,IO>".inspect
+        else raise "unhandled shape type `#{shape.type}'"
+        end
+      end
+
+      def string_value(shape)
+        if shape.enum
+          shape.enum.join('|').inspect
+        else
+          shape_name(shape)
+        end
+      end
+
+      def multiline?(shape)
+        shape.is_a?(StructureShape) or
+        shape.is_a?(MapShape) or
+        shape.is_a?(ListShape)
+      end
+
+      def shape_name(shape, inspect = true)
+        value = shape.metadata['shape_name']
+        inspect ? value.inspect : value
+      end
+
+      def key_name(shape, inspect = true)
+        shape_name(shape.keys)
+      end
+
+    end
+  end
+end

data/lib/aws/api/documentor.rb

@@ -0,0 +1,140 @@
+module Aws
+  module Api
+    class Documentor
+
+      include Seahorse::Model::Shapes
+
+      def initialize(obj_name, method_name, operation)
+        @operation = operation
+        @example = DocExample.new(obj_name, method_name, operation)
+      end
+
+      def input
+        params('') do
+          structure(@operation.input)
+        end.join
+      end
+
+      def output
+        params('') do
+          structure(@operation.output)
+        end.join
+      end
+
+      def example
+        @example
+      end
+
+      def api_ref(shape)
+        docs = shape.is_a?(String) ? shape : shape.documentation
+        if docs
+          docs = docs.strip if docs
+          "<div class=\"api-ref\">#{docs}</div>" unless docs.empty?
+        end
+      end
+
+      private
+
+      def params(shape, &block)
+        ['<div class="params">', api_ref(shape)] + yield + ['</div>']
+      end
+
+      def param(shape, key_name, value_type, &block)
+        lines = []
+        lines << '<div class="param">'
+        lines << entry(shape, key_name, value_type)
+        yield(lines) if block_given?
+        lines += nested_params(shape)
+        lines << '</div>'
+        lines
+      end
+
+      def nested_params(shape)
+        if leaf?(shape)
+          nested(shape)
+        else
+          params(shape) { nested(shape) }
+        end
+      end
+
+      def nested(shape)
+        case shape
+        when StructureShape then structure(shape)
+        when MapShape then map(shape)
+        when ListShape then list(shape)
+        else [api_ref(shape)]
+        end
+      end
+
+      def structure(shape)
+        shape.members.inject([]) do |lines, (member_name, member_shape)|
+          lines += param(member_shape, member_name, shape_type(member_shape))
+        end
+      end
+
+      def map(shape)
+        param(shape.members, key_name(shape), value_type(shape))
+      end
+
+      def list(shape)
+        case shape.members
+        when StructureShape then structure(shape.members)
+        when MapShape then map(shape.members)
+        when ListShape then raise NotImplementedError
+        else [api_ref(shape)]
+        end
+      end
+
+      def entry(shape, key_name, value_type)
+        classes = ['key']
+        classes << 'required' if shape.required
+        line = '<div class="entry">'
+        line << "<span class=\"#{classes.join(' ')}\">#{key_name.inspect}</span>"
+        line << " => #{value_type}"
+        line << '</div>'
+        line
+      end
+
+      def shape_type(shape)
+        case shape
+        when StructureShape then 'Hash'
+        when MapShape then 'Hash'
+        when ListShape then "Array&lt;#{value_type(shape)}&gt;"
+        when StringShape then 'String'
+        when TimestampShape then 'Time'
+        when IntegerShape then 'Integer'
+        when FloatShape then 'Number'
+        when BooleanShape then 'Boolean'
+        when BlobShape then 'String,IO'
+        else raise "unhandled type #{shape.type}"
+        end
+      end
+
+      def key_type(shape)
+        shape_type(shape.keys)
+      end
+
+      def value_type(shape)
+        shape_type(shape.members)
+      end
+
+      def key_name(shape)
+        shape.keys.metadata['shape_name']
+      end
+
+      def value_name(shape)
+        shape.members.metadata['shape_name']
+      end
+
+      def leaf?(shape)
+        case shape
+        when StructureShape then false
+        when MapShape then false
+        when ListShape then leaf?(shape.members)
+        else true
+        end
+      end
+
+    end
+  end
+end

data/lib/aws/api/operation_translator.rb

@@ -0,0 +1,77 @@
+module Aws
+  module Api
+    class OperationTranslator < BaseTranslator
+
+      def translated
+        @properties['http_method'] ||= 'POST'
+        @properties['http_path'] ||= '/'
+
+        if @input
+          @input.members.each_pair do |member_name, member_shape|
+            if member_shape.location == 'uri'
+              placeholder = member_shape.serialized_name
+              @properties['http_path'].sub!("{#{placeholder}}", "{#{member_name}}")
+              member_shape.serialized_name = nil
+              if path_param?(@properties['http_path'], member_name)
+                member_shape.required = true
+              end
+            end
+          end
+        end
+
+        operation = Seahorse::Model::Operation.from_hash(@properties)
+        operation.input = @input if @input
+        operation.output = @output if @output
+        operation.errors = @errors if @errors and @options[:errors]
+        operation
+      end
+
+      ignore :documentation_url
+      ignore :alias
+
+      def path_param?(path, param_name)
+        path.split('?').first.include?("{#{param_name}}")
+      end
+
+      def set_name(name)
+        # strip api version from operation name
+        @properties['name'] = name.sub(/\d{4}_\d{2}_\d{2}$/, '')
+      end
+
+      def set_http(http)
+        @properties['http_method'] = http['method']
+        @properties['http_path'] = http['uri']
+      end
+
+      def set_input(src)
+        handle_input_output('input', src)
+      end
+
+      def set_output(src)
+        handle_input_output('output', src)
+      end
+
+      def handle_input_output(input_or_output, src)
+        if src
+          src = src.merge('type' => input_or_output)
+          translator = "#{input_or_output.capitalize}ShapeTranslator"
+          translator = Aws::Api::const_get(translator)
+          shape = translator.translate(src, @options)
+          shape.members.each do |member_name, member|
+            if member.metadata['payload']
+              member.metadata.delete('payload')
+              shape.payload = member_name
+            end
+          end
+          instance_variable_set("@#{input_or_output}", shape)
+        end
+      end
+
+      def set_errors(errors)
+        @errors = errors.map { |src| OutputShapeTranslator.translate(src, @options) }
+        @errors = nil if @errors.empty?
+      end
+
+    end
+  end
+end

data/lib/aws/api/service_namer.rb

@@ -0,0 +1,40 @@
+module Aws
+  module Api
+
+    # This class is responsible for calculating class names and method names
+    # from AWS name.  The basic pattern for determining a class name is:
+    #
+    # * Start with the service full name or abbreviation if it has one
+    # * Remove AWS/Amazon prefixes and suffixes
+    # * Take the shorter of the name or the endpoint prefix
+    #
+    class ServiceNamer
+
+      def initialize(endpoint_prefix, full_name, abbreviation = nil)
+        @full_name = full_name
+        @abbreviation = abbreviation
+        @class_name = build_class_name(endpoint_prefix)
+      end
+
+      # @return [String]
+      attr_reader :full_name
+
+      # @return [String, nil]
+      attr_reader :abbreviation
+
+      alias abbr abbreviation
+
+      # @return [String]
+      attr_reader :class_name
+
+      private
+
+      def build_class_name(endpoint_prefix)
+        name = @abbreviation || @full_name
+        name = name.sub('Amazon', '').sub('AWS', '').gsub(/\W+/, '')
+        [name, endpoint_prefix.upcase].sort_by(&:size).first
+      end
+
+    end
+  end
+end