seahorse 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d97791002e0e789b3434e96537b6638aa4250099
+  data.tar.gz: 231d4abf711240a602e06dab1fc7b1a9a6c15f52
+SHA512:
+  metadata.gz: c16d3d5420f6be5ad2ab1d4b511ae3e6f93c22311379c49e97e3f92f3219dbd862e990d066b9ef44188baceb3bc3ee60bdb60e9b07a81fd98acb8628341895ba
+  data.tar.gz: dc3f7d18cd934f2428da5312125d7050d6cf5bcf142ab198d3b8d9515da1d0a4373506f1a1d8fb7829a49394d4769ea274bce7c453b2e76f4af8d56db72e50e8

data/LICENSE

@@ -0,0 +1,12 @@
+Copyright 2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License"). You
+may not use this file except in compliance with the License. A copy of
+the License is located at
+
+    http://aws.amazon.com/apache2.0/
+
+or in the "license" file accompanying this file. This file is
+distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ANY KIND, either express or implied. See the License for the specific
+language governing permissions and limitations under the License.

data/README.md

@@ -0,0 +1,3 @@
+# Seahorse
+
+This project rocks and uses Apache 2.0 License.

data/Rakefile

@@ -0,0 +1,7 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Bundler::GemHelper.install_tasks

data/lib/seahorse.rb

@@ -0,0 +1,15 @@
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/concern'
+
+require 'seahorse/api_translator/operation'
+require 'seahorse/api_translator/shape'
+require 'seahorse/api_translator/inflector'
+require 'seahorse/controller'
+require 'seahorse/router'
+require 'seahorse/model'
+require 'seahorse/operation'
+require 'seahorse/type'
+require 'seahorse/shape_builder'
+require 'seahorse/version'
+
+require 'seahorse/railtie' if defined?(Rails)

data/lib/seahorse/api_translator/inflector.rb

@@ -0,0 +1,37 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+module Seahorse
+  class ApiTranslator
+
+    # @private
+    module Inflector
+
+      # Performs a very simple inflection on on the words as they are
+      # formatted in the source API configurations.  These are *not*
+      # general case inflectors.
+      # @param [String] string The string to inflect.
+      # @param [String,nil] format Valid formats include 'snake_case',
+      #   'camelCase' and `nil` (leave as is).
+      # @return [String]
+      def inflect string, format = nil
+        case format
+        when 'camelCase' then string.camelize
+        when 'snake_case' then string.underscore
+        else string
+        end
+      end
+    end
+
+  end
+end

data/lib/seahorse/api_translator/operation.rb

