callapi 0.8

data/lib/callapi/call/request/http/log_helper.rb

@@ -0,0 +1,41 @@
+require 'colorize'
+
+module Callapi::Call::Request::Http::LogHelper
+  def with_logging
+    return yield if Callapi::Config.log_level == :none
+
+    t0 = Time.now
+    string = ''
+    string << uri.host
+    string << ":#{uri.port}" if uri.port
+
+    puts "Sending request to #{string}".center(80, '-').colorize(:white).on_blue
+    'PATH:    '.tap do |string|
+      string << "#{request_method.to_s.upcase} "
+      string << "#{uri.path}"
+      puts string.colorize(:magenta)
+    end
+    'HEADERS: '.tap do |string|
+      string << "#{headers}"
+      puts string.colorize(:cyan)
+    end
+    'PARAMS:  '.tap do |string|
+      string << "#{params}"
+      puts string.colorize(:green)
+    end
+
+    response = yield
+
+    response.tap do |response|
+      "RESPONSE: [#{response.code}]\n".tap do |string|
+        string << (response.body.nil? ? '[EMPTY BODY]' : response.body)
+        puts string.colorize(:light_blue)
+      end
+
+      puts "request send (#{(Time.now - t0).round(3)} sec)".center(80, '-').colorize(:white).on_blue
+    end
+  rescue StandardError => e
+    puts "Exception occured, skipping logs".center(80, '-').colorize(:red).on_yellow
+    raise e
+  end
+end

data/lib/callapi/call/request/mock.rb

@@ -0,0 +1,29 @@
+class Callapi::Call::Request::Mock < Callapi::Call::Request::Base
+  extend Memoist
+  #TODO: should not be hardcoded
+  MOCK_FORMAT = '.json'
+
+  def response
+    OpenStruct.new(body: body, code: code)
+  end
+
+  def code
+    '200'
+  end
+
+  def body
+    File.read(file_path)  # add #with_logging
+  rescue Errno::ENOENT
+    raise Callapi::CouldNotFoundMockRequestFileError.new(file_path)
+  end
+
+  private
+
+  def file_path
+    File.join(Callapi::Config.mocks_directory, @context.request_method.to_s, file_name + MOCK_FORMAT)
+  end
+
+  def file_name
+    @context.request_path
+  end
+end

data/lib/callapi/call/request_metadata.rb

@@ -0,0 +1,57 @@
+require 'active_support/core_ext/string/inflections'
+
+class Callapi::Call::RequestMetadata < Struct.new(:context)
+  extend Memoist
+
+  HTTP_METHODS = %w(GET POST PUT PATCH DELETE)
+
+  def request_method
+    http_method = namespace_with_http_method
+    raise Callapi::UnknownHttpMethodError unless http_method
+    http_method.downcase.to_sym
+  end
+
+  def request_path
+    request_path = request_path_without_replaced_param_keys
+    param_keys_to_replace.each do |param_key|
+      param_value = context.params[param_key.to_sym] || raise(Callapi::MissingParamError.new(request_path, param_keys_to_replace, missing_keys))
+      request_path.sub!(param_key + '_param', param_value.to_s)
+    end
+    request_path
+  end
+  memoize :request_path
+
+  private
+
+  def param_keys_to_replace
+    request_path_without_replaced_param_keys.scan(/(\w+)_param/).map(&:first)
+  end
+
+  def request_path_without_replaced_param_keys
+    '/' + call_name.underscore
+  end
+  memoize :request_path_without_replaced_param_keys
+
+  def missing_keys
+    (param_keys_to_replace.map(&:to_sym) - context.params.keys).map { |key| ":#{key}" }
+  end
+
+  def namespaces_after_http_method
+    namespaces[namespaces.index(namespace_with_http_method) + 1 .. namespaces.size]
+  end
+  memoize :namespaces_after_http_method
+
+  def namespace_with_http_method
+    namespaces.detect{ |namespace| HTTP_METHODS.include?(namespace.upcase) } || raise(Callapi::UnknownHttpMethodError)
+  end
+  memoize :namespace_with_http_method
+
+  def call_name
+    namespaces_after_http_method.join('::')
+  end
+
+  def namespaces
+    context.class.to_s.split('::')
+  end
+  memoize :namespaces
+end

data/lib/callapi/call/response.rb

@@ -0,0 +1,54 @@
+# Change it to Callapi::Call::Parser::Base
+class Callapi::Call::Parser
+  require_relative 'response/plain'
+  require_relative 'response/json'
+  require_relative 'response/json/as_object'
+
+  extend Memoist
+  extend Forwardable
+
+  def_delegators :@response, :body, :code
+
+  def initialize(response)
+    @response = response
+  end
+
+  def data
+    raise_error unless ok?
+    return nil if no_content?
+
+    parse
+  end
+  memoize :data
+
+  def status
+    code.to_i
+  end
+  memoize :status
+
+  private
+
+  def parse
+    raise NotImplementedError
+  end
+
+  def ok?
+    status < 300
+  end
+  memoize :ok?
+
+  def no_content?
+    return true if body.nil?
+    body.strip.empty?
+  end
+  memoize :no_content?
+
+  def raise_error
+    error_class = Callapi::Errors.error_by_status(status)
+    raise error_class.new(status, error_message)
+  end
+
+  def error_message
+    "response body: \"#{body}\""
+  end
+end

data/lib/callapi/call/response/json.rb

@@ -0,0 +1,18 @@
+require 'multi_json'
+
+class Callapi::Call::Parser::Json < Callapi::Call::Parser
+  def parse
+    to_hash
+  end
+
+  private
+
+  def to_hash
+    @to_hash ||= MultiJson.load(body)
+  end
+  #TODO: remove Memoist
+
+  def error_message
+    to_hash['error_message'] rescue super
+  end
+end

data/lib/callapi/call/response/json/as_object.rb

@@ -0,0 +1,49 @@
+require_relative '../../../../ext/deep_struct'
+
+class Callapi::Call::Parser::Json::AsObject < Callapi::Call::Parser::Json
+  def parse
+    object.tap do |struct|
+      append_data_excluded_from_parsing(struct)
+    end
+  end
+
+  def self.keys_excluded_from_parsing
+    @keys_excluded_from_parsing ||= []
+  end
+
+  def self.keys_excluded_from_parsing=(keys_excluded_from_parsing)
+    @keys_excluded_from_parsing = keys_excluded_from_parsing
+  end
+
+  private
+
+  def object
+    if data_to_parse.is_a?(Array)
+      data_to_parse.map { |item| DeepStruct.new(item) }
+    else
+      DeepStruct.new(data_to_parse)
+    end
+  end
+
+  def data_to_parse
+    keys_excluded_from_parsing = self.class.keys_excluded_from_parsing
+    to_hash.dup.delete_if { |key, value| keys_excluded_from_parsing.include? key }
+  end
+
+  def data_excluded_from_parsing
+    @data_excluded_from_parsing ||= {}.tap do |hash|
+      self.class.keys_excluded_from_parsing.each do |key|
+        hash[key] = to_hash[key]
+      end
+    end
+  end
+
+  def append_data_excluded_from_parsing(struct)
+    return if struct.is_a?(Array)
+    struct.tap do |struct|
+      self.class.keys_excluded_from_parsing.each do |key|
+        struct.send("#{key}=", data_excluded_from_parsing[key])
+      end
+    end
+  end
+end

data/lib/callapi/call/response/plain.rb

@@ -0,0 +1,5 @@
+class Callapi::Call::Parser::Plain < Callapi::Call::Parser
+  def parse
+    body
+  end
+end

data/lib/callapi/config.rb

@@ -0,0 +1,56 @@
+class Callapi::Config
+  DEFAULT_REQUEST_STRATEGY = 'Callapi::Call::Request::Api'
+  DEFAULT_RESPONSE_PARSER  = 'Callapi::Call::Parser::Json'
+  DEFAULT_MOCKS_DIRECTORY  = 'mocked_calls'
+  DEFAULT_PATH_PREFIX = ''
+
+  class << self
+    attr_reader :mocks_directory
+    attr_accessor :api_host
+    attr_writer :api_path_prefix, :default_response_parser, :default_request_strategy
+
+    def configure
+      yield self if block_given?
+    end
+
+    def default_request_strategy
+      @default_request_strategy ||= DEFAULT_REQUEST_STRATEGY.constantize
+    end
+
+    def api_path_prefix
+      @api_path_prefix ||= DEFAULT_PATH_PREFIX
+    end
+
+    def default_response_parser
+      @default_response_parser ||= DEFAULT_RESPONSE_PARSER.constantize
+    end
+
+    def mocks_directory=(mocks_directory)
+      [].tap do |paths|
+        paths << Rails.root if defined?(Rails)
+        paths << mocks_directory
+        paths << '/'
+        @mocks_directory = File.join(paths)
+      end
+    end
+
+    def mocks_directory
+      return @mocks_directory if @mocks_directory
+
+      [].tap do |paths|
+        paths << Rails.root if defined?(Rails)
+        paths << DEFAULT_MOCKS_DIRECTORY
+        paths << '/'
+        @mocks_directory = File.join(paths)
+      end
+    end
+
+    def log_level=(log_level)
+      @log_level = log_level
+    end
+
+    def log_level
+      @log_level ||= :debug
+    end
+  end
+end

data/lib/callapi/errors.rb

@@ -0,0 +1,58 @@
+class Callapi::Errors < StandardError
+  STATUS_TO_ERROR_CLASS = {
+    401 => 'NotAuthorizedError',
+    404 => 'NotFoundError'
+  }
+  def self.error_by_status(status)
+    error_class_name = STATUS_TO_ERROR_CLASS[status]
+    unless error_class_name
+      error_class_name = case status
+        when 500..599 then 'ServerError'
+        when 400..499 then 'ClientError'
+        when 300..399 then 'RedirectionError'
+        else
+          'ServerError'
+      end
+    end
+    "Callapi::#{error_class_name}".constantize
+  end
+end
+
+class Callapi::ApiError < StandardError
+  def initialize(status, message)
+    super "#{status}: #{message}"
+  end
+end
+
+class Callapi::ServerError < Callapi::ApiError; end
+class Callapi::ClientError < Callapi::ApiError; end
+class Callapi::RedirectionError < Callapi::ApiError; end
+class Callapi::NotAuthorizedError < Callapi::ApiError; end
+class Callapi::NotFoundError < Callapi::ApiError; end
+
+class Callapi::UnknownHttpMethodError < StandardError
+  def initialize
+    super 'Could not retrieve HTTP method from Call class name'
+  end
+end
+
+class Callapi::ApiHostNotSetError < StandardError
+  def initialize
+    super 'Set API host with Callapi::Config.api_host = "http://yourapi.host.com"'
+  end
+end
+
+class Callapi::CouldNotFoundMockRequestFileError < StandardError
+  def initialize(file_path)
+    super "Expected \"#{file_path}\""
+  end
+end
+
+class Callapi::MissingParamError < StandardError
+  def initialize(request_path, param_keys_to_replace, missing_keys)
+    param_keys_to_replace.each do |param_key|
+      request_path.sub!(param_key + '_param', ':' + param_key)
+    end
+    super "could not found: #{missing_keys.join(', ')} for \"#{request_path}\""
+  end
+end

data/lib/callapi/routes.rb

@@ -0,0 +1,131 @@
+require 'active_support/core_ext/string'
+
+class Callapi::Routes
+  require_relative 'routes/metadata'
+
+  class << self
+    def draw(&block)
+      build_http_method_namespaces
+
+      instance_eval &block
+
+      create_classes
+    end
+
+    def get(*args)
+      save_route(Callapi::Get, *args)
+    end
+
+    def post(*args)
+      save_route(Callapi::Post, *args)
+    end
+
+    def put(*args)
+      save_route(Callapi::Put, *args)
+    end
+
+    def delete(*args)
+      save_route(Callapi::Delete, *args)
+    end
+
+    def patch(*args)
+      save_route(Callapi::Patch, *args)
+    end
+
+    def namespace(*args)
+      add_namespace(args.shift)
+      yield
+      remove_namespace
+    end
+
+    private
+
+    def save_route(http_method_namespace, *args)
+      Callapi::Routes::Metadata.new(http_method_namespace, *args)
+    end
+
+    def create_classes
+      classes_metadata.each do |class_metadata|
+        classes = class_metadata.class_name.split('::')
+        classes = classes[2..classes.size]
+
+        classes.inject(class_metadata.http_method_namespace) do |namespace, class_name|
+          if namespace.constants.include?(class_name.to_sym)
+            namespace.const_get(class_name)
+          else
+            full_class_name = "#{namespace}::#{class_name}"
+            if call_classes_names.include?(full_class_name)
+              namespace.const_set(class_name, Class.new(Callapi::Call::Base)).tap do |klass|
+                set_call_class_options(klass, class_metadata.class_options) if class_metadata.class_options
+                create_helper_method(klass, class_metadata)
+              end
+            else
+              namespace.const_set(class_name, Class.new)
+            end
+          end
+        end
+      end
+    end
+
+    def create_helper_method(klass, class_metadata)
+      http_method = class_metadata.http_method_namespace.to_s.split('::').last
+      call_name_with_namespaces = class_metadata.call_name_with_namespaces.map do |class_name|
+        class_name.scan(/(::)?((\w)+)Param/).map { |matched_groups| matched_groups[1] }.compact.each do |pattern|
+          class_name.sub!(pattern, "By#{pattern}")
+          class_name.sub!('Param', '')
+        end
+        class_name
+      end
+      method_name = [http_method, call_name_with_namespaces, 'call'].join('_')
+      method_name = method_name.underscore.gsub('/', '_')
+      Object.send(:define_method, method_name) do |*args|
+        klass.new(*args)
+      end
+    end
+
+    def set_call_class_options(klass, options)
+      klass.strategy = options[:strategy] if options[:strategy]
+      klass.response_parser = options[:parser] if options[:parser]
+    end
+
+    def namespaces
+      @namespaces ||= []
+    end
+
+    def add_namespace(namespace)
+      namespaces << namespace.to_s
+    end
+
+    def remove_namespace
+      namespaces.pop
+    end
+
+    def build_http_method_namespaces
+      @build_http_method_namespaces ||= http_methods.each do |http_method|
+        Callapi.const_set(http_method.to_s.camelize, Module.new)
+      end
+    end
+
+    def http_methods
+      Callapi::Call::Request::Http::HTTP_METHOD_TO_REQUEST_CLASS.keys
+    end
+
+    def save_class(class_metadata)
+      classes_metadata << class_metadata unless classes_metadata.include?(class_metadata)
+      @call_classes = nil
+      @call_classes_names = nil
+    end
+
+    def classes_metadata
+      @classes_metadata ||= []
+    end
+
+    def call_classes_metadata
+      @call_classes ||= classes_metadata.select(&:call_class)
+    end
+
+    def call_classes_names
+      @call_classes_names ||= call_classes_metadata.map(&:class_name).uniq
+    end
+  end
+end