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

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

@@ -1,325 +0,0 @@
-require 'set'
-
-module AwsSdkCodeGenerator
-  module Generators
-    class ResourceClass < Dsl::Class
-
-      extend Helper
-
-      # @option options [required, String] :name
-      # @option options [required, Hash] :resource
-      # @option options [required, Hash] :api
-      # @option options [Hash] :paginators
-      # @option options [Hash] :waiters
-      # @option options [String] :var_name (underscore(name))
-      def initialize(options)
-        @api = options.fetch(:api)
-        @name = options.fetch(:name)
-        @resource = options.fetch(:resource)
-        @paginators = options.fetch(:paginators, nil)
-        @waiters = options.fetch(:waiters, nil)
-        @var_name = options.fetch(:var_name, underscore(@name))
-        super(@name)
-        build
-        check_for_method_name_conflicts!
-      end
-
-      private
-
-      def build
-        extend_module('Aws::Deprecations')
-        add(initialize_method)
-        code('# @!group Read-Only Attributes')
-        add(*identifier_getters)
-        add(*data_attribute_getters)
-        code('# @!endgroup')
-        add(client_getter)
-        add(load_method)
-        add(data_method)
-        add(data_loaded_method)
-        add(exists_method)
-        add(*waiters)
-        apply_actions
-        apply_associations
-        add(identifiers_method)
-        add(*private_methods)
-        add(batch_action)
-      end
-
-      def initialize_method
-        Generators::Resource::InitializeMethod.new(resource: @resource)
-      end
-
-      def identifier_getters
-        identifiers.map do |i|
-          Generators::Resource::IdentifierGetter.new(identifier: i)
-        end
-      end
-
-      def data_attribute_getters
-        data_attribute_names.map do |member_name, member_ref|
-          Generators::Resource::DataAttributeGetter.new(
-            api: @api,
-            member_name: member_name,
-            member_ref: member_ref
-          )
-        end
-      end
-
-      def client_getter
-        Generators::Resource::ClientGetter.new
-      end
-
-      def load_method
-        Generators::Resource::LoadMethod.new(
-          resource_name: @name,
-          definition: @resource['load']
-        )
-      end
-
-      def data_method
-        Generators::Resource::DataMethod.new(
-          resource_name: @name,
-          resource: @resource
-        )
-      end
-
-      def data_loaded_method
-        Generators::Resource::DataLoadedMethod.new
-      end
-
-      def exists_method
-        if @resource['waiters'] && @resource['waiters']['Exists']
-          Generators::Resource::ExistsMethod.new(
-            resource_name: @name,
-            resource: @resource,
-            waiters: @waiters,
-          )
-        end
-      end
-
-      def waiters
-        (@resource['waiters'] || {}).map do |waiter_name, waiter|
-          Generators::Resource::WaiterMethod.new(
-            resource_name: @name,
-            resource: @resource,
-            resource_waiter_name: waiter_name,
-            resource_waiter: waiter,
-            waiter: @waiters['waiters'][waiter['waiterName']]
-          )
-        end
-      end
-
-      def apply_actions
-        actions = @resource['actions'] || {}
-        return if actions.empty?
-        code('# @!group Actions')
-        actions.each do |name, action|
-          add(Resource::Action.new(
-            api: @api,
-            name: name,
-            action: action,
-            var_name: @var_name,
-          ))
-        end
-      end
-
-      def apply_associations
-        associations = []
-        associations += has_associations
-        associations += has_many_associations
-
-        return if associations.empty?
-
-        code('# @!group Associations')
-        associations.sort_by(&:name).each do |association_method|
-          add(association_method)
-        end
-      end
-
-      def has_associations
-        (@resource['has'] || {}).map do |name, has|
-          Resource::HasAssociation.new(
-            api: @api,
-            name: name,
-            has: has
-          )
-        end
-      end
-
-      def has_many_associations
-        (@resource['hasMany'] || {}).map do |name, has_many|
-          Resource::HasManyAssociation.new(
-            name: name,
-            has_many: has_many,
-            api: @api,
-            paginators: @paginators,
-            var_name: @var_name,
-          )
-        end
-      end
-
-      def batch_action
-        Generators::Resource::CollectionClass.new(
-          resource_name: @name,
-          resource: @resource,
-          api: @api,
-        )
-      end
-
-      def identifiers_method
-        Generators::Resource::IdentifiersMethod.new(
-          identifiers: identifiers
-        )
-      end
-
-      def private_methods
-        methods = []
-        methods.concat(extract_identifier_methods)
-        methods << yield_waiter_and_warn_method
-        methods << separate_params_and_options
-        methods.compact
-      end
-
-      def extract_identifier_methods
-        identifiers.map.with_index do |identifier, n|
-          Generators::Resource::ExtractIdentifierMethod.new(
-            identifier: identifier,
-            index: n
-          )
-        end
-      end
-
-      def identifiers
-        @resource['identifiers'] || []
-      end
-
-      def data_attribute_names
-
-        skip = Set.new
-
-        # do no duplicate identifiers
-        identifiers.each do |i|
-          skip << i['name']
-          skip << i['memberName'] if i.key?('memberName')
-        end
-
-        # do no duplicate action names
-        (@resource['actions'] || {}).keys.each do |action_name|
-          skip << action_name
-        end
-
-        # do no duplicate has association names
-        (@resource['has'] || {}).keys.each do |association_name|
-          skip << association_name
-        end
-
-        # do no duplicate hasMany association names
-        (@resource['hasMany'] || {}).keys.each do |association_name|
-          skip << association_name
-        end
-
-        shape = (@api['shapes'] || {})[@resource['shape']] || {}
-        members = shape['members'] || {}
-        Enumerator.new do |y|
-          members.each do |member_name, member_ref|
-            unless skip.include?(member_name)
-              y.yield(member_name, member_ref)
-            end
-          end
-        end
-      end
-
-      def check_for_method_name_conflicts!
-
-        names = Set.new
-
-        # Ensure the resource does not have duplicate names. This
-        # includes comparing identifier names, action names, association
-        # names, e.g. anything that is exposed as a method.
-        @code_objects.each do |code_obj|
-          if Dsl::Method === code_obj || Dsl::AttributeAccessor === code_obj
-            check_for_duplicate_method!(code_obj.name, names)
-          end
-        end
-
-        # It is possible for Dsl::Method#aliases to collide with
-        # code object names. Remove aliases that collide.
-        @code_objects.each do |code_obj|
-          if Dsl::Method === code_obj
-            code_obj.aliases.each do |alias_name|
-              if names.include?(alias_name.to_s)
-                code_obj.aliases.delete(alias_name.to_s)
-              end
-            end
-          end
-        end
-
-        # Compare all resource methods against methods defined
-        # on Ruby's Object class as an instance method. We need to
-        # ensure we do not clobber built in Ruby functionality.
-        Object.instance_methods.each do |obj_method_name|
-          if names.include?(obj_method_name.to_s)
-            raise Errors::ResourceMethodConflict.new(
-              resource_name: @name,
-              method_name: obj_method_name
-            )
-          end
-        end
-      end
-
-      def check_for_duplicate_method!(method_name, names)
-        method_name = method_name.to_s
-        if names.include?(method_name)
-          raise Errors::ResourceMethodConflict.new(
-            resource_name: @name,
-            method_name: method_name
-          )
-        else
-          names << method_name
-        end
-      end
-
-      def yield_waiter_and_warn_method
-        if @resource['waiters'] && @resource['waiters'].size > 0
-          Dsl::Method.new(:yield_waiter_and_warn, access: :private) do |m|
-            m.param(:waiter)
-            m.block_param
-            m.code(<<-CODE)
-if !@waiter_block_warned
-  msg = "pass options to configure the waiter; "
-  msg << "yielding the waiter is deprecated"
-  warn(msg)
-  @waiter_block_warned = true
-end
-yield(waiter.waiter)
-            CODE
-          end
-        end
-      end
-
-      def separate_params_and_options
-        if @resource['waiters'] && @resource['waiters'].size > 0
-          Dsl::Method.new(:separate_params_and_options, access: :private) do |m|
-            m.param(:options)
-            m.code(<<-CODE)
-opts = Set.new([:client, :max_attempts, :delay, :before_attempt, :before_wait])
-waiter_opts = {}
-waiter_params = {}
-options.each_pair do |key, value|
-  if opts.include?(key)
-    waiter_opts[key] = value
-  else
-    waiter_params[key] = value
-  end
-end
-waiter_opts[:client] ||= @client
-[waiter_opts, waiter_params]
-            CODE
-          end
-        end
-      end
-
-    end
-  end
-end

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