aws-sdk-core 2.0.0.rc14 → 2.0.0.rc15

data/lib/aws/api/manifest.rb

@@ -1,29 +0,0 @@
-require 'multi_json'
-
-module Aws
-  module Api
-    # @api private
-    class Manifest
-
-      # @api private
-      DEFAULT_MANIFEST_PATH = File.join(GEM_ROOT, 'apis', 'manifest.json')
-
-      # @param [Hash] manifest
-      def initialize(manifest)
-        @services = manifest.map do |name,verisons|
-          Entry.new(name, name.downcase.to_sym, verisons)
-        end
-      end
-
-      # @return [Array<Service>]
-      attr_reader :services
-
-      def self.default_manifest
-        new(MultiJson.load(File.read(DEFAULT_MANIFEST_PATH)))
-      end
-
-      Entry = Struct.new(:name, :identifier, :versions)
-
-    end
-  end
-end

data/lib/aws/api/manifest_builder.rb

@@ -1,57 +0,0 @@
-require 'multi_json'
-
-module Aws
-  module Api
-    # @api private
-    class ManifestBuilder
-
-      # @param [String] directory The folder to scan for API files.
-      def initialize(directory)
-        @directory = directory
-      end
-
-      def build
-        manifest = {}
-        Dir.glob(File.join(@directory, '*.api.json')).each do |path|
-          api = JSON.load(File.read(path))
-          service = compute_service_name(api)
-          version = api['metadata']['apiVersion']
-          manifest[service] ||= {}
-          manifest[service][version] = entry(path, api)
-        end
-        manifest
-      end
-
-      private
-
-      def compute_service_name(api)
-        metadata = api['metadata']
-        name = metadata['serviceAbbreviation'] || metadata['serviceFullName']
-        name = name.sub('Amazon', '').sub('AWS', '').gsub(/\W+/, '')
-        name
-      end
-
-      def compatible_with(api)
-        api['metadata']['compatibleWith']
-      end
-
-      def path_for(file_type, api)
-        prefix = api['metadata']['endpointPrefix']
-        version = api['metadata']['apiVersion']
-        path = File.join(@directory, "#{prefix}-#{version}.#{file_type}.json")
-        path if File.exists?(path)
-      end
-
-      def entry(path, api)
-        entry = {
-          'api' => path,
-          'paginators' => path_for('paginators', api),
-          'waiters' => path_for('waiters', api),
-          'resources' => path_for('resources', api),
-          'compatibleWith' => compatible_with(api),
-        }.delete_if { |k,v| v.nil? }
-      end
-
-    end
-  end
-end

data/lib/aws/api/minifier.rb

@@ -1,42 +0,0 @@
-require 'multi_json'
-
-module Aws
-  module Api
-
-    # @api private
-    # Generates smaller API models by removing:
-    #
-    # * documentation
-    # * whitespace
-    #
-    class Minifier
-
-      def self.minify(src, target)
-        json = MultiJson.load(File.read(src))
-        json = new(json).minify
-        File.open(target, 'w') { |f| f.write(MultiJson.dump(json)) }
-      end
-
-      def initialize(json)
-        @json = json
-      end
-
-      def minify(value = @json)
-        case value
-        when Hash
-          value.inject({}) do |h, (k, v)|
-            unless k == 'documentation'
-              h[k] = minify(v)
-            end
-            h
-          end
-        when Array
-          value.map { |v| minify(v) }
-        else
-          value
-        end
-      end
-
-    end
-  end
-end

data/lib/aws/response_handler.rb

@@ -1,38 +0,0 @@
-module Aws
-  # @api private
-  class ResponseHandler
-
-    def initialize(parser)
-      @parser = parser
-    end
-
-    attr_accessor :handler
-
-    def call(context)
-      @handler.call(context).on(200..299) do |response|
-        rules = context.operation.output
-        response.error = nil
-        response.data = case
-          when rules.raw_payload? then empty_struct(rules)
-          when rules.payload then parse_payload(rules, context)
-          else parse(rules, context)
-        end
-      end
-    end
-
-    def empty_struct(rules)
-      Structure.new(rules.members.keys)
-    end
-
-    def parse_payload(rules, context)
-      data = empty_struct(rules)
-      data[rules.payload] = parse(rules.payload_member, context)
-      data
-    end
-
-    def parse(rules, context)
-      @parser.parse(rules, context.http_response.body_contents)
-    end
-
-  end
-end

data/lib/aws/service_builder.rb

@@ -1,56 +0,0 @@
-module Aws
-  class ServiceBuilder
-    class << self
-
-      # @param [Symbol] identifier
-      # @option options [required, String, Hash, Seahorse::Model::Api] 'api'
-      # @option options [String, Hash, Paging::Provider] 'paging'
-      # @return [Module<Service>]
-      def new(identifier, options = {})
-        svc_module = Module.new
-        svc_module.send(:extend, Service)
-        svc_module.const_set(:Errors, Module.new { extend Errors::DynamicErrors })
-        svc_module.const_set(:Client, client_class(identifier, options))
-        svc_module
-      end
-
-      private
-
-      def client_class(identifier, options)
-        client_class = Class.new(Seahorse::Client::Base)
-        client_class.const_set(:IDENTIFIER, identifier)
-        client_class.const_set(:PAGING_PROVIDER, paging_provider(options))
-        client_class.set_api(api(options))
-        Api::ServiceCustomizations.apply(client_class)
-        client_class
-      end
-
-      def api(options)
-        api = options['api']
-        case api
-        when Seahorse::Model::Api then api
-        when Hash then Seahorse::Model::Api.new(api)
-        when String then Seahorse::Model::Api.new(load_json(api))
-        else
-          raise ArgumentError, "expected :api to be an Api, Hash or String"
-        end
-      end
-
-      def paging_provider(options)
-        paginators = options['paginators']
-        case paginators
-        when Paging::Provider then paginators
-        when Hash then Paging::Provider.new(paginators)
-        when String then Paging::Provider.new(load_json(paginators))
-        when nil then Paging::NullProvider.new
-        end
-      end
-
-      def load_json(path)
-        path = File.join(GEM_ROOT, path) unless path.match(/^#{File::SEPARATOR}/)
-        MultiJson.load(File.read(path))
-      end
-
-    end
-  end
-end