@@ -0,0 +1,150 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require_relative './inflector'
+require_relative './shape'
+
+module Seahorse
+  class ApiTranslator
+
+    # @private
+    class Operation
+
+      include Inflector
+
+      def initialize rules, options = {}
+        @options = options
+
+        @method_name = rules['name'].sub(/\d{4}_\d{2}_\d{2}$/, '')
+        @method_name = inflect(@method_name, @options[:inflect_method_names])
+
+        @rules = rules
+
+        if @rules['http']
+          @rules['http'].delete('response_code')
+        end
+
+        translate_input
+        translate_output
+
+        if @options[:documentation]
+          @rules['errors'] = @rules['errors'].map {|e| e['shape_name'] }
+        else
+          @rules.delete('errors')
+          @rules.delete('documentation')
+          @rules.delete('documentation_url')
+          @rules.delete('response_code')
+        end
+      end
+
+      # @return [String]
+      attr_reader :method_name
+
+      # @return [Hash]
+      attr_reader :rules
+
+      private
+
+      def translate_input
+        if @rules['input']
+          rules = InputShape.new(@rules['input'], @options).rules
+          rules['members'] ||= {}
+          rules = normalize_inputs(rules)
+        else
+          rules = {
+            'type' => 'structure',
+            'members' => {},
+          }
+        end
+        @rules['input'] = rules
+      end
+
+      def translate_output
+        if @rules['output']
+          rules = OutputShape.new(@rules['output'], @options).rules
+          move_up_outputs(rules)
+          cache_payload(rules)
+        else
+          rules = {
+            'type' => 'structure',
+            'members' => {},
+          }
+        end
+        @rules['output'] = rules
+      end
+
+      def normalize_inputs rules
+        return rules unless @options[:type].match(/rest/)
+
+        xml = @options[:type].match(/xml/)
+        payload = false
+        wrapper = false
+
+        if rules['members'].any?{|name,rule| rule['payload'] }
+
+          # exactly one member has the payload trait
+          payload, rule = rules['members'].find{|name,rule| rule['payload'] }
+          rule.delete('payload')
+
+          #if rule['type'] == 'structure'
+          #  wrapper = payload
+          #  payload = [payload]
+          #end
+
+        else
+
+          # no members marked themselves as the payload, collect everything
+          # without a location
+          payload = rules['members'].inject([]) do |list,(name,rule)|
+            list << name if !rule['location']
+            list
+          end
+
+          if payload.empty?
+            payload = false
+          elsif xml
+            wrapper = @rules['input']['shape_name']
+          end
+
+        end
+
+        rules = { 'wrapper' => wrapper }.merge(rules) if wrapper
+        rules = { 'payload' => payload }.merge(rules) if payload
+        rules
+
+      end
+
+      def move_up_outputs output
+        move_up = nil
+        (output['members'] || {}).each_pair do |member_name, rules|
+          if rules['payload'] and rules['type'] == 'structure'
+            rules.delete('payload')
+            move_up = member_name
+          end
+        end
+
+        if move_up
+          output['members'].merge!(output['members'].delete(move_up)['members'])
+        end
+      end
+
+      def cache_payload rules
+        (rules['members'] || {}).each_pair do |member_name, rule|
+          rules['payload'] = member_name if rule['payload'] || rule['streaming']
+          rule.delete('payload')
+        end
+      end
+
+    end
+  end
+end

data/lib/seahorse/api_translator/shape.rb

