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

data/lib/aws-sdk-code-generator/dsl/module.rb

@@ -1,167 +0,0 @@
-module AwsSdkCodeGenerator
-  module Dsl
-    class Module < Dsl::Main
-
-      include Dsl::CodeObject
-
-      # @option options [Main, Module] :parent (nil)
-      def initialize(name, options = {}, &block)
-        @name = name
-        @code_objects = []
-        @access = :public
-        @parent = options.fetch(:parent, nil)
-        @docstring = Dsl::Docstring.new(nil)
-        yield(self) if block
-      end
-
-      attr_reader :name
-
-      def add(*code_objects)
-        code_objects.each do |code_object|
-          if Dsl::Method === code_object && code_object.access != @access
-            add(AccessControlStatement.new(code_object.access))
-          elsif Dsl::AccessControlStatement === code_object
-            @access = code_object.access
-          end
-          super(code_object)
-        end
-      end
-
-      def require_statement(path)
-        root.require(path)
-      end
-      alias require require_statement
-
-      def docstring(docstring = nil)
-        @docstring ||= Dsl::Docstring.new
-        @docstring.append(docstring) unless docstring.nil?
-        @docstring
-      end
-
-      def require_relative(path)
-        root.require_relative(path)
-      end
-
-      def constructor(options = {}, &block)
-        method(:initialize, options, &block)
-      end
-
-      def attr_accessor(name, options = {}, &block)
-        a = Dsl::AttributeAccessor.new(name, options)
-        yield(a) if block
-        add(a)
-      end
-
-      def autoload(const_name, path)
-        @code_objects << AutoloadStatement.new(const_name, path)
-      end
-
-      def attr_reader(name, options = {}, &block)
-        a = Dsl::AttributeReader.new(name, options)
-        yield(a) if block
-        add(a)
-      end
-
-      def attr_writer(name, &block)
-        a = Dsl::AttributeWriter.new(name)
-        yield(a) if block
-        add(a)
-      end
-
-      def eigenclass(&block)
-        m = Dsl::Eigenclass.new
-        yield(m) if block
-        add(m)
-      end
-
-      def lines
-        code = []
-        code.concat(@docstring.lines)
-        code += open_module
-        code << :newline if padded?(0)
-
-        @code_objects.each.with_index do |code_object, n|
-          code << code_object.lines
-          code << :newline if separator?(n)
-        end
-
-        if @code_objects.empty?
-          code[-1] += "; end"
-        else
-          code += close_module
-        end
-        code
-      end
-
-      private
-
-      def open_module
-        ["module #{@name}"]
-      end
-
-      def close_module
-        ["end"]
-      end
-
-      def padded?(n)
-        !@code_objects[n].kind_of?(Dsl::Module) &&
-        !(
-          @code_objects.all? { |obj| autoload_statement?(obj) } ||
-          @code_objects.all? { |obj| mixin?(obj) } ||
-          @code_objects.all? { |obj| undocumented_attr_macro?(obj) }
-        )
-      end
-
-      def separator?(n)
-        if last?(n)
-          padded?(@code_objects.size - 1)
-        elsif grouped_statements?(n)
-          false
-        else
-          true
-        end
-      end
-
-      def last?(n)
-        @code_objects.size == n + 1
-      end
-
-      def grouped_statements?(n)
-        two_autoloads?(n) ||
-        two_mixins?(n) ||
-        two_undocumented_attr_macros?(n)
-      end
-
-      def two_autoloads?(n)
-        @code_objects[n + 1] &&
-        autoload_statement?(@code_objects[n + 1]) &&
-        autoload_statement?(@code_objects[n])
-      end
-
-      def two_mixins?(n)
-        @code_objects[n + 1] &&
-        mixin?(@code_objects[n + 1]) &&
-        mixin?(@code_objects[n])
-      end
-
-      def two_undocumented_attr_macros?(n)
-        @code_objects[n + 1] &&
-        undocumented_attr_macro?(@code_objects[n + 1]) &&
-        undocumented_attr_macro?(@code_objects[n])
-      end
-
-      def autoload_statement?(code_object)
-        Dsl::AutoloadStatement === code_object
-      end
-
-      def mixin?(code_object)
-        Dsl::IncludeStatement === code_object
-      end
-
-      def undocumented_attr_macro?(code_object)
-        Dsl::AttributeAccessor === code_object && !code_object.documented?
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-code-generator/dsl/option_tag.rb

