api_struct 0.1.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/circle.yml

@@ -0,0 +1,3 @@
+machine:
+  ruby:
+    version: 2.4.2

data/lib/api_struct.rb

@@ -0,0 +1,19 @@
+require 'http'
+require 'dry-monads'
+require 'dry-configurable'
+require 'json'
+require 'hashie'
+
+require_relative 'api_struct/version'
+require_relative 'api_struct/settings'
+require_relative 'api_struct/concerns/underscore'
+require_relative 'api_struct/extensions/api_client'
+require_relative 'api_struct/extensions/dry_monads'
+require_relative 'api_struct/errors/client'
+require_relative 'api_struct/client'
+require_relative 'api_struct/collection'
+require_relative 'api_struct/entity'
+require_relative 'api_struct/errors/entity'
+
+module ApiStruct
+end

data/lib/api_struct/client.rb

@@ -0,0 +1,86 @@
+module ApiStruct
+  class Client
+    DEFAULT_HEADERS = { 
+      'Accept': 'application/json',
+      'Content-Type': 'application/json' 
+    }
+    URL_OPTION_REGEXP = /\/:([a-z_]+)/.freeze
+
+    attr_reader :client
+
+    def self.method_missing(method_name, *args, &block)
+      endpoints = Settings.config.endpoints
+      return super unless endpoints.keys.include?(method_name)
+
+      define_method(:api_root) { endpoints[method_name][:root] }
+      define_method(:default_path) { first_arg(args) }
+
+      define_method(:headers) do
+        endpoints[method_name][:headers]
+      end
+    end
+
+    HTTP_METHODS = %i[get post patch put delete].freeze
+
+    HTTP_METHODS.each do |http_method|
+      define_method http_method do |*args, **options|
+        begin
+          wrap client.send(http_method, build_url(args, options), options)
+        rescue HTTP::ConnectionError => e
+          failure(body: e.message, status: :not_connected)
+        end
+      end
+    end
+
+    def initialize
+      api_settings_exist
+      client_headers = headers || DEFAULT_HEADERS
+      @client = HTTP::Client.new(headers: client_headers)
+    end
+
+    private
+
+    def wrap(response)
+      response.status < 300 ? success(response) : failure(response)
+    end
+
+    def success(response)
+      body = response.body.to_s
+      result = !body.empty? ? JSON.parse(body, symbolize_names: true) : nil
+      Dry::Monads.Right(result)
+    end
+
+    def failure(response)
+      result = ApiStruct::Errors::Client.new(response)
+      Dry::Monads.Left(result)
+    end
+
+    def first_arg(args)
+      args.first.to_s
+    end
+
+    def build_url(args, options)
+      suffix = to_path(args)
+      prefix = to_path(options.delete(:prefix))
+      path = to_path(options.delete(:path) || default_path)
+
+      replace_optional_params(to_path(api_root, prefix, path, suffix), options)
+    end
+
+    def to_path(*args)
+      Array(args).reject { |o| o.respond_to?(:empty?) ? o.empty? : !o }.join('/')
+    end
+
+    def replace_optional_params(url, options)
+      url.gsub(URL_OPTION_REGEXP) do
+        value = options.delete($1.to_sym)
+        value ? "/#{value}" : ''
+      end
+    end
+
+    def api_settings_exist
+      return if respond_to?(:api_root)
+      raise RuntimeError, "\nSet api configuration for #{self.class}."
+    end
+  end
+end

data/lib/api_struct/collection.rb

@@ -0,0 +1,19 @@
+module ApiStruct
+  class Collection < SimpleDelegator
+    attr_reader :collection
+
+    def initialize(collection, entity_klass)
+      raise EntityError, 'Collection must be a Array' unless collection.is_a? Array
+      @collection = collection.map { |item| entity_klass.convert_to_entity(item) }
+      __setobj__(@collection)
+    end
+
+    def success?
+      true
+    end
+
+    def failure?
+      false
+    end
+  end
+end

data/lib/api_struct/concerns/underscore.rb

@@ -0,0 +1,11 @@
+module Concerns
+  module Underscore
+    def underscore(camel_cased_word)
+      camel_cased_word.gsub(/::/, '/')
+        .gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2')
+        .gsub(/([a-z\d])([A-Z])/,'\1_\2')
+        .tr("-", "_")
+        .downcase
+    end
+  end
+end

data/lib/api_struct/entity.rb

@@ -0,0 +1,84 @@
+module ApiStruct
+  class Entity < SimpleDelegator
+    extend Extensions::DryMonads
+    extend Extensions::ApiClient
+
+    class << self
+      def entity_attributes
+        @entity_attributes ||= []
+      end
+
+      def attr_entity(*attrs, &block)
+        entity_attributes.concat attrs
+
+        attrs.each do |attr|
+          define_entity_attribute_getter(attr, &block)
+          define_entity_attribute_setter(attr)
+        end
+      end
+
+      def has_entities(attr, options)
+        entity_attributes << attr.to_sym
+        define_method attr.to_s do
+          self.class.collection(entity[attr], options[:as])
+        end
+      end
+
+      def has_entity(attr, options)
+        entity_attributes << attr.to_sym
+        define_method attr.to_s do
+          return unless entity[attr]
+          self.class.convert_to_entity(entity[attr], options[:as])
+        end
+      end
+
+      def collection(entities, entity_type = self)
+        Collection.new(entities, entity_type)
+      end
+
+      def convert_to_entity(item, entity_type = self)
+        raise EntityError, "#{entity_type} must be inherited from base_entity" unless entity_type < ApiStruct::Entity
+        entity_type.new(item)
+      end
+
+      private
+
+      def define_entity_attribute_getter(attr)
+        define_method attr.to_s do
+          block_given? ? yield(entity[attr]) : entity[attr]
+        end
+      end
+
+      def define_entity_attribute_setter(attr)
+        define_method "#{attr}=" do |value|
+          entity[attr] = value
+        end
+      end
+    end
+
+    attr_reader :entity, :entity_status
+
+    def initialize(entity, entity_status = true)
+      raise EntityError, "#{entity} must be Hash" unless entity.is_a?(Hash)
+      @entity = Hashie::Mash.new(extract_attributes(entity))
+      @entity_status = entity_status
+      __setobj__(@entity)
+    end
+
+    def success?
+      entity_status == true
+    end
+
+    def failure?
+      entity_status == false
+    end
+
+    private
+
+    def extract_attributes(attributes)
+      attributes.select { |key, _value| self.class.entity_attributes.include?(key.to_sym) }
+    end
+  end
+
+  class EntityError < StandardError; end
+end

data/lib/api_struct/errors/client.rb

@@ -0,0 +1,41 @@
+module ApiStruct
+  module Errors
+    class Client
+      attr_reader :status, :body, :error
+
+      def initialize(response)
+        if response.is_a?(Hash)
+          @status = response[:status]
+          @body = response[:body]
+        else
+          @status = response.status
+          @body = parse_body(response.body.to_s)
+        end
+      end
+
+      def to_s
+        error
+      end
+
+      private
+
+      def error
+        return @status unless @body
+
+        if @body['errors']
+          @body['errors'].map do |k, v|
+            v.map { |e| "#{k} #{e}".strip }.join("\n")
+          end.join("\n")
+        elsif @body['error']
+          @body['error']
+        else
+          @status
+        end
+      end
+
+      def parse_body(b)
+        !b.empty? ? JSON.parse(b, symbolize_names: true) : nil
+      end
+    end
+  end
+end

data/lib/api_struct/errors/entity.rb

@@ -0,0 +1,7 @@
+module ApiStruct
+  module Errors
+    class Entity < ApiStruct::Entity
+      attr_entity :body, :status, :error
+    end
+  end
+end

data/lib/api_struct/extensions/api_client.rb

@@ -0,0 +1,43 @@
+module ApiStruct
+  module Extensions
+    module ApiClient
+      include Concerns::Underscore
+
+      REJECTED_METHODS = %i[api_root default_path headers]
+
+      attr_reader :clients
+
+      def client_service(*services, **options)
+        @clients ||= {}
+        services.each { |service| register_service(service, options) }
+      end
+
+      private
+
+      def register_service(service, options)
+        options[:prefix] = prefix_from_class(service) if options[:prefix] == true
+        options[:client_key] = options[:prefix] || :base
+
+        @clients[options[:client_key]] = service
+        allowed_methods(service, options).each { |method| define_client_method(method, options) }
+      end
+
+      def define_client_method(method, options)
+        method_name = options[:prefix] ? [options[:prefix], method].join('_') : method
+        define_singleton_method method_name do |*args|
+          from_monad(clients[options[:client_key]].new.send(method, *args))
+        end
+      end
+
+      def prefix_from_class(klass)
+        underscore(klass.name.split('::').last).to_sym
+      end
+
+      def allowed_methods(service, options)
+        return Array(options[:only]) if options[:only]
+        rejected = REJECTED_METHODS.concat(Array(options[:except]))
+        service.instance_methods(false).reject { |method| rejected.include?(method) }
+      end
+    end
+  end
+end

data/lib/api_struct/extensions/dry_monads.rb

@@ -0,0 +1,18 @@
+module ApiStruct
+  module Extensions
+    module DryMonads
+      def from_monad(monad)
+        monad.fmap { |v| from_right(v) }.or_fmap { |e| from_left(e) }.value
+      end
+
+      def from_right(value)
+        return Dry::Monads::Right(nil) if value.nil?
+        value.is_a?(Array) ? collection(value) : new(value)
+      end
+
+      def from_left(error)
+        ApiStruct::Errors::Entity.new({ status: error.status, body: error.body, error: true }, false)
+      end
+    end
+  end
+end

data/lib/api_struct/settings.rb

@@ -0,0 +1,7 @@
+module ApiStruct
+  class Settings
+    extend ::Dry::Configurable
+
+    setting :endpoints, {}
+  end
+end

data/lib/api_struct/version.rb

@@ -0,0 +1,3 @@
+module ApiStruct
+  VERSION = '0.1.0'
+end

data/spec/api_struct/client_spec.rb

@@ -0,0 +1,118 @@
+describe ApiStruct::Client do
+  extend Support::Stub
+  let(:api_root) { 'https://jsonplaceholder.typicode.com' }
+  stub_api('https://jsonplaceholder.typicode.com')
+
+  class StubClient < ApiStruct::Client
+    stub_api :posts
+
+    def show(id)
+      get(id)
+    end
+    
+    def update(id, params)
+      patch(id, json: params)
+    end
+  end
+
+  context 'build url options' do
+    context 'url options' do
+      let(:client) { StubClient.new }
+      it ' should replace /posts/users/:id to /posts/users if URL option didnt provided' do
+        url = client.send(:build_url, 'users/:id', {})
+        expect(url).to eq api_root + '/posts/users'
+      end
+
+      it ' should replace users/:id/comments to users/comments if URL option didnt provided' do
+        url = client.send(:build_url, 'users/:id/comments', {})
+        expect(url).to eq api_root + '/posts/users/comments'
+      end
+
+      it 'should replace /users/:id in prefix to /users/1' do
+        url = client.send(:build_url, [], prefix: 'users/:id', id: 1)
+        expect(url).to eq api_root + '/users/1/posts'
+      end
+
+      it 'should replace /users/:user_id/posts/:id in prefix to /users/1/posts/12' do
+        url = client.send(:build_url, ':id', prefix: 'users/:user_id', user_id: 1, id: 12)
+        expect(url).to eq api_root + '/users/1/posts/12'
+      end
+
+      it 'should replace /users/:id to /users/1' do
+        url = client.send(:build_url, 'users/:id', id: 1)
+        expect(url).to eq api_root + '/posts/users/1'
+      end
+
+      it 'user_posts without post_id' do
+        user_id = 1
+        post_id = nil
+        url = client.send(:build_url, post_id, prefix: [:users, user_id])
+        expect(url).to eq api_root + '/users/1/posts'
+      end
+
+      it 'user_posts with post_id' do
+        user_id = 1
+        post_id = 2
+        url = client.send(:build_url, post_id, prefix: [:users, user_id])
+        expect(url).to eq api_root + '/users/1/posts/2'
+      end
+    end
+    it 'should build url with prefix' do
+      VCR.use_cassette('users/1/posts') do
+        response = StubClient.new.get(prefix: 'users/:id', id: 1)
+        expect(response).to be_success
+        expect(response.value).to be_kind_of Array
+        expect(response.value).not_to be_empty
+      end
+    end
+
+    it 'should build url with custom path' do
+      VCR.use_cassette('todos') do
+        response = StubClient.new.get(path: 'todos/1')
+        expect(response).to be_success
+        expect(response.value[:id]).to eq(1)
+        expect(response.value[:title]).not_to be_empty
+        expect(response.value.keys).to include(:completed)
+      end
+    end
+
+    it 'should build url with prefix as array' do
+      VCR.use_cassette('todos') do
+        response = StubClient.new.get(path: [:todos, 1])
+        expect(response).to be_success
+        expect(response.value[:id]).to eq(1)
+        expect(response.value[:title]).not_to be_empty
+        expect(response.value.keys).to include(:completed)
+      end
+    end
+  end
+  
+  context 'GET' do
+    it 'when successful response' do
+      VCR.use_cassette('posts/show_success') do
+        response = StubClient.new.show(1)
+        expect(response).to be_success
+        expect(response.value[:id]).to eq(1)
+        expect(response.value[:title]).not_to be_empty
+      end
+    end
+
+    it 'when failed response' do
+      VCR.use_cassette('posts/show_failure') do
+        response = StubClient.new.show(101)
+        expect(response).to be_failure
+        expect(response.value.status).to eq(404)
+      end
+    end
+  end
+
+  context 'PATCH' do
+    it 'when successful response' do
+      VCR.use_cassette('posts/update_success') do
+        response = StubClient.new.update(1, title: FFaker::Name.name)
+        expect(response).to be_success
+        expect(response.value[:id]).to eq(1)
+      end
+    end
+  end
+end