@@ -0,0 +1,235 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require_relative './inflector'
+
+module Seahorse
+  class ApiTranslator
+
+    # @private
+    class Shape
+
+      include Inflector
+
+      def initialize rules, options = {}
+        @options = options
+        @rules = {}
+        @rules['name'] = options['name'] if options.key?('name')
+        set_type(rules.delete('type'))
+        rules.each_pair do |method,arg|
+          send("set_#{method}", *[arg])
+        end
+      end
+
+      def rules
+        if @rules['type'] != 'blob'
+          @rules
+        elsif @rules['payload'] or @rules['streaming']
+          @rules.merge('type' => 'binary')
+        else
+          @rules.merge('type' => 'base64')
+        end
+      end
+
+      def xmlname
+        if @rules['flattened']
+          (@rules['members'] || {})['name'] || @xmlname
+        else
+          @xmlname
+        end
+      end
+
+      protected
+
+      def set_timestamp_format format
+        @rules['format'] = format
+      end
+
+      def set_type name
+        types = {
+          'structure' => 'structure',
+          'list' => 'list',
+          'map' => 'map',
+          'boolean' => 'boolean',
+          'timestamp' => 'timestamp',
+          'character' => 'string',
+          'double' => 'float',
+          'float' => 'float',
+          'integer' => 'integer',
+          'long' => 'integer',
+          'short' => 'integer',
+          'string' => 'string',
+          'blob' => 'blob',
+          'biginteger' => 'integer',
+          'bigdecimal' => 'float',
+        }
+        if name == 'string'
+          # Purposefully omitting type when string (to reduce size of the api
+          # configuration).  The parsers use string as the default when
+          # 'type' is omitted.
+          #@rules['type'] = 'string'
+        elsif type = types[name]
+          @rules['type'] = type
+        else
+          raise "unhandled shape type: #{name}"
+        end
+      end
+
+      def set_members members
+        case @rules['type']
+        when 'structure'
+          @rules['members'] = {}
+          members.each_pair do |member_name,member_rules|
+
+            member_shape = new_shape(member_rules)
+
+            member_key = inflect(member_name, @options[:inflect_member_names])
+            member_rules = member_shape.rules
+
+            if member_name != member_key
+              member_rules = { 'name' => member_name }.merge(member_rules)
+            end
+
+            if swap_names?(member_shape)
+              member_rules['name'] = member_key
+              member_key = member_shape.xmlname
+            end
+
+            @rules['members'][member_key] = member_rules
+
+          end
+        when 'list'
+          @rules['members'] = new_shape(members).rules
+        when 'map'
+          @rules['members'] = new_shape(members).rules
+        else
+          raise "unhandled complex shape `#{@rules['type']}'"
+        end
+        @rules.delete('members') if @rules['members'].empty?
+      end
+
+      def set_keys rules
+        shape = new_shape(rules)
+        @rules['keys'] = shape.rules
+        @rules.delete('keys') if @rules['keys'].empty?
+      end
+
+      def set_xmlname name
+        @xmlname = name
+        @rules['name'] = name
+      end
+
+      def set_location location
+        @rules['location'] = (location == 'http_status' ? 'status' : location)
+      end
+
+      def set_location_name header_name
+        @rules['name'] = header_name
+      end
+
+      def set_payload state
+        @rules['payload'] = true if state
+      end
+
+      def set_flattened state
+        @rules['flattened'] = true if state
+      end
+
+      def set_streaming state
+        @rules['streaming'] = true if state
+      end
+
+      def set_xmlnamespace ns
+        @rules['xmlns'] = ns
+      end
+
+      def set_xmlattribute state
+        @rules['attribute'] = true if state
+      end
+
+      def set_documentation docs
+        @rules['documentation'] = docs if @options[:documentation]
+      end
+
+      def set_enum values
+        @rules['enum'] = values if @options[:documentation]
+      end
+
+      def set_wrapper state
+        @rules['wrapper'] = true if state
+      end
+
+      # we purposefully drop these, not useful unless you want to create
+      # static classes
+      def set_shape_name *args; end
+      def set_box *args; end
+
+      # @param [Hash] rules
+      # @option options [String] :name The name this shape has as a structure member.
+      def new_shape rules
+        self.class.new(rules, @options)
+      end
+
+    end
+
+    # @private
+    class InputShape < Shape
+
+      def set_required *args
+        @rules['required'] = true;
+      end
+
+      def set_member_order order
+        @rules['order'] = order
+      end
+
+      def set_min_length min
+        @rules['min_length'] = min if @options[:documentation]
+      end
+
+      def set_max_length max
+        @rules['max_length'] = max if @options[:documentation]
+      end
+
+      def set_pattern pattern
+        @rules['pattern'] = pattern if @options[:documentation]
+      end
+
+      def swap_names? shape
+        false
+      end
+
+    end
+
+    # @private
+    class OutputShape < Shape
+
+      # these traits are ignored for output shapes
+      def set_required *args; end
+      def set_member_order *args; end
+      def set_min_length *args; end
+      def set_max_length *args; end
+      def set_pattern *args; end
+
+      def swap_names? shape
+        if @options[:documentation]
+          false
+        else
+          !!(%w(query rest-xml).include?(@options[:type]) and shape.xmlname)
+        end
+      end
+
+    end
+
+  end
+end

data/lib/seahorse/controller.rb