@@ -1,36 +0,0 @@
-module AwsSdkCodeGenerator
-  module Dsl
-    class OptionTag
-
-      # @option options [required, String] :name
-      # @option options [required, String] :type
-      # @option options [String] :param ('options')
-      # @option options [Boolean] :required (false)
-      # @option options [String, nil] :docstring (nil)
-      # @option options [Object] :default
-      def initialize(options)
-        @name = options.fetch(:name)
-        @type = options.fetch(:type)
-        @param = options.fetch(:param, 'options')
-        @required = options.fetch(:required, false) ? 'required, ' : ''
-        @docstring = Dsl::TagDocstring.new(options.fetch(:docstring, nil))
-        @default = Dsl::TagDefault.new(options.fetch(:default, nil))
-      end
-
-      def lines
-        [first_line] + @docstring.lines
-      end
-
-      private
-
-      def first_line
-        "# @option #{@param} [#{@required}#{@type}] :#{@name}#{yard_default}"
-      end
-
-      def yard_default
-        @default.empty? ? '' : " (#{@default})"
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-code-generator/dsl/param.rb

@@ -1,43 +0,0 @@
-module AwsSdkCodeGenerator
-  module Dsl
-    class Param
-
-      # @option options [String] :type
-      # @option options [Object] :default
-      # @option options [String] :docstring
-      # @option options [Boolean] :documented (true)
-      def initialize(name, options = {})
-        @name = name.to_s
-        @type = TagType.new(options.fetch(:type, nil))
-        @default = TagDefault.new(options.fetch(:default, nil))
-        @docstring = TagDocstring.new(options.fetch(:docstring, nil))
-        @documented = options.fetch(:documented, true)
-      end
-
-      attr_reader :name, :default
-
-      def documented?
-        !!@documented
-      end
-
-      def tag
-        if [@type, @default, @docstring].all?(&:empty?)
-          []
-        else
-          [first_line] + @docstring.lines
-        end
-      end
-
-      private
-
-      def first_line
-        "# @param#{@type} #{@name}#{yard_default}"
-      end
-
-      def yard_default
-        @default.empty? ? '' : " (#{@default})"
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-code-generator/dsl/param_list.rb

@@ -1,38 +0,0 @@
-module AwsSdkCodeGenerator
-  module Dsl
-    # @api private
-    class ParamList
-
-      def initialize(params)
-        @params = params
-      end
-
-      def signature
-        if @params.empty?
-          nil
-        else
-          "(#{@params.map { |p| param_signature(p) }.join(', ')})"
-        end
-      end
-
-      def tags
-        lines = []
-        @params.each do |param|
-          lines.concat(param.tag) if param.documented?
-        end
-        lines
-      end
-
-      private
-
-      def param_signature(param)
-        if param.default.empty?
-          param.name
-        else
-          "#{param.name} = #{param.default}"
-        end
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-code-generator/dsl/return_tag.rb

@@ -1,19 +0,0 @@
-module AwsSdkCodeGenerator
-  module Dsl
-    # @api private
-    class ReturnTag
-
-      # @option options [required, String] :type
-      # @option options [String] :docstring
-      def initialize(options)
-        @type = Dsl::TagType.new(options.fetch(:type))
-        @docstring = Dsl::TagDocstring.new(options.fetch(:docstring, nil))
-      end
-
-      def lines
-        ["# @return#{@type}"] + @docstring.lines
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-code-generator/dsl/tag_default.rb

@@ -1,20 +0,0 @@
-module AwsSdkCodeGenerator
-  module Dsl
-    # @api private
-    class TagDefault
-
-      def initialize(default)
-        @default = default
-      end
-
-      def to_s
-        @default.inspect
-      end
-
-      def empty?
-        @default.nil?
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-code-generator/dsl/tag_docstring.rb

@@ -1,27 +0,0 @@
-module AwsSdkCodeGenerator
-  module Dsl
-    # @api private
-    class TagDocstring
-
-      def initialize(docstring)
-        @lines = docstring.to_s.strip.lines.inject([]) do |lines, line|
-          line = line.rstrip
-          if line.empty?
-            lines << "#"
-          else
-            lines << "#   #{line.rstrip}"
-          end
-        end
-      end
-
-      # @return Array<String>
-      attr_reader :lines
-
-      # @return [Boolean]
-      def empty?
-        @lines.empty?
-      end
-
-    end
-  end
-end

data/lib/aws-sdk-code-generator/dsl/tag_type.rb

@@ -1,18 +0,0 @@
-module AwsSdkCodeGenerator
-  module Dsl
-    # @api private
-    class TagType < String
-
-      def self.new(type)
-        if type
-          types = Array(type)
-          types = types.map { |t| t.nil? ? 'nil' : t.to_s }
-          super(types.empty? ? '' : " [#{types.join(', ')}]")
-        else
-          super('')
-        end
-      end
-
-    end
-  end
-end

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

@@ -1,334 +0,0 @@
-module AwsSdkCodeGenerator
-  module Generators
-    class ClientApiModule < Dsl::Module
-
-      include Helper
-
-      SKIP_TRAITS = Set.new(%w(shape deprecated location locationName documentation))
-
-      SHAPE_CLASSES = {
-        'blob' => 'BlobShape',
-        'byte' => 'IntegerShape',
-        'boolean' => 'BooleanShape',
-        'character' => 'StringShape',
-        'double' => 'FloatShape',
-        'float' => 'FloatShape',
-        'integer' => 'IntegerShape',
-        'list' => 'ListShape',
-        'long' => 'IntegerShape',
-        'map' => 'MapShape',
-        'string' => 'StringShape',
-        'structure' => 'StructureShape',
-        'timestamp' => 'TimestampShape',
-      }
-
-      SHAPE_KEYS = {
-        # keep
-        'flattened' => true,
-        'timestampFormat' => true, # glacier api customization
-        'xmlNamespace' => true,
-        # ignore
-        'box' => false,
-        'fault' => false,
-        'error' => false,
-        'deprecated' => false,
-        'type' => false,
-        'documentation' => false,
-        'members' => false,
-        'member' => false,
-        'key' => false,
-        'locationName'  => false,
-        'value' => false,
-        'required' => false,
-        'streaming'  => false,
-        'enum' => false,
-        'exception' => false,
-        'payload' => false,
-        'pattern' => false,
-        'sensitive' => false,
-        'min' => false,
-        'max' => false,
-        'wrapper' => false,
-        'xmlOrder' => false,
-      }
-
-      METADATA_KEYS = {
-        # keep
-        'endpointPrefix' => true,
-        'signatureVersion' => true,
-        'signingName' => true,
-        'serviceFullName' => true,
-        'protocol' => true,
-        'targetPrefix' => true,
-        'jsonVersion' => true,
-        'errorPrefix' => true,
-        'timestampFormat' => true, # glacier api customization
-        'xmlNamespace' => true,
-
-        # ignore
-        'apiVersion' => false,
-        'checksumFormat' => false,
-        'globalEndpoint' => false,
-        'serviceAbbreviation' => false,
-        'uid' => false,
-      }
-
-      # @option options [required, Hash] :api
-      # @option options [required, Hash, nil] :paginators
-      def initialize(options)
-        @api = options.fetch(:api)
-        @paginators = options.fetch(:paginators)
-        super('ClientApi')
-        docstring("@api private")
-        include('Seahorse::Model')
-        apply_shape_classes(self)
-        apply_shape_definitions(self)
-        apply_api_const(self)
-      end
-
-      private
-
-      def metadata
-        Dsl::CodeLiteral.new do |c|
-          c << "api.metadata = {"
-          c.indent do
-            (@api['metadata'] || {}).keys.sort.each do |key|
-              if METADATA_KEYS[key]
-                c << "#{key.inspect} => #{@api['metadata'][key].inspect},"
-              elsif METADATA_KEYS[key].nil?
-                raise "unhandled metadata key #{key.inspect}"
-              end
-            end
-          end
-          c << "}"
-        end
-      end
-
-      def operations
-        (@api['operations'] || {}).map do |name, operation|
-          operation(name, operation)
-        end
-      end
-
-      def operation(name, operation)
-        Dsl::CodeLiteral.new do |code|
-          code << "api.add_operation(:#{underscore(name)}, Seahorse::Model::Operation.new.tap do |o|"
-          code.indent do |c|
-            c << "o.name = #{name.inspect}"
-            c << "o.http_method = #{operation['http']['method'].inspect}"
-            c << "o.http_request_uri = #{operation['http']['requestUri'].inspect}"
-            c << "o.deprecated = true" if operation['deprecated']
-            c << "o['authtype'] = #{operation['authtype'].inspect}" if operation['authtype']
-            %w(input output).each do |mode|
-              c << "o.#{mode} = #{operation_shape_ref(operation[mode])}"
-            end
-            Array(operation['errors']).each do |error|
-              c << "o.errors << #{operation_shape_ref(error)}"
-            end
-            apply_operation_pager(c, name)
-          end
-          code << "end)"
-        end
-      end
-
-      def operation_shape_ref(ref)
-        if ref
-          metadata = ref.dup
-          shape_name = metadata.delete('shape')
-          if metadata.empty?
-            options = ''
-          else
-            options = {}
-            metadata.each_pair do |key, value|
-              next if key == 'resultWrapper'
-              if key == 'locationName'
-                options[:location_name] = value.inspect
-              else
-                options[:metadata] ||= {}
-                options[:metadata][key] = value.inspect
-              end
-            end
-            if options.empty?
-              options = ''
-            else
-              options = ', ' + HashFormatter.new(wrap:false).format(options)
-            end
-          end
-          "Shapes::ShapeRef.new(shape: #{shape_name}#{options})"
-        else
-          "Shapes::ShapeRef.new(shape: Shapes::StructureShape.new(struct_class: Aws::EmptyStructure))"
-        end
-      end
-
-      def shape_ref(ref, member_name = nil, required = Set.new)
-        line = "Shapes::ShapeRef.new(shape: #{ref['shape']}"
-        line += shape_ref_required(required, member_name)
-        line += shape_ref_deprecated(ref)
-        line += shape_ref_location(ref)
-        line += shape_ref_location_name(member_name, ref)
-        line += shape_ref_metadata(ref)
-        line += ")"
-        line
-      end
-
-      def apply_operation_pager(code, operation_name)
-        if @paginators && @paginators['pagination'][operation_name]
-          p = @paginators['pagination'][operation_name]
-          input = Array(p['input_token'])
-          output = Array(p['output_token'])
-          tokens = {}
-          input.each.with_index do |key, n|
-            tokens[underscore_jmespath(output[n])] = underscore_jmespath(key)
-          end
-          options = {}
-          options[:more_results] = underscore_jmespath(p['more_results']) if p['more_results']
-          options[:limit_key] = underscore_jmespath(p['limit_key']) if p['limit_key']
-          options[:tokens] = tokens
-          options = HashFormatter.new(
-            quote_strings: true,
-            inline: true,
-            wrap: false,
-          ).format(options)
-          code << "o[:pager] = Aws::Pager.new(#{options})" unless tokens.empty?
-        end
-      end
-
-      def underscore_jmespath(str)
-        Underscore.underscore_jmespath(str)
-      end
-
-      def apply_shape_classes(m)
-        m.code do |c|
-          shape_defs.each do |shape_name, shape|
-            attrs = []
-            attrs << "name: '#{shape_name}'"
-            shape.each_pair do |key, value|
-              if SHAPE_KEYS[key]
-                attrs << "#{key}: #{value.inspect}"
-              elsif SHAPE_KEYS[key].nil?
-                raise "unhandled shape key #{key.inspect}"
-              end
-            end
-            attrs = attrs.join(', ')
-            c << "#{shape_name} = Shapes::#{shape_class(shape['type'])}.new(#{attrs})"
-          end
-        end
-      end
-
-      def apply_shape_definitions(m)
-        m.code do |c|
-          shape_defs.each do |shape_name, shape|
-            if shape['type'] == 'structure' && !shape['error'] && !shape['exception']
-              required = Set.new(shape['required'] || [])
-              shape['members'].each do |member_name, member_ref|
-                c << "#{shape_name}.add_member(:#{underscore(member_name)}, #{shape_ref(member_ref, member_name, required)})"
-              end
-              c << "#{shape_name}.struct_class = Types::#{shape_name}"
-              if payload = shape['payload']
-                c << "#{shape_name}[:payload] = :#{underscore(payload)}"
-                c << "#{shape_name}[:payload_member] = #{shape_name}.member(:#{underscore(payload)})"
-              end
-            elsif shape['type'] == 'list'
-              c << "#{shape_name}.member = #{shape_ref(shape['member'])}"
-            elsif shape['type'] == 'map'
-              c << "#{shape_name}.key = #{shape_ref(shape['key'])}"
-              c << "#{shape_name}.value = #{shape_ref(shape['value'])}"
-            else
-              next
-            end
-            c.newline
-          end
-        end
-      end
-
-      def apply_api_const(m)
-        m.code do |c|
-          c << "# @api private"
-          c << "API = Seahorse::Model::Api.new.tap do |api|"
-          c.indent do
-            c.newline
-            if @api['metadata'] && @api['metadata']['apiVersion']
-              c << "api.version = #{@api['metadata']['apiVersion'].inspect}"
-              c.newline
-            end
-            c << metadata
-            operations.each do |operation|
-              c.newline
-              c << operation
-            end
-          end
-          c << "end"
-        end
-      end
-
-      def shape_ref_required(required, member_name)
-        if required.include?(member_name)
-          ", required: true"
-        else
-          ""
-        end
-      end
-
-      def shape_ref_deprecated(ref)
-        if ref['deprecated'] || @api['shapes'][ref['shape']]['deprecated']
-          ", deprecated: true"
-        else
-          ""
-        end
-      end
-
-      def shape_ref_location(ref)
-        if ref['location']
-          ", location: #{ref['location'].inspect}"
-        else
-          ''
-        end
-      end
-
-      def shape_ref_location_name(member_name, member_ref)
-        location_name = member_ref['locationName']
-        location_name ||= member_name unless member_ref['location'] == 'headers'
-        location_name ? ", location_name: #{location_name.inspect}" : ""
-      end
-
-      def shape_ref_metadata(member_ref)
-        metadata = member_ref.inject({}) do |hash, (key, value)|
-          hash[key] = value unless SKIP_TRAITS.include?(key)
-          hash
-        end
-        if metadata.empty?
-          ""
-        else
-          ", metadata: #{metadata.inspect}"
-        end
-      end
-
-      def shape_class(type)
-        if SHAPE_CLASSES.key?(type)
-          SHAPE_CLASSES[type]
-        else
-          raise ArgumentError, "unsupported shape type `#{type}'"
-        end
-      end
-
-      def shape_defs
-        Enumerator.new do |y|
-          (@api['shapes'] || {}).keys.sort.each do |shape_name|
-            y.yield(shape_name, @api['shapes'][shape_name])
-          end
-        end
-      end
-
-      def structure_defs
-        Enumerator.new do |y|
-          shape_defs.each do |shape_name, shape|
-            if shape['type'] == 'structure' && !shape['error'] && !shape['exception']
-              y.yield(shape_name, shape)
-            end
-          end
-        end
-      end
-
-    end
-  end
-end