seahorse 0.1.0 → 1.0.0.pre1

data/lib/seahorse/param_validator.rb

@@ -1,158 +0,0 @@
-# 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

@@ -1,7 +0,0 @@
-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

@@ -1,20 +0,0 @@
-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

@@ -1,84 +0,0 @@
-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

@@ -1,220 +0,0 @@
-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

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

data/lib/tasks/seahorse_tasks.rake

@@ -1,24 +0,0 @@
-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