castle-rb 2.2.0 → 2.3.0

checksums.yaml

@@ -1,7 +1,4 @@
 ---
-SHA1:
-  metadata.gz: cf802329a5b427cc2b979f02931c572601397506
-  data.tar.gz: 58746daf7163fe23e054261b1b52a44e918b7074
 SHA512:
-  metadata.gz: 16c66f7e9c363791316aa12aac26ab42f77770929ce8fca7732b2fdf26e3cf4c8efb304bd8b6683f34c9d31ff74e4b01e88ff4efa44caf7e11d4854c89c35760
-  data.tar.gz: 1287a6ac045069c0ef795c4764c8e1235c04dcf0a7b8a696d3e88c499f815cd3f112f1bad848580006c55d7ffdb80ee5d25e3477616f8e7ede2c98dbda5f1ef2
+  metadata.gz: 5119758641db337ccc160ed9709f68c91a9e65d80748d31b719f71af40f25d7fe512e0026ec1252fce167511a5edac3a07c35b436981347d02007fe02c1de774
+  data.tar.gz: 6464b7e94ed647fadf2f5ee6928db94c29f77be387f7d98330c7868597a3dfed036565458fb1f354d8df0d8cc18e1117f8f40d877e13641e5441462a74452184

data/README.md

@@ -28,7 +28,7 @@ A Castle client instance will be made available as `castle` in your Rails, Sinat
 
 ## Exceptions
 
-`Castle::Error` will be thrown if the Castle API returns a 400 or a 500 level HTTP response. You can also choose to catch a more [finegrained error](https://github.com/castle/castle-ruby/blob/master/lib/castle-rb/errors.rb).
+`Castle::Error` will be thrown if the Castle API returns a 400 or a 500 level HTTP response. You can also choose to catch a more [finegrained error](https://github.com/castle/castle-ruby/blob/master/lib/castle/errors.rb).
 
 ```ruby
 begin

data/lib/castle-rb.rb

@@ -1,20 +1,3 @@
-require 'openssl'
-require 'net/http'
-
-require 'castle-rb/version'
-
-require 'castle-rb/configuration'
-require 'castle-rb/client'
-require 'castle-rb/errors'
-require 'castle-rb/api'
-require 'castle-rb/support/cookie_store'
-require 'castle-rb/support/rails' if defined?(Rails::Railtie)
-
-if defined?(Sinatra::Base)
-  if defined?(Padrino)
-    require 'castle-rb/support/padrino'
-  else
-    require 'castle-rb/support/sinatra'
-  end
-end
+# frozen_string_literal: true
 
+require 'castle'

data/lib/castle.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require 'net/http'
+
+require 'castle/version'
+
+require 'castle/configuration'
+require 'castle/client'
+require 'castle/errors'
+require 'castle/system'
+require 'castle/extractors/client_id'
+require 'castle/extractors/headers'
+require 'castle/extractors/ip'
+require 'castle/headers'
+require 'castle/response'
+require 'castle/request'
+require 'castle/api'
+require 'castle/cookie_store'
+
+# main sdk module
+module Castle
+  class << self
+    def configure(config_hash = nil)
+      (config_hash || {}).each do |config_name, config_value|
+        config.send("#{config_name}=", config_value)
+      end
+
+      yield(config) if block_given?
+    end
+
+    def config
+      @configuration ||= Castle::Configuration.new
+    end
+
+    def api_secret=(api_secret)
+      config.api_secret = api_secret
+    end
+  end
+end
+
+require 'castle/support'

data/lib/castle/api.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Castle
+  # this class is responsible for making requests to api
+  class API
+    def initialize(cookie_id, ip, headers)
+      @config = Castle.config
+      @config_api_endpoint = @config.api_endpoint
+      @http = prepare_http
+      @headers = Castle::Headers.new.prepare(cookie_id, ip, headers)
+    end
+
+    def request_query(endpoint)
+      request = Castle::Request.new(@headers).build_query(endpoint)
+      perform_request(request)
+    end
+
+    def request(endpoint, args, method = :post)
+      request = Castle::Request.new(@headers).build(endpoint, args, method)
+      perform_request(request)
+    end
+
+    private
+
+    def prepare_http
+      http = Net::HTTP.new(
+        @config_api_endpoint.host,
+        @config_api_endpoint.port
+      )
+      http.read_timeout = @config.request_timeout
+      prepare_http_for_ssl(http) if @config_api_endpoint.scheme == 'https'
+      http
+    end
+
+    def prepare_http_for_ssl(http)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+    end
+
+    def perform_request(req)
+      Castle::Response.new(@http.request(req)).parse
+    rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
+           Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
+           Net::ProtocolError
+      raise Castle::RequestError, 'Castle API connection error'
+    end
+  end
+end

data/lib/castle/client.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Castle
+  class Client
+    attr_accessor :api
+
+    def initialize(request, response)
+      @do_not_track = false
+      cookie_id = Extractors::ClientId.new(request).call(response, '__cid')
+      ip = Extractors::IP.new(request).call
+      headers = Extractors::Headers.new(request).call
+      @api = API.new(cookie_id, ip, headers)
+    end
+
+    def fetch_review(id)
+      @api.request_query("reviews/#{id}")
+    end
+
+    def identify(args)
+      @api.request('identify', args) unless do_not_track?
+    end
+
+    def authenticate(args)
+      @api.request('authenticate', args)
+    end
+
+    def track(args)
+      @api.request('track', args) unless do_not_track?
+    end
+
+    def do_not_track!
+      @do_not_track = true
+    end
+
+    def track!
+      @do_not_track = false
+    end
+
+    def do_not_track?
+      @do_not_track
+    end
+  end
+end

data/lib/castle/configuration.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Castle
+  # manages configuration variables
+  class Configuration
+    SUPPORTED = %i[source_header request_timeout api_secret api_endpoint].freeze
+    REQUEST_TIMEOUT = 30.0
+    API_ENDPOINT = 'https://api.castle.io/v1'
+
+    attr_accessor :request_timeout, :source_header
+    attr_reader :api_secret, :api_endpoint
+
+    def initialize
+      @request_timeout = REQUEST_TIMEOUT
+      self.api_endpoint = API_ENDPOINT
+      self.api_secret = ''
+    end
+
+    def api_endpoint=(value)
+      @api_endpoint = URI(
+        ENV.fetch('CASTLE_API_ENDPOINT', value)
+      )
+    end
+
+    def api_secret=(value)
+      @api_secret = ENV.fetch('CASTLE_API_SECRET', value).to_s
+    end
+
+    private
+
+    def respond_to_missing?(method_name, _include_private)
+      /^(\w+)=$/ =~ method_name
+    end
+
+    def method_missing(_m, *_args)
+      raise Castle::ConfigurationError, 'there is no such a config'
+    end
+  end
+end

data/lib/{castle-rb/support → castle}/cookie_store.rb

@@ -1,6 +1,10 @@
+# frozen_string_literal: true
+
 module Castle
   module CookieStore
     class Base
+      EXPIRATION_TIME = 20 * 365 * 24 * 60 * 60 # cookie expiration time 20y
+
       def initialize(request, response)
         @request = request
         @response = response
@@ -13,9 +17,10 @@ module Castle
       def []=(key, value)
         @request.cookies[key] = value
         if value
-          @response.set_cookie(key, value: value,
-                                    expires: Time.now + (20 * 365 * 24 * 60 * 60),
-                                    path: '/')
+          @response.set_cookie(key,
+                               value: value,
+                               expires: Time.now + EXPIRATION_TIME,
+                               path: '/')
         else
           @response.delete_cookie(key)
         end
@@ -35,7 +40,7 @@ module Castle
         if value
           @cookies[key] = {
             value: value,
-            expires: Time.now + (20 * 365 * 24 * 60 * 60),
+            expires: Time.now + EXPIRATION_TIME,
             path: '/'
           }
         else
@@ -43,6 +48,5 @@ module Castle
         end
       end
     end
-
   end
 end

data/lib/castle/errors.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Castle
+  # general error
+  class Error < RuntimeError; end
+  # request error
+  class RequestError < Castle::Error; end
+  # security error
+  class SecurityError < Castle::Error; end
+  # wrong configuration error
+  class ConfigurationError < Castle::Error; end
+  # error returned by api
+  class ApiError < Castle::Error; end
+
+  # api error bad request 400
+  class BadRequestError < Castle::ApiError; end
+  # api error forbidden 403
+  class ForbiddenError < Castle::ApiError; end
+  # api error not found 404
+  class NotFoundError < Castle::ApiError; end
+  # api error user unauthorized 419
+  class UserUnauthorizedError < Castle::ApiError; end
+  # api error invalid param 422
+  class InvalidParametersError < Castle::ApiError; end
+  # api error unauthorized 401
+  class UnauthorizedError < Castle::ApiError; end
+end

data/lib/castle/extractors/client_id.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Castle
+  module Extractors
+    # used for extraction of cookies and headers from the request
+    class ClientId
+      def initialize(request)
+        @request = request
+      end
+
+      def call(response, name)
+        extract_cookie(response)[name] ||
+          @request.env.fetch('HTTP_X_CASTLE_CLIENT_ID', '')
+      end
+
+      private
+
+      # Extract the cookie set by the Castle JavaScript
+      def extract_cookie(response)
+        if response.class.name == 'ActionDispatch::Cookies::CookieJar'
+          Castle::CookieStore::Rack.new(response)
+        else
+          Castle::CookieStore::Base.new(@request, response)
+        end
+      end
+    end
+  end
+end

data/lib/castle/extractors/headers.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Castle
+  module Extractors
+    # used for extraction of cookies and headers from the request
+    class Headers
+      def initialize(request)
+        @request = request
+        @request_env = @request.env
+        @disabled_headers = ['Cookie']
+      end
+
+      # Serialize HTTP headers
+      def call
+        headers = http_headers.each_with_object({}) do |header, acc|
+          name = format_header_name(header)
+          unless @disabled_headers.include?(name)
+            acc[name] = @request_env[header]
+          end
+        end
+
+        JSON.generate(headers)
+      end
+
+      private
+
+      def format_header_name(header)
+        header.gsub(/^HTTP_/, '').split('_').map(&:capitalize).join('-')
+      end
+
+      def http_headers
+        @request_env.keys.grep(/^HTTP_/)
+      end
+    end
+  end
+end

data/lib/castle/extractors/ip.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Castle
+  module Extractors
+    # used for extraction of ip from the request
+    class IP
+      def initialize(request)
+        @request = request
+      end
+
+      def call
+        @request.ip
+      end
+    end
+  end
+end

data/lib/castle/headers.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Castle
+  # setups headers for requests
+  class Headers
+    def initialize
+      @config = Castle.config
+      @headers = {
+        'Content-Type' => 'application/json',
+        'User-Agent' => "Castle/v1 RubyBindings/#{Castle::VERSION}"
+      }
+    end
+
+    def prepare(client_id, ip, castle_headers)
+      @headers.merge!(
+        'X-Castle-Client-Id' => client_id,
+        'X-Castle-Ip' => ip,
+        'X-Castle-Headers' => castle_headers,
+        'X-Castle-Client-User-Agent' => JSON.generate(client_user_agent),
+        'X-Castle-Source' => @config.source_header
+      )
+      @headers.delete_if { |_k, header_value| header_value.nil? }
+      @headers
+    end
+
+    private
+
+    def client_user_agent
+      {
+        bindings_version: Castle::VERSION,
+        lang: 'ruby',
+        lang_version: Castle::System.ruby_version,
+        platform: Castle::System.platform,
+        publisher: 'castle',
+        uname: Castle::System.uname
+      }
+    end
+  end
+end

data/lib/castle/request.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Castle
+  # generate api request
+  class Request
+    def initialize(headers)
+      @config = Castle.config
+      @headers = headers
+    end
+
+    def build_query(endpoint)
+      request = Net::HTTP::Get.new(
+        "#{@config.api_endpoint.path}/#{endpoint}", @headers
+      )
+      add_basic_auth(request)
+      request
+    end
+
+    def build(endpoint, args, method)
+      request = Net::HTTP.const_get(method.to_s.capitalize).new(
+        "#{@config.api_endpoint.path}/#{endpoint}", @headers
+      )
+      request.body = args.to_json
+      add_basic_auth(request)
+      request
+    end
+
+    private
+
+    def add_basic_auth(request)
+      request.basic_auth('', @config.api_secret)
+    end
+  end
+end