angus 0.0.1 → 0.0.2

data/lib/angus/marshallings/marshalling.rb

@@ -0,0 +1,136 @@
+require 'bigdecimal'
+require 'date'
+
+module Angus
+  module Marshalling
+
+    # Marshal an object
+    #
+    # This method is intended for scalar objects and arrays of scalar objects.
+    #
+    # For more complex objects:
+    # @see Angus::Marshalling.marshal_object
+    #
+    # @param object The object to be marshalled
+    # @return [Array] An object suitable for be converted easily to JSON notation
+    #
+    # If {object} is an array, this method returns an array with all the elements marshalled
+    # Else returns a marshalled representation of the object.
+    def self.marshal(object)
+      if object.is_a?(Array)
+        object.map { |element| marshal(element) }
+      else
+        marshal_scalar(object)
+      end
+    end
+
+    # Marshal a complex object.
+    #
+    # @param object The object to be marshalled
+    # @param getters An array of getters / hashes that will be used to obtain the information
+    #   from the object.
+    def self.marshal_object(object, getters)
+      result = {}
+      getters.each do |getter|
+        if getter.is_a?(Hash)
+          key = getter.keys[0]
+          value = get_value(object, key)
+
+          #TODO Consider adding ActiveRecord::Relation support
+          #ex: "if value.is_a?(Array) || value.is_a?(ActiveRecord::Relation)"
+          if value.is_a?(Array)
+            result[key] = value.map { |object| marshal_object(object, getter.values[0]) }
+          else
+            result[key] = value.nil? ? nil : marshal_object(value, getter.values[0])
+          end
+        else
+          value = get_value(object, getter)
+          result[getter] = marshal_scalar(value)
+        end
+      end
+      return result
+    end
+
+    private
+
+    # Gets a value from a object for a given getter.
+    #
+    # @param [Object] object The object to get the value from
+    # @param [Symbol, String] getter to request from the object
+    # @raise [InvalidGetterError] when getter is not present
+    # in the object
+    # @return [Object] the requested value
+    def self.get_value(object, getter)
+      if object.is_a?(Hash)
+        get_value_from_hash(object, getter)
+      else
+        get_value_from_object(object, getter)
+      end
+    end
+
+    # Gets a value from a object by invoking method.
+    #
+    # @param [Object] object The object to get the value from
+    # @param [Symbol, String] method the method to invoke in the object
+    # @raise [InvalidGetterError] when the object does not responds
+    # to method as public.
+    # @return [Object] the requested value
+    def self.get_value_from_object(object, method)
+      value = object.public_send method.to_sym
+
+      # HACK in order to fix the error:
+      # NoMethodError: undefined method `merge' for #<JSON::Ext::Generator::State:0x257fd086>
+      if value.is_a?(Array)
+        value.to_a
+      else
+        value
+      end
+    # TODO ver si tirar una exception especifica o que hacer?
+    #rescue NoMethodError => error
+    #  raise InvalidGetterError.new(method, error.backtrace.first)
+    end
+
+    # Gets a value from a hash for a given key.
+    #
+    # It accepts the key as a symbol or a string,
+    # it looks for the symbol key first.
+    #
+    # @param [Hash] hash The hash to get the value from
+    # @param [Symbol, String] key to get from the hash
+    # @raise [InvalidGetterError] when the key does not
+    # exists in the hash
+    # @return [Object] the requested value
+    def self.get_value_from_hash(hash, key)
+      if hash.has_key?(key.to_sym)
+        hash[key.to_sym]
+      elsif hash.has_key?(key.to_s)
+        hash[key.to_s]
+      else
+        #raise InvalidGetterError.new(key)
+        raise NoMethodError.new(key.to_s)
+      end
+    end
+
+    # Marshal a scalar value
+    # @param scalar the scalar value to be marshalled
+    #
+    # If scalar is a Date or DateTime it return a iso8601 string
+    # If scalar is a Symbol it returns the symbol as string
+    # Everything else (string, integer, ...) returns the same object.
+    def self.marshal_scalar(scalar)
+      case scalar
+        when Time
+          scalar.iso8601
+        when DateTime
+          scalar.iso8601
+        when Date
+          scalar.iso8601
+        when Symbol
+          scalar.to_s
+        else
+          scalar
+      end
+    end
+
+  end
+end

data/lib/angus/marshallings/unmarshalling.rb

@@ -0,0 +1,29 @@
+require 'bigdecimal'
+require 'date'
+
+module Angus
+  module Unmarshalling
+
+    def self.unmarshal_scalar(scalar, type)
+      return nil if scalar.nil?
+
+      case type
+      when :string
+        scalar
+      when :integer
+        scalar
+      when :boolean
+        scalar
+      when :date
+        Date.iso8601(scalar)
+      when :date_time
+        DateTime.iso8601(scalar)
+      when :decimal
+        BigDecimal.new(scalar.to_s)
+      else
+        raise ArgumentError, "Unknown type: #{type}"
+      end
+    end
+
+  end
+end

data/lib/angus/renders/base.rb

@@ -0,0 +1,2 @@
+require_relative 'html_render'
+require_relative 'json_render'

data/lib/angus/renders/html_render.rb

@@ -0,0 +1,9 @@
+module HtmlRender
+
+  def self.render(response, html)
+    response['Content-Type'] = 'text/html'
+
+    response.write(html)
+  end
+
+end

data/lib/angus/renders/json_render.rb

@@ -0,0 +1,15 @@
+module JsonRender
+
+  def self.render(response, json)
+    response['Content-Type'] = 'application/json'
+
+    json = if json.is_a?(String)
+             json
+           else
+             JSON(json, :ascii_only => true)
+           end
+
+    response.write(json)
+  end
+
+end

data/lib/angus/request_handler.rb

@@ -0,0 +1,62 @@
+require 'angus-router'
+
+require_relative 'response'
+require_relative 'responses'
+
+module Angus
+  class RequestHandler
+
+    include Responses
+
+    DEFAULT_RENDER = :json
+
+    attr_reader :env, :request, :response, :params
+
+    def initialize
+      @router = Angus::Router.new
+    end
+
+    def router
+      @router
+    end
+
+    def call(env)
+      begin
+        @env      = env
+        @response = Response.new
+
+        router.route(env)
+      rescue Angus::Router::NotImplementedError
+        @response.status = HTTP_STATUS_CODE_NOT_FOUND
+
+        render({ 'status' => 'error',
+                 'messages' => [{ 'level' => 'error', 'key' => 'RouteNotFound',
+                                  'dsc' => 'Invalid route' }]
+               }, {format: :json})
+      end
+
+      @response.finish
+    end
+
+    # TODO ver multiples formatos en el futuro
+    def render(content, options = {})
+      format = options[:format] || DEFAULT_RENDER
+      case(format)
+        when :html
+          HtmlRender.render(@response, content)
+        when :json
+          JsonRender.render(@response, content)
+        else
+          raise 'Unknown render format'
+      end
+    end
+
+    # TODO ver esto en el futuro
+    # Use the specified Rack middleware
+    def use(middleware, *args, &block)
+      @prototype = nil
+      @middleware << [middleware, args, block]
+    end
+
+  end
+end

data/lib/angus/resource_definition.rb

@@ -0,0 +1,78 @@
+require 'yaml'
+
+module Angus
+  class ResourceDefinition
+
+    def initialize(resource_name, representations)
+      @resource_name       = resource_name
+      @resource_class_name = classify_resource(resource_name)
+      @representations     = representations || {}
+    end
+
+    def operations
+      @representations.operations[@resource_name.to_s]
+    end
+
+    def canonical_name
+      Angus::String.underscore(@resource_class_name.to_s)
+    end
+
+    def resource_class
+      return @resource_class if @resource_class
+      require resource_path
+
+      @resource_class = Object.const_get(@resource_class_name)
+    end
+
+    def resource_path
+      File.join('resources', canonical_name)
+    end
+
+    def build_response_metadata(response_representation)
+      return {} unless response_representation
+
+      case response_representation
+        when Angus::SDoc::Definitions::Representation
+          result = []
+
+          response_representation.fields.each do |field|
+            result << build_response_metadata(field)
+          end
+
+          result
+        when Array
+          result = []
+
+          response_representation.each do |field|
+            result << build_response_metadata(field)
+          end
+
+          result
+        else
+          field_name = response_representation.name
+          field_type = response_representation.type || response_representation.elements_type
+
+          # TODO fix this
+          representation = representation_by_name(field_type)
+
+          if representation.nil?
+            field_name.to_sym
+          else
+            {field_name.to_sym => build_response_metadata(representation)}
+          end
+      end
+    end
+
+    # TODO improve this find
+    def representation_by_name(name)
+      @representations.representations.find { |representation| representation.name == name }
+    end
+
+    private
+
+    def classify_resource(resource)
+      Angus::String.camelize(resource)
+    end
+
+  end
+end

data/lib/angus/response.rb

@@ -0,0 +1,53 @@
+module Angus
+  class Response < Rack::Response
+    def initialize(*)
+      super
+      headers['Content-Type'] ||= 'text/html'
+    end
+
+    def body=(value)
+      value = value.body while Rack::Response === value
+      @body = String === value ? [value.to_str] : value
+    end
+
+    def each
+      block_given? ? super : enum_for(:each)
+    end
+
+    def finish
+      result = body
+
+      if drop_content_info?
+        headers.delete "Content-Length"
+        headers.delete "Content-Type"
+      end
+
+      if drop_body?
+        close
+        result = []
+      end
+
+      if calculate_content_length?
+        # if some other code has already set Content-Length, don't muck with it
+        # currently, this would be the static file-handler
+        headers["Content-Length"] = body.inject(0) { |l, p| l + Rack::Utils.bytesize(p) }.to_s
+      end
+
+      [status.to_i, headers, result]
+    end
+
+    private
+
+    def calculate_content_length?
+      headers["Content-Type"] and not headers["Content-Length"] and Array === body
+    end
+
+    def drop_content_info?
+      status.to_i / 100 == 1 or drop_body?
+    end
+
+    def drop_body?
+      [204, 205, 304].include?(status.to_i)
+    end
+  end
+end

data/lib/angus/responses.rb

@@ -0,0 +1,232 @@
+require 'angus/sdoc'
+
+module Angus
+  module Responses
+
+    HTTP_STATUS_CODE_OK = 200
+
+    HTTP_STATUS_CODE_FORBIDDEN = 403
+    HTTP_STATUS_CODE_NOT_FOUND = 404
+    HTTP_STATUS_CODE_CONFLICT = 409
+    HTTP_STATUS_CODE_UNPROCESSABLE_ENTITY = 422
+
+    HTTP_STATUS_CODE_INTERNAL_SERVER_ERROR = 500
+
+    # Returns a suitable HTTP status code for the given error
+    #
+    # If error param responds to #errors, then #{HTTP_STATUS_CODE_CONFLICT} will be returned.
+    #
+    # If error param responds to #error_key, then the status_code associated
+    #  with the message will be returned.
+    #
+    # @param [#errors, #error_key] error An error object
+    #
+    # @return [Integer] HTTP status code
+    def get_error_status_code(error)
+      if error.respond_to?(:errors)
+        return HTTP_STATUS_CODE_CONFLICT
+      end
+
+      message = get_error_definition(error)
+
+      if message
+        message.status_code
+      else
+        HTTP_STATUS_CODE_INTERNAL_SERVER_ERROR
+      end
+    end
+
+    # Returns the error definition.
+    #
+    # If the error does not responds to error_key nil will be returned, see EvolutionError.
+    #
+    # @param [#error_key] error An error object
+    #
+    # @return [Hash]
+    def get_error_definition(error)
+      error_key = error.class.name
+
+      get_message_definition(error_key, Angus::SDoc::Definitions::Message::ERROR_LEVEL)
+    end
+
+    def get_message_definition(key, level)
+      message = @definitions.messages.find { |name, definition|
+        name == key.to_s && definition.level.downcase == level.downcase
+      }
+
+      message.last if message
+    end
+
+    # Builds a service success response
+    #
+    # @param [Hash<Symbol, Object>] messages Elements to be sent in the response
+    # @param [Array<ResponseMessage] messages Messages to be sent in the response
+    #
+    # @return [String] JSON response
+    def build_success_response(elements = {}, messages = [])
+      elements = {
+        :status => :success,
+      }.merge(elements)
+
+      unless messages.empty?
+        elements[:messages] = messages
+      end
+
+      json(elements)
+    end
+
+    # Builds a service error response
+    def build_error_response(error)
+      error_messages = messages_from_error(error)
+      build_response(:error, *error_messages)
+    end
+
+    # Builds a ResponseMessage object
+    #
+    # @param [#to_s] key Message key
+    # @param [#to_s] level Message level
+    # @param [*Object] params Objects to be used when formatting the message description
+    #
+    # @raise [NameError] when there's no message for the given key and level
+    #
+    # @return [ResponseMessage]
+    def build_message(key, level, *params)
+      message_definition = get_message_definition(key, level)
+
+      unless message_definition
+        raise NameError.new("Could not found message with key: #{key}, level: #{level}")
+      end
+
+      description = if message_definition.text
+                      message_definition.text % params
+                    else
+                      message_definition.description
+                    end
+
+      Angus::SDoc::Definitions::Message
+
+      message = Angus::SDoc::Definitions::Message.new
+      message.key = key
+      message.level = level
+      message.description = description
+
+      message
+    end
+
+    # Builds a service success response
+    def build_warning_response(error)
+      error_messages = messages_from_error(error, :warning)
+      build_response(:success, *error_messages)
+    end
+
+    # Builds a success response with the received data
+    #
+    # @param [Hash] data the hash to be returned in the response
+    # @param [Array] attributes the attributes that will be returned
+    # @param [Message, Symbol, String] messages A list of messages, or message keys
+    def build_data_response(data, attributes, messages = [])
+      marshalled_data = Angus::Marshalling.marshal_object(data, attributes)
+
+      messages = build_messages(Angus::SDoc::Definitions::Message::INFO_LEVEL, messages)
+
+      build_success_response(marshalled_data, messages)
+    end
+
+    # Builds a success response with no elements
+    #
+    # The response would include the following:
+    #  - status
+    #  - messages
+    #
+    # @param [Array<ResponseMessage>, Array<Symbol>] messages Message to be included in the response
+    #
+    # @return [String] JSON response
+    def build_no_data_response(messages = [])
+      messages = build_messages(Angus::SDoc::Definitions::Message::INFO_LEVEL, messages)
+
+      build_success_response({}, messages)
+    end
+
+    # Builds a list of messages with the following level
+    #
+    # ResponseMessage objects contained in messages param won't be modified, this method
+    #  only creates ResponseMessage for each Symbol in messages array
+    #
+    # @param [#to_s] level Messages level
+    # @param [Array<ResponseMessage>, Array<Symbol>] messages
+    #
+    # @raise (see #build_message)
+    #
+    # @return [Array<ResponseMessage>]
+    def build_messages(level, messages)
+      (messages || []).map do |message|
+        if message.kind_of?(Angus::SDoc::Definitions::Message)
+          message
+        else
+          build_message(message, level)
+        end
+      end
+    end
+
+    # Sets the content_type to json and serialize +element+ as json
+    def json(element)
+      #content_type :json
+      JSON(element, :ascii_only => true)
+    end
+
+    private
+    # Returns an array of messages errors to be sent in an operation response
+    #
+    # If {error} respond_to? :errors then the method returns one error message
+    #   for each one.
+    #
+    # Each message returned is a hash with:
+    #  - level
+    #  - key
+    #  - description
+    #
+    # @param [Exception] error The error to be returned
+    #
+    # @return [Array] an array of messages
+    def messages_from_error(error, level = :error)
+      messages = []
+
+      if error.respond_to?(:errors)
+        error.errors.each do |key, description|
+          messages << {:level => level, :key => key, :dsc => description}
+        end
+      elsif error.respond_to?(:error_key)
+        messages << {:level => level, :key => error.error_key,
+                     :dsc => error_message(error)}
+      else
+        messages << {:level => level, :key => error.class.name, :dsc => error.message}
+      end
+
+      messages
+    end
+
+    # Returns the message for an error.
+    #
+    # It first tries to get the message from text attribute of the error definition
+    #   if no definition is found or if the text attribute is blank it the returns the error
+    #   message attribute.
+    #
+    # @param [Exception] error The error to get the message for.
+    #
+    # @return [String] the error message.
+    def error_message(error)
+      error_definition = get_error_definition(error)
+
+      if error_definition && !error_definition.text.blank?
+        error_definition.text
+      else
+        error.message
+      end
+    end
+
+    def build_response(status, *messages)
+      json(:status => status, :messages => messages)
+    end
+
+  end
+end