@@ -0,0 +1,87 @@
+require_relative './param_validator'
+
+module Seahorse
+  module Controller
+    extend ActiveSupport::Concern
+
+    included do
+      respond_to :json, :xml
+
+      rescue_from Exception, :with => :render_error
+
+      wrap_parameters false
+
+      before_filter do
+        @params = params
+        @params = operation.input.from_input(params, false)
+        @params.update(operation.input.from_input(map_headers, false))
+
+        begin
+          input_rules = operation.to_hash['input']
+          %w(action controller format).each {|v| params.delete(v) }
+          validator = Seahorse::ParamValidator.new(input_rules)
+          validator.validate!(params)
+        rescue ArgumentError => error
+          if request.headers['HTTP_USER_AGENT'] =~ /sdk|cli/
+            service_error(error, 'ValidationError')
+          else
+            raise(error)
+          end
+        end
+
+        @params = operation.input.from_input(@params)
+        @params = params.permit(*operation.input.to_strong_params)
+
+        true
+      end
+    end
+
+    private
+
+    def render_error(exception)
+      service_error(exception, exception.class.name)
+    end
+
+    def params
+      @params || super
+    end
+
+    def respond_with(model, opts = {})
+      opts[:location] = nil
+      if opts[:error]
+        opts[:status] = opts[:error]
+        super
+      else
+        super(operation.output.to_output(model), opts)
+      end
+    end
+
+    def operation
+      return @operation if @operation
+      @operation = api_model.operation_from_action(action_name)
+    end
+
+    def api_model
+      return @api_model if @api_model
+      @api_model = ('Api::' + controller_name.singularize.camelcase).constantize
+    end 
+
+    def service_error(error, code = 'ServiceError', status = 400)
+      respond_with({ code: code, message: error.message }, error: status)
+    end
+
+    def map_headers
+      return @map_headers if @map_headers
+      @map_headers = {}
+      return @map_headers unless operation.input.default_type == 'structure'
+      operation.input.members.each do |name, member|
+        if member.header
+          hdr_name = member.header == true ? name : member.header
+          hdr_name = "HTTP_" + hdr_name.upcase.gsub('-', '_')
+          @map_headers[name] = request.headers[hdr_name]
+        end
+      end
+      @map_headers
+    end
+  end
+end

data/lib/seahorse/model.rb

@@ -0,0 +1,82 @@
+module Seahorse
+  module Model
+    @@apis ||= {}
+
+    class << self
+      def apis; @@apis end
+
+      def add_all_routes(router)
+        Dir.glob("#{Rails.root}/app/models/api/*.rb").each {|f| load f }
+        @@apis.values.each {|api| api.add_routes(router) }
+      end
+    end
+
+    extend ActiveSupport::Concern
+
+    included do
+      @@apis[name.underscore.gsub(/_api$|^api\//, '')] = self
+    end
+
+    module ClassMethods
+      attr_reader :operations
+
+      def model_name
+        name.underscore.gsub(/_api$|^api\//, '')
+      end
+
+      def add_routes(router)
+        Seahorse::Router.new(self).add_routes(router)
+      end
+
+      def desc(text)
+        @desc = text
+      end
+
+      def operation(name, &block)
+        name, action = *operation_name_and_action(name)
+        @actions ||= {}
+        @operations ||= {}
+        @operations[name] = Operation.new(self, name, action, &block)
+        @operations[name].documentation = @desc
+        @actions[action] = @operations[name]
+        @desc = nil
+      end
+
+      def operation_from_action(action)
+        @actions ||= {}
+        @actions[action]
+      end
+
+      def type(name, &block)
+        supertype = 'structure'
+        name, supertype = *name.map {|k,v| [k, v] }.flatten if Hash === name
+        ShapeBuilder.type(name, supertype, &block)
+      end
+
+      def to_hash
+        ops = @operations.inject({}) do |hash, (name, operation)|
+          hash[name.camelcase(:lower)] = operation.to_hash
+          hash
+        end
+        {'operations' => ops}
+      end
+
+      private
+
+      def operation_name_and_action(name)
+        if Hash === name
+          name.to_a.first.map(&:to_s).reverse
+        else
+          case name.to_s
+          when 'index', 'list'
+            ["list_#{model_name.pluralize}", 'index']
+          when 'show'
+            ["get_#{model_name}", name.to_s]
+          else
+            ["#{name}_#{model_name}", name.to_s]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/seahorse/operation.rb

@@ -0,0 +1,66 @@
+module Seahorse
+  class Operation
+    attr_reader :name, :verb, :action
+    attr_accessor :documentation
+
+    def initialize(controller, name, action = nil, &block)
+      @name = name.to_s
+      @action = action.to_s
+      @controller = controller
+      url_prefix = "/" + controller.model_name.pluralize
+      url_extra = nil
+
+      case action.to_s
+      when 'index'
+        @verb = 'get'
+      when 'show'
+        @verb = 'get'
+        url_extra = ':id'
+      when 'destroy', 'delete'
+        @verb = 'delete'
+        url_extra = ':id'
+      when 'create'
+        @verb = 'post'
+      when 'update'
+        @verb = 'put'
+      else
+        @verb = 'get'
+        url_extra = name.to_s
+      end
+      @url = url_prefix + (url_extra ? "/#{url_extra}" : "")
+
+      instance_eval(&block)
+    end
+
+    def verb(verb = nil)
+      verb ? (@verb = verb) : @verb
+    end
+
+    def url(url = nil)
+      url ? (@url = url) : @url
+    end
+
+    def input(type = nil, &block)
+      @input ||= ShapeBuilder.type_class_for(type || 'structure').new
+      type || block ? ShapeBuilder.new(@input).build(&block) : @input
+    end
+
+    def output(type = nil, &block)
+      @output ||= ShapeBuilder.type_class_for(type || 'structure').new
+      type || block ? ShapeBuilder.new(@output).build(&block) : @output
+    end
+
+    def to_hash
+      {
+        'name' => name.camelcase,
+        'http' => {
+          'uri' => url.gsub(/:(\w+)/, '{\1}'),
+          'method' => verb.upcase
+        },
+        'input' => input.to_hash,
+        'output' => output.to_hash,
+        'documentation' => documentation
+      }
+    end
+  end
+end

data/lib/seahorse/param_validator.rb

@@ -0,0 +1,158 @@
+# Copyright 2011-2013 Amazon.com, Inc. or its affiliates. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License"). You
+# may not use this file except in compliance with the License. A copy of
+# the License is located at
+#
+#     http://aws.amazon.com/apache2.0/
+#
+# or in the "license" file accompanying this file. This file is
+# distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+# ANY KIND, either express or implied. See the License for the specific
+# language governing permissions and limitations under the License.
+
+require 'date'
+require 'time'
+require 'pathname'
+
+module Seahorse
+  # @api private
+  class ParamValidator
+
+    # @param [Hash] rules
+    def initialize rules
+      @rules = (rules || {})['members'] || {}
+    end
+
+    # @param [Hash] params A hash of request params.
+    # @raise [ArgumentError] Raises an `ArgumentError` if any of the given
+    #   request parameters are invalid.
+    # @return [Boolean] Returns `true` if the `params` are valid.
+    def validate! params
+      validate_structure(@rules, params || {})
+      true
+    end
+
+    private
+
+    def validate_structure rules, params, context = "params"
+      # require params to be a hash
+      unless params.is_a?(Hash)
+        raise ArgumentError, "expected a hash for #{context}"
+      end
+
+      # check for missing required params
+      rules.each_pair do |param_name, rule|
+        if rule['required']
+          unless params.key?(param_name) or params.key?(param_name.to_sym)
+            msg = "missing required option :#{param_name} in #{context}"
+            raise ArgumentError, msg
+          end
+        end
+      end
+
+      # validate hash members
+      params.each_pair do |param_name, param_value|
+        if param_rules = rules[param_name.to_s]
+          member_context = "#{context}[#{param_name.inspect}]"
+          validate_member(param_rules, param_value, member_context)
+        else
+          msg = "unexpected option #{param_name.inspect} found in #{context}"
+          raise ArgumentError, msg
+        end
+      end
+    end
+
+    def validate_list rules, params, context
+      # require an array
+      unless params.is_a?(Array)
+        raise ArgumentError, "expected an array for #{context}"
+      end
+      # validate array members
+      params.each_with_index do |param_value,n|
+        validate_member(rules, param_value, context + "[#{n}]")
+      end
+    end
+
+    def validate_map rules, params, context
+      # require params to be a hash
+      unless params.is_a?(Hash)
+        raise ArgumentError, "expected a hash for #{context}"
+      end
+      # validate hash keys and members
+      params.each_pair do |key,param_value|
+        unless key.is_a?(String)
+          msg = "expected hash keys for #{context} to be strings"
+          raise ArgumentError, msg
+        end
+        validate_member(rules, param_value, context + "[#{key.inspect}]")
+      end
+    end
+
+    def validate_member rules, param, context
+      member_rules = rules['members'] || {}
+      case rules['type']
+      when 'structure' then validate_structure(member_rules, param, context)
+      when 'list' then validate_list(member_rules, param, context)
+      when 'map' then validate_map(member_rules, param, context)
+      else validate_scalar(rules, param, context)
+      end
+    end
+
+    def validate_scalar rules, param, context
+      case rules['type']
+      when 'string', nil
+        unless param.respond_to?(:to_str)
+          raise ArgumentError, "expected #{context} to be a string"
+        end
+      when 'integer'
+        unless param.respond_to?(:to_int)
+          raise ArgumentError, "expected #{context} to be an integer"
+        end
+      when 'timestamp'
+        case param
+        when Time, DateTime, Date, Integer
+        when /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/
+        else
+          msg = "expected #{context} to be a Time/DateTime/Date object, "
+          msg << "an integer or an iso8601 string"
+          raise ArgumentError, msg
+        end
+      when 'boolean'
+        unless [true,false].include?(param)
+          raise ArgumentError, "expected #{context} to be a boolean"
+        end
+      when 'float'
+        unless param.is_a?(Numeric)
+          raise ArgumentError, "expected #{context} to be a Numeric (float)"
+        end
+      when 'base64', 'binary'
+        unless
+          param.is_a?(String) or
+          (param.respond_to?(:read) and param.respond_to?(:rewind)) or
+          param.is_a?(Pathname)
+        then
+          msg = "expected #{context} to be a string, an IO object or a "
+          msg << "Pathname object"
+          raise ArgumentError, msg
+        end
+      else
+        raise ArgumentError, "unhandled type `#{rules['type']}' for #{context}"
+      end
+    end
+
+    class << self
+
+      # @param [Hash] rules
+      # @param [Hash] params
+      # @raise [ArgumentError] Raises an `ArgumentError` when one or more
+      #   of the request parameters are invalid.
+      # @return [Boolean] Returns `true` when params are valid.
+      def validate! rules, params
+        ParamValidator.new(rules).validate!(params)
+      end
+
+    end
+
+  end
+end

data/lib/seahorse/railtie.rb

@@ -0,0 +1,7 @@
+module Seahorse
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      load File.dirname(__FILE__) + '/../tasks/seahorse_tasks.rake'
+    end
+  end
+end

data/lib/seahorse/router.rb

@@ -0,0 +1,20 @@
+module Seahorse
+  class Router
+    def initialize(model)
+      @model = model
+    end
+
+    def add_routes(router)
+      operations = @model.operations
+      controller = @model.model_name.pluralize
+      operations.each do |name, operation|
+        router.match "/#{name}" => "#{controller}##{operation.action}",
+          defaults: { format: 'json' },
+          via: [:get, operation.verb.to_sym].uniq
+        router.match operation.url => "#{controller}##{operation.action}",
+          defaults: { format: 'json' },
+          via: operation.verb
+      end
+    end
+  end
+end

data/lib/seahorse/shape_builder.rb

@@ -0,0 +1,84 @@
+require_relative './type'
+
+module Seahorse
+  class ShapeBuilder
+    def self.build_default_types
+      hash = HashWithIndifferentAccess.new
+      hash.update string: [StringType, nil],
+                  timestamp: [TimestampType, nil],
+                  integer: [IntegerType, nil],
+                  boolean: [BooleanType, nil],
+                  list: [ListType, nil],
+                  structure: [StructureType, nil]
+      hash
+    end
+
+    def self.type(type, supertype = 'structure', &block)
+      klass = Class.new(type_class_for(supertype))
+      klass.type = type
+      @@types[type] = [klass, block]
+    end
+
+    def self.type_class_for(type)
+      @@types[type] ? @@types[type][0] : nil
+    end
+
+    def initialize(context)
+      @context = context
+      @desc = nil
+    end
+
+    def build(&block)
+      init_blocks = []
+      init_blocks << block if block_given?
+
+      # collect the init block for this type and all of its super types
+      klass = @context.class
+      while klass != Type
+        if block = @@types[klass.type][1]
+          init_blocks << block
+        end
+        klass = klass.superclass
+      end
+
+      init_blocks.reverse.each do |init_block|
+        instance_eval(&init_block)
+      end
+    end
+
+    def method_missing(type, *args, &block)
+      if @@types[type]
+        send_type(type, *args, &block)
+      else
+        super
+      end
+    end
+
+    def desc(text)
+      @desc = text
+    end
+
+    def model(model)
+      @context.model = model
+    end
+
+    private
+
+    def send_type(type, *args, &block)
+      klass, init_block = *@@types[type.to_s]
+      shape = klass.new(*args)
+      shape.documentation = @desc
+      @context.add(shape)
+      if init_block || block
+        old_context, @context = @context, shape
+        instance_eval(&init_block) if init_block
+        instance_eval(&block) if block
+        @context = old_context
+      end
+      @desc = nil
+      true
+    end
+
+    @@types = build_default_types
+  end
+end

data/lib/seahorse/type.rb

@@ -0,0 +1,220 @@
+module Seahorse
+  class Type
+    attr_accessor :name, :required, :model, :location, :header, :uri, :as
+    attr_accessor :documentation
+
+    def self.type; @type || name.to_s.underscore.gsub(/_type$|^.+\//, '') end
+    def self.type=(v) @type = v end
+    def self.inspect; "Type(#{type})" end
+
+    def initialize(*args)
+      name, opts = nil, {}
+      if args.size == 0
+        name = type
+      elsif args.size == 2
+        name, opts = args.first, args.last
+      elsif Hash === args.first
+        opts = args.first
+      else
+        name = args.first
+      end
+
+      self.name = name.to_s
+      opts.each {|k, v| send("#{k}=", v) }
+    end
+
+    def inspect
+      variables = instance_variables.map do |v|
+        next if v.to_s =~ /^@(?:(?:default_)?type|name|model)$/
+        [v.to_s[1..-1], instance_variable_get(v).inspect].join('=')
+      end.compact.join(' ')
+      variables = ' ' + variables if variables.length > 0
+      "#<Type(#{type})#{variables}>"
+    end
+
+    def type
+      @type ||= self.class.type.to_s
+    end
+
+    def default_type
+      klass = self.class
+      last_klass = nil
+      while klass != Type
+        last_klass = klass
+        klass = klass.superclass
+      end
+      @default_type ||= last_klass.type
+    end
+
+    def complex?; false end
+
+    def add(shape)
+      raise NotImplementedError, "Cannot add #{shape.inspect} to #{type}"
+    end
+
+    def to_hash
+      hash = {'type' => default_type}
+      hash['required'] = true if required
+      hash['location'] = location if location
+      hash['location'] = 'uri' if uri
+      if header
+        header_name = header == true ? name : header
+        hash['location'] = 'header'
+        hash['location_name'] = header_name
+        hash['name'] = header_name
+      end
+      hash['documentation'] = documentation if documentation
+      hash
+    end
+
+    def from_input(data, filter = true) data end
+    def to_output(data) pull_value(data).to_s end
+    def to_strong_params; name.to_s end
+
+    def pull_value(value)
+      found = false
+      names = as ? as : name
+      if names
+        names = [names].flatten
+        names.each do |name|
+          if value.respond_to?(name)
+            value = value.send(name)
+            found = true
+          elsif Hash === value
+            if value.has_key?(name)
+              value = value[name]
+              found = true
+            end
+          else
+            raise ArgumentError, "no property `#{name}' while looking for " +
+                                 "`#{names.join('.')}' on #{value.inspect}"
+          end
+        end
+      end
+      found ? value : nil
+    end
+  end
+
+  class StringType < Type
+    def from_input(data, filter = true) data.to_s end
+  end
+
+  class TimestampType < Type
+    def from_input(data, filter = true)
+      String === data ? Time.parse(data) : data
+    end
+  end
+
+  class IntegerType < Type
+    def from_input(data, filter = true) Integer(data) end
+    def to_output(data) (value = pull_value(data)) ? value.to_i : nil end
+  end
+
+  class BooleanType < Type
+    def from_input(data, filter = true) !!pull_value(data) end
+  end
+
+  class ListType < Type
+    attr_accessor :collection
+
+    def initialize(*args)
+      super
+    end
+
+    def complex?; true end
+
+    def add(shape)
+      self.collection = shape
+    end
+
+    def to_hash
+      hash = super
+      hash['members'] = collection ? collection.to_hash : {}
+      hash
+    end
+
+    def from_input(data, filter = true)
+      data.each_with_index {|v, i| data[i] = collection.from_input(v, filter) }
+      data
+    end
+
+    def to_output(data)
+      pull_value(data).map {|v| collection.to_output(v) }
+    end
+
+    def to_strong_params
+      collection.complex? ? collection.to_strong_params : []
+    end
+  end
+
+  class StructureType < Type
+    attr_accessor :members
+
+    def initialize(*args)
+      @members = {}
+      super
+    end
+
+    def complex?; true end
+
+    def add(shape)
+      members[shape.name.to_s] = shape
+    end
+
+    def to_hash
+      hash = super
+      hash['members'] = members.inject({}) do |hsh, (k, v)|
+        hsh[k.to_s] = v.to_hash
+        hsh
+      end
+      hash
+    end
+
+    def from_input(data, filter = true)
+      return nil unless data
+      data.dup.each do |name, value|
+        if members[name]
+          if filter && members[name].type == 'list' && members[name].collection.model &&
+             ActiveRecord::Base > members[name].collection.model
+          then
+            data.delete(name)
+            data[name + '_attributes'] = members[name].from_input(value, filter)
+          else
+            data[name] = members[name].from_input(value, filter)
+          end
+        elsif filter
+          data.delete(name)
+        end
+      end
+      data
+    end
+
+    def to_output(data)
+      if Hash === data
+        data = data.with_indifferent_access unless HashWithIndifferentAccess === data
+      end
+
+      members.inject({}) do |hsh, (name, member)|
+        value = member.to_output(data)
+        hsh[name] = value if value
+        hsh
+      end
+    end
+
+    def to_strong_params
+      members.map do |name, member|
+        if member.complex?
+          if member.type == 'list' && member.collection.model &&
+             ActiveRecord::Base > member.collection.model
+          then
+            name += '_attributes'
+          end
+
+          {name => member.to_strong_params}
+        else
+          name
+        end
+      end
+    end
+  end
+end

data/lib/seahorse/version.rb

@@ -0,0 +1,3 @@
+module Seahorse
+  VERSION = "0.1.0"
+end

data/lib/tasks/seahorse_tasks.rake

@@ -0,0 +1,24 @@
+require 'oj'
+
+namespace :seahorse do
+  desc 'Builds API clients'
+  task :api => :environment do
+    filename = 'service.json'
+    service = {
+      'format' => 'rest-json',
+      'type' => 'rest-json',
+      'endpoint_prefix' => '',
+      'operations' => {}
+    }
+
+    Dir.glob("#{Rails.root}/app/models/api/*.rb").each {|f| load f }
+    Seahorse::Model.apis.values.each do |api|
+      service['operations'].update(api.to_hash['operations'])
+    end
+
+    File.open(filename, 'w') do |f|
+      f.puts(Oj.dump(service, indent: 2))
+    end
+    puts "Wrote service description: #{filename}"
+  end
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: seahorse
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Loren Segal
+- Trevor Rowe
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Easy web service descriptions
+email:
+- amazon@amazon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/seahorse/api_translator/inflector.rb
+- lib/seahorse/api_translator/operation.rb
+- lib/seahorse/api_translator/shape.rb
+- lib/seahorse/controller.rb
+- lib/seahorse/model.rb
+- lib/seahorse/operation.rb
+- lib/seahorse/param_validator.rb
+- lib/seahorse/railtie.rb
+- lib/seahorse/router.rb
+- lib/seahorse/shape_builder.rb
+- lib/seahorse/type.rb
+- lib/seahorse/version.rb
+- lib/seahorse.rb
+- lib/tasks/seahorse_tasks.rake
+- LICENSE
+- Rakefile
+- README.md
+homepage: http://github.com/awslabs/seahorse
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Seahorse is a way to describe web services
+test_files: []
+has_rdoc: