dialers 0.1.0

data/dialers.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "dialers/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "dialers"
+  spec.version       = Dialers::VERSION
+  spec.authors       = ["juliogarciag"]
+  spec.email         = ["julioggonz@gmail.com"]
+
+  spec.summary       = "Api Wrappers for Ruby"
+  spec.description   = "Api Wrappers for Ruby"
+  spec.homepage      = "https://github.com/platanus/dialers"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "faraday", "~> 0.9"
+  spec.add_dependency "faraday_middleware", "~> 0.9"
+  spec.add_dependency "faraday-conductivity", "~> 0.3"
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.3"
+  spec.add_development_dependency "pry", "~> 0.10"
+  spec.add_development_dependency "guard", "~> 2.13"
+  spec.add_development_dependency "guard-rspec", "~> 4.6"
+  spec.add_development_dependency "rspec-nc", "~> 0.2"
+  spec.add_development_dependency "rspec-legacy_formatters", "~> 1.0"
+  spec.add_development_dependency "simple_oauth", "~> 0.3"
+  spec.add_development_dependency "patron", "~> 0.4"
+end

data/examples/github/api.rb

@@ -0,0 +1,19 @@
+require_relative "./api_caller"
+
+module Github
+  class Repository
+    attr_accessor :id, :name, :description, :language
+
+    def to_s
+      "#{id} : #{name} : #{description} : #{language}"
+    end
+  end
+
+  class Api < Dialers::Wrapper
+    api_caller { ApiCaller.new }
+
+    def user_repos(username)
+      api_caller.get("users/#{username}/repos").transform_to_many(Repository)
+    end
+  end
+end

data/examples/github/api_caller.rb

@@ -0,0 +1,27 @@
+require "dialers"
+
+module Github
+  class ApiCaller < Dialers::Caller
+    TIMEOUT_IN_SECONDS = 5
+    GITHUB_API_URL = "https://api.github.com"
+
+    setup_api(url: GITHUB_API_URL) do |faraday|
+      faraday.request :json
+      faraday.request :request_headers, accept: "application/vnd.github.v3+json"
+      faraday.response :json
+      faraday.adapter :net_http
+      faraday.options.timeout = TIMEOUT_IN_SECONDS
+      faraday.options.open_timeout = TIMEOUT_IN_SECONDS
+    end
+
+    short_circuits.add(
+      if: -> (response) { Dialers::Status.new(response.status).server_error? },
+      do: -> (response) { fail Dialers::ServerError.new(response) }
+    )
+
+    short_circuits.add(
+      if: -> (response) { Dialers::Status.new(response.status).is?(404) },
+      do: -> (response) { fail Dialers::NotFoundError.new(response) }
+    )
+  end
+end

data/examples/github/usage.rb

@@ -0,0 +1,12 @@
+require_relative "./api"
+
+username = ARGV.first
+github = Github::Api.new
+
+begin
+  github.user_repos(username).each do |repository|
+    puts repository.to_s
+  end
+rescue Dialers::NotFoundError
+  puts "Not Found Username #{username}."
+end

data/examples/twitter/api.rb

@@ -0,0 +1,27 @@
+require_relative "./api_caller"
+
+module Twitter
+  class Tweet
+    attr_accessor :created_at, :text
+  end
+
+  class User
+    attr_accessor :screen_name, :profile_image_url
+  end
+
+  class Api < Dialers::Wrapper
+    api_caller { ApiCaller.new }
+
+    def get_user_timeline
+      api_caller.get("statuses/user_timeline.json").transform_to_many(Tweet)
+    end
+
+    def get_user
+      api_caller.get("account/verify_credentials.json").transform_to_one(User)
+    end
+
+    def search(query)
+      api_caller.get("search/tweets.json", q: query).transform_to_many(Tweet, root: "statuses")
+    end
+  end
+end

data/examples/twitter/api_caller.rb

@@ -0,0 +1,43 @@
+require "dialers"
+
+module Twitter
+  class ApiCaller < Dialers::Caller
+    BASE_URL = "https://api.twitter.com/1.1/"
+    CONSUMER_KEY = ENV["TWITTER_CONSUMER_KEY"]
+    CONSUMER_SECRET = ENV["TWITTER_CONSUMER_SECRET"]
+    TOKEN = ENV["TWITTER_TOKEN"]
+    TOKEN_SECRET = ENV["TWITTER_TOKEN_SECRET"]
+
+    setup_api(url: BASE_URL, ssl: { verify: true }) do |faraday|
+      faraday.request :json
+      faraday.request :oauth,
+        consumer_key: CONSUMER_KEY,
+        consumer_secret: CONSUMER_SECRET,
+        token: TOKEN,
+        token_secret: TOKEN_SECRET
+      faraday.request :request_headers, accept: "*/*"
+      faraday.response :json
+      faraday.adapter :patron
+    end
+
+    short_circuits.add(
+      if: -> (response) { Dialers::Status.new(response.status).server_error? },
+      do: -> (response) { fail Dialers::ServerError.new(response) }
+    )
+
+    short_circuits.add(
+      if: -> (response) { Dialers::Status.new(response.status).is?(400) },
+      do: -> (response) { fail Dialers::ResponseError.new(response) }
+    )
+
+    short_circuits.add(
+      if: -> (response) { Dialers::Status.new(response.status).is?(401) },
+      do: -> (response) { fail Dialers::UnauthorizedError.new(response) }
+    )
+
+    short_circuits.add(
+      if: -> (response) { Dialers::Status.new(response.status).is?(404) },
+      do: -> (response) { fail Dialers::NotFoundError.new(response) }
+    )
+  end
+end

data/examples/twitter/usage.rb

@@ -0,0 +1,16 @@
+require_relative "./api"
+require "simple_oauth"
+
+api = Twitter::Api.new
+keyword = ARGV.first
+
+ruby_tweet = api.get_user_timeline.find do |tweet|
+  tweet.text.include?(keyword)
+end || api.search(keyword).first
+
+if ruby_tweet
+  puts "Gotcha!"
+  puts ruby_tweet.text
+else
+  puts "We searched in your timeline and in the world for #{keyword} and we didn't find nothing :("
+end

data/lib/dialers.rb

@@ -0,0 +1,13 @@
+require "dialers/version"
+require "faraday"
+require "faraday_middleware"
+require "faraday/conductivity"
+require "dialers/assign_attributes"
+require "dialers/errors"
+require "dialers/request_options"
+require "dialers/transformable"
+require "dialers/short_circuit"
+require "dialers/short_circuits_collection"
+require "dialers/status"
+require "dialers/caller"
+require "dialers/wrapper"

data/lib/dialers/assign_attributes.rb

@@ -0,0 +1,20 @@
+module Dialers
+  module AssignAttributes
+    # Assign the attributes hash into the object calling attribute writers of the object
+    # if the object can respond to them.
+    #
+    # @param object [Object] any object with some or no attribute writers.
+    # @param attributes [Hash<Symbol, Object>] the attributes using symbols and objects.
+    #
+    # @return [Object] the same object passed as parameter.
+    def self.call(object, attributes)
+      attributes.each do |key, value|
+        writer = "#{key}=".to_sym
+        if object.respond_to?(writer)
+          object.public_send(writer, value)
+        end
+      end
+      object
+    end
+  end
+end

data/lib/dialers/caller.rb

@@ -0,0 +1,128 @@
+module Dialers
+  class Caller
+    IDEMPOTENT_AND_SAFE_METHODS = [:get, :head, :options]
+    MAX_RETRIES = 5
+
+    class << self
+      # Setups a connection using {https://github.com/lostisland/faraday Faraday}.
+      #
+      # @param [Array] Arguments to pass to the faraday connection.
+      # @yield A block to pass to the faraday connection
+      #
+      # @return [Faraday::Connection] a connection
+      def setup_api(*args, &block)
+        api = Faraday.new(*args) { |faraday| block.call(faraday) }
+        const_set "API", api
+      end
+
+      # @return [ShortCircuitsCollection] a collection of short circuits that can stop the process.
+      def short_circuits
+        @short_circuits ||= Dialers::ShortCircuitsCollection.new
+      end
+
+      private
+
+      # @!macro [attach] query_holder_request_method
+      #   @method $1
+      #   Make a $1 request.
+      #
+      #   @param url [String] The path for the request.
+      #   @param params [Hash] The query params to attach to the url.
+      #   @param headers [Hash] The headers.
+      #
+      #   @return [Transformable] a transformable object
+      def query_holder_request_method(http_method)
+        define_method(http_method) do |url, params = {}, headers = {}|
+          options = RequestOptions.new
+          options.url = url
+          options.http_method = http_method
+          options.query_params = params
+          options.headers = headers
+
+          transform(http_call(options))
+        end
+      end
+
+      # @!macro [attach] body_holder_request_method
+      #   @method $1
+      #   Make a $1 request.
+      #
+      #   @param url [String] The path for the request.
+      #   @param payload [Hash] The request body.
+      #   @param headers [Hash] The headers.
+      #
+      #   @return [Transformable] a transformable object
+      def body_holder_request_method(http_method)
+        define_method(http_method) do |url, payload = {}, headers = {}|
+          options = RequestOptions.new
+          options.url = url
+          options.http_method = http_method
+          options.payload = payload
+          options.headers = headers
+
+          transform(http_call(options))
+        end
+      end
+    end
+
+    public
+
+    query_holder_request_method :get
+    query_holder_request_method :head
+    query_holder_request_method :delete
+    query_holder_request_method :options
+    body_holder_request_method :post
+    body_holder_request_method :put
+    body_holder_request_method :patch
+
+    private
+
+    def transform(response)
+      self.class.short_circuits.search_for_stops(response)
+      Dialers::Transformable.new(response)
+    end
+
+    def http_call(request_options, current_retries = 0)
+      call_api(request_options)
+    rescue Faraday::ParsingError => _exception
+      raise Dialers::ParsingError.new(exception)
+    rescue Faraday::ConnectionFailed => exception
+      raise Dialers::UnreachableError.new(exception)
+    rescue Faraday::TimeoutError => exception
+      retry_call(request_options, exception, current_retries)
+    end
+
+    def retry_call(request_options, exception, current_retries)
+      if idempotent_and_safe_method?(request_options.http_method) && current_retries <= MAX_RETRIES
+        http_call(request_options, current_retries + 1)
+      else
+        fail Dialers::UnreachableError.new(exception)
+      end
+    end
+
+    def call_api(request_options)
+      api.public_send(
+        request_options.http_method, request_options.url, request_options.query_params || {}
+      ) do |request|
+        request.body = request_options.payload
+        (request_options.headers || {}).each do |key, value|
+          request.headers[key] = value
+        end
+      end
+    end
+
+    def api
+      @api ||= get_api
+    end
+
+    def get_api
+      self.class::API
+    rescue NameError
+      raise Dialers::InexistentApiError.new(self.class)
+    end
+
+    def idempotent_and_safe_method?(http_method)
+      IDEMPOTENT_AND_SAFE_METHODS.include?(http_method)
+    end
+  end
+end

data/lib/dialers/errors.rb

@@ -0,0 +1,77 @@
+module Dialers
+  class ErrorAsErrorProxy < StandardError
+    def initialize(error = nil)
+      self.error = error
+    end
+
+    def message
+      error ? error.message : super
+    end
+
+    private
+
+    attr_accessor :error
+  end
+
+  class ErrorWithResponse < StandardError
+    def initialize(response = nil)
+      self.response = response
+    end
+
+    def message
+      if response.nil?
+        super
+      else
+        "\n
+        STATUS: #{response.status}
+        URL: #{response.env.url}
+        REQUEST HEADERS: #{response.env.request_headers}
+        HEADERS: #{response.env.response_headers}
+        BODY: #{response.body}\n\n"
+      end
+    end
+
+    private
+
+    attr_accessor :response
+  end
+
+  class UnreachableError < ErrorAsErrorProxy
+  end
+
+  class ParsingError < ErrorAsErrorProxy
+  end
+
+  class ResponseError < ErrorWithResponse
+  end
+
+  class InexistentApiError < StandardError
+    def initialize(searched_class)
+      self.searched_class = searched_class
+    end
+
+    def message
+      "\n\nSEARCHED CLASS: #{searched_class}\n\n"
+    end
+
+    private
+
+    attr_accessor :searched_class
+  end
+
+  class ServerError < ErrorWithResponse
+  end
+
+  class NotFoundError < ErrorWithResponse
+  end
+
+  class UnauthorizedError < ErrorWithResponse
+  end
+
+  class ImpossibleTranformationError < ErrorWithResponse
+  end
+
+  ERRORS = [
+    UnreachableError, ParsingError, ResponseError, InexistentApiError
+  ]
+end

data/lib/dialers/request_options.rb

@@ -0,0 +1,5 @@
+module Dialers
+  class RequestOptions
+    attr_accessor :url, :http_method, :query_params, :payload, :headers
+  end
+end

data/lib/dialers/short_circuit.rb

@@ -0,0 +1,18 @@
+module Dialers
+  class ShortCircuit
+    def initialize(condition, action)
+      self.condition = condition
+      self.action = action
+    end
+
+    def can_stop?(response)
+      condition.call(response)
+    end
+
+    def stop(response)
+      action.call(response)
+    end
+
+    attr_accessor :condition, :action
+  end
+end