thron 0.7.0

data/lib/thron/logger.rb

@@ -0,0 +1,25 @@
+require 'logger'
+require 'thron/config'
+
+module Thron
+  extend self
+
+  LOGGER_FILE   = Thron::root.join('log', 'thron.log')
+  LOGGER_LEVELS = %i[debug info warn error fatal unknown]
+
+  def logger_level
+    LOGGER_LEVELS.fetch(logger.level)
+  end
+
+  def logger(options = {})
+    file = options.fetch(:file) { LOGGER_FILE }
+    level = options.fetch(:level) { Config::logger::level }
+    @logger ||= Logger.new(file).tap do |logger|
+      logger.level = level
+    end
+  end
+
+  def reset_logger(logger = Logger.new(STDOUT))
+    @logger = logger
+  end
+end

data/lib/thron/pageable.rb

@@ -0,0 +1,26 @@
+require 'thron/paginator'
+
+module Thron
+  module Pageable
+    module ClassMethods
+      def paginate(*apis)
+        (@paginated_apis = apis).each do |api|
+          define_method("#{api}_paginator") do |*args|
+            options = args.empty? ? {} : args.last
+            limit = options.delete(:limit) { Paginator::MAX_LIMIT }
+            body = ->(limit, offset) { send(api, options.merge!({ offset: offset, limit: limit })) }
+            Paginator::new(body: body, limit: limit)
+          end
+        end
+      end
+
+      def paginator_methods
+        Array(@paginated_apis).map { |api| :"#{api}_paginator" }
+      end
+    end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+  end
+end

data/lib/thron/paginator.rb

@@ -0,0 +1,82 @@
+require 'ostruct'
+require 'thron/response'
+
+module Thron
+  class Paginator
+    MAX_LIMIT = 50
+
+    def self.check_limit(limit)
+      limit.to_i.tap do |limit|
+        return MAX_LIMIT if limit > MAX_LIMIT
+      end
+    end
+    
+    attr_reader :offset, :limit, :cache
+
+    def initialize(options = {})
+      body = options[:body]
+      limit = options.fetch(:limit) { MAX_LIMIT }
+      fail ArgumentError, 'body must be a proc object' unless body.is_a?(Proc)
+      fail ArgumentError, 'body must accept the limit and offset attributes' unless body.arity == 2
+      @body = body
+      @limit = self.class.check_limit(limit)
+      @offset = offset.to_i
+      @cache = {}
+    end
+
+    def prev
+      @offset = prev_offset
+      fetch.value
+    end
+
+    def next
+      @offset = next_offset
+      fetch.value
+    end
+
+    def preload(n)
+      starting_offset = max_offset
+      (n).to_i.times do |i|
+        index  = starting_offset.zero? ? i : (i + 1)
+        offset = starting_offset + (index * @limit)
+        fetch(offset)
+      end
+    end
+
+    def total
+      return @total if @total
+      return 0 if cache.empty?
+      @total = cache.fetch(0).value.total
+    end
+
+    private
+
+    def fetch(offset = @offset)
+      @cache.fetch(offset) do
+        call(offset).tap do |raw|
+          @cache[offset] = raw
+        end
+      end
+    end
+
+    def call(offset)
+      Thread::new { @body.call(@limit, offset) }
+    end
+
+    def next_offset
+      return 0 if cache.empty?
+      return @offset if total > 0 && (@offset + @limit) >= total
+      @offset + @limit
+    end
+
+    def prev_offset
+      return 0 if @offset <= @limit
+      @offset - @limit
+    end
+
+    def max_offset
+      return 0 if cache.empty?
+      @cache.max.first
+    end
+  end
+end

data/lib/thron/response.rb

@@ -0,0 +1,48 @@
+require 'thron/string_extensions'
+
+module Thron
+  using StringExtensions
+  class Response
+    attr_accessor :body
+    attr_reader :http_code, :result_code, :sso_code, :total, :other_results, :error
+
+    ERROR_KEY = 'errorDescription'
+    ID_REGEX  = /\A\w{8}-\w{4}-\w{4}-\w{4}-\w{12}\Z/
+
+    def initialize(raw_data)
+      @http_code     = raw_data.code
+      @body          = fetch(raw_data)
+      @result_code   = @body.delete('resultCode')
+      @sso_code      = @body.delete('ssoCode')
+      @total         = @body.delete('totalResults')
+      @other_results = @body.delete('otherResults') { false }
+      @error         = @body.delete(ERROR_KEY)
+    end
+
+    def extra(options = {})
+      attribute = options[:attribute].to_s
+      name = attribute.snakecase 
+      self.class.send(:attr_reader, name)
+      instance_variable_set(:"@#{name}", body.delete(attribute))
+    end
+
+    def is_200?
+      (@http_code.to_i / 100) == 2
+    end
+
+    private
+
+    def fetch(raw_data)
+      case(parsed = raw_data.parsed_response)
+      when Hash
+        parsed
+      when ID_REGEX
+        { id: parsed }
+      when String
+        { ERROR_KEY => parsed }
+      else
+        {}
+      end
+    end
+  end
+end

data/lib/thron/root.rb

@@ -0,0 +1,9 @@
+require 'pathname'
+
+module Thron
+  extend self
+
+  def root
+    @root ||= Pathname.new(File.expand_path(File.join('..', '..', '..'), __FILE__))
+  end
+end

data/lib/thron/routable.rb

@@ -0,0 +1,80 @@
+require 'httparty'
+require 'thron/config'
+require 'thron/route'
+require 'thron/circuit_breaker'
+require 'thron/response'
+require 'thron/logger'
+
+module Thron
+  module Routable
+    include HTTParty
+
+    class NoentRouteError < StandardError; end
+
+    def self.included(klass)
+      klass.extend ClassMethods
+      klass.class_eval do
+        include HTTParty
+      end
+    end
+
+    def self.info(host, query, body, route, token_id, dash)
+      info = [
+        "\n",
+        "*" * 50,
+        'HTTP REQUEST:',
+        "  * host: #{host}",
+        "  * url: #{route.url}",
+        "  * verb: #{route.verb.upcase}",
+        "  * query: #{query.inspect}",
+        "  * body: #{body.inspect}",
+        "  * headers: #{route.headers(token_id: token_id, dash: dash)}",
+        "*" * 50,
+        "\n"
+      ]
+      puts info if Config::logger::verbose
+      Thron::logger.debug info.join("\n")
+    end
+
+    module ClassMethods
+      def circuit_breaker
+        @circuit_breaker ||= CircuitBreaker::new(threshold: Config::circuit_breaker.threshold)
+      end
+
+      def routes
+        fail NotImplementedError
+      end
+    end
+
+    def route(options = {})
+      to = options[:to]
+      query = options.fetch(:query) { {} }
+      body = options.fetch(:body) { {} }
+      token_id = options[:token_id]
+      dash = options.fetch(:dash) { true }
+      params = options[:params].to_a
+      route = fetch_route(to, params)
+      body = body.to_json if !body.empty? && route.json?
+      self.class.circuit_breaker.monitor do
+        raw = self.class.send(route.verb, 
+                              route.url, 
+                              { query: query, 
+                                body: body, 
+                                headers: route.headers(token_id: token_id, dash: dash) })
+        Routable::info(self.class.default_options[:base_uri], query, body, route, token_id, dash)
+        Response::new(raw).tap do |response|
+          yield(response) if response.is_200? && block_given?
+        end
+      end
+    rescue CircuitBreaker::OpenError
+      Thron::logger.error "Circuit breaker is open for process #{$$}"
+      Response::new(OpenStruct::new(code: 200))
+    end
+
+    private
+    
+    def fetch_route(to, params)
+      self.class.routes.fetch(to) { fail NoentRouteError, "#{to} route does not exist!" }.call(params)
+    end
+  end
+end

data/lib/thron/route.rb

@@ -0,0 +1,102 @@
+module Thron
+  class Route
+    module Types
+      ALL = %w[json xml plain multipart]
+      ALL.each do |type|
+        const_set(type.upcase, type)
+      end
+    end
+
+    module Verbs
+      ALL = %w[post get put delete]
+      ALL.each do |type|
+        const_set(type.upcase, type)
+      end
+    end
+
+    class UnsupportedVerbError < StandardError; end
+    class UnsupportedTypeError < StandardError; end
+
+    def self.factory(options = {})
+      name = options[:name]
+      package = options[:package]
+      params = options[:params].to_a
+      verb = options.fetch(:verb) { Verbs::POST }
+      type = options.fetch(:type) { Types::JSON }
+      accept = options.fetch(:accept) { Types::JSON }
+      url = "/#{package}/#{name}"
+      url << "/#{params.join('/')}" unless params.empty?
+      Route::new(verb: verb, url: url, type: type, accept: accept)
+    end
+
+    def self.lazy_factory(options)
+      options.delete(:params)
+      ->(params) { factory(options.merge({ params: params })) }
+    end
+
+    def self.header_type(type)
+      case type.to_s
+      when Types::JSON
+        'application/json'
+      when Types::XML
+        'application/xml'
+      when Types::MULTIPART
+        'multipart/form-data'
+      when Types::PLAIN
+        'text/plain'
+      end
+    end
+
+    attr_reader :verb, :url
+
+    def initialize(options = {})
+      @verb   = check_verb(options[:verb])
+      @url    = options[:url]
+      @type   = check_type(options[:type])
+      @accept = check_type(options[:accept])
+    end
+
+    def call(*args)
+      self
+    end
+
+    def json?
+      @type == Types::JSON
+    end
+
+    def format
+      return {} unless @format
+      { format: @format }
+    end
+
+    def headers(options = {})
+      @headers = { 
+        'Accept' => self.class.header_type(@accept), 
+        content_type_key(options[:dash]) => self.class.header_type(@type)
+      }.tap do |headers|
+        headers.merge!({ 'X-TOKENID' => options[:token_id] }) if options[:token_id]
+      end
+    end
+
+    private
+    
+    def content_type_key(dash = nil)
+      "Content_Type".tap do |key|
+        key.sub!('_', '-') if dash
+      end
+    end
+
+    def check_verb(verb)
+      verb.tap do |verb|
+        fail UnsupportedVerbError, "#{verb} is not supported" unless Verbs::ALL.include?(verb)
+      end
+    end
+
+    def check_type(type)
+      type.tap do |type|
+        fail UnsupportedTypeError, "#{type} is not supported" unless Types::ALL.include?(type)
+      end
+    end
+  end
+end
+

data/lib/thron/string_extensions.rb

@@ -0,0 +1,23 @@
+module Thron
+  module StringExtensions
+    refine String do
+      def snakecase
+        partition(/[A-Z]{2,}\Z/).reject(&:empty?).reduce([]) do |acc, token|
+          token = token.gsub(/(.)([A-Z])/,'\1_\2').downcase unless token.uppercase?
+          acc << token
+        end.join('_')
+      end
+
+      def camelize_low
+        self.split('_').reduce([]) do |acc, token| 
+          token.capitalize! unless acc.empty? || token.uppercase?
+          acc << token
+        end.join
+      end
+
+      def uppercase?
+        self.upcase == self
+      end
+    end
+  end
+end

data/lib/thron/user.rb

@@ -0,0 +1,77 @@
+require 'forwardable'
+Dir[Thron.root.join('lib', 'thron', 'gateway', '*.rb')].each { |f| require f }
+
+module Thron
+  class User
+    extend Forwardable
+    
+    def_delegators :@access_gateway, *Gateway::AccessManager::routes.keys
+
+    def self.session_gateways
+      @session_gateways ||= Gateway::constants.select do |name|
+        Gateway.const_get(name) < Gateway::Session
+      end
+    end
+
+    def self.delegate_to_gateways
+      self.session_gateways.each do |name|
+        gateway = Gateway.const_get(name)
+        def_delegators "@gateways[:#{name}]", *(gateway.routes::keys + gateway.paginator_methods)
+      end
+    end
+
+    delegate_to_gateways
+    
+    attr_reader :token_id, :gateways
+
+    def initialize
+      @access_gateway = Gateway::AccessManager::new
+    end 
+
+    def login(options)
+      @access_gateway.login(options).tap do |response|
+        @token_id = @access_gateway.token_id
+        refresh_gateways
+      end
+    end
+
+    def logout
+      return unless logged?
+      @token_id = @access_gateway.token_id = nil
+      @gateways = nil
+    end
+
+    def disguise(options)
+      response = su(options)
+      response.body[:id].tap do |token_id|
+        return response.error unless token_id
+        original_token, @token_id = @token_id, token_id
+        refresh_gateways
+        yield if block_given?
+        @token_id = original_token 
+        refresh_gateways
+      end
+    end
+
+    def logged?
+      !!@token_id
+    end
+
+    private 
+    
+    def initialize_gateways
+      self.class.session_gateways.reduce({}) do |acc, name|
+        acc[name] = Gateway.const_get(name)::new(token_id: @token_id); acc
+      end
+    end
+
+    def refresh_gateways
+      return unless logged?
+      return (@gateways = initialize_gateways) unless @gateways
+      @access_gateway.token_id = @token_id
+      @gateways.each do |name, gateway|
+        gateway.token_id = @token_id
+      end
+    end
+  end
+end