castle-rb 2.2.0 → 2.3.0

data/lib/castle-rb/api.rb

@@ -1,94 +0,0 @@
-module Castle
-  class API
-    attr_accessor :http, :headers
-
-    def initialize(cookie_id, ip, headers)
-      @http = Net::HTTP.new(Castle.config.api_endpoint.host,
-                            Castle.config.api_endpoint.port)
-
-      @http.read_timeout = Castle.config.request_timeout
-
-      if Castle.config.api_endpoint.scheme == 'https'
-        @http.use_ssl = true
-        @http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-      end
-
-      @headers = {
-        "Content-Type" => "application/json",
-        "X-Castle-Cookie-Id" => cookie_id,
-        "X-Castle-Ip" => ip,
-        "X-Castle-Headers" => headers,
-        "X-Castle-Client-User-Agent" => JSON.generate(client_user_agent),
-        "X-Castle-Source" => Castle.config.source_header,
-        "User-Agent" => "Castle/v1 RubyBindings/#{Castle::VERSION}"
-      }
-
-      @headers.delete_if { |k, v| v.nil? }
-    end
-
-    def request(endpoint, args, method: :post)
-      http_method = method.to_s.capitalize
-      req = Net::HTTP.const_get(http_method).new(
-        "#{Castle.config.api_endpoint.path}/#{endpoint}", @headers)
-      req.basic_auth("", Castle.config.api_secret)
-      req.body = args.to_json unless http_method == 'Get'
-
-      begin
-        response = @http.request(req)
-      rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
-             Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError,
-             Net::ProtocolError, Net::ReadTimeout => e
-        raise Castle::RequestError, 'Castle API connection error'
-      end
-
-      case response.code.to_i
-      when 200..299
-        # OK
-      when 400
-        raise Castle::BadRequestError, response[:message]
-      when 401
-        raise Castle::UnauthorizedError, response[:message]
-      when 403
-        raise Castle::ForbiddenError, response[:message]
-      when 404
-        raise Castle::NotFoundError, response[:message]
-      when 419
-        raise Castle::UserUnauthorizedError, response[:message]
-      when 422
-        raise Castle::InvalidParametersError, response[:message]
-      else
-        raise Castle::ApiError, response[:message]
-      end
-
-      if response.body.nil? || response.body.empty?
-        {}
-      else
-        begin
-          JSON.parse(response.body, :symbolize_names => true)
-        rescue JSON::ParserError
-          raise Castle::ApiError, 'Invalid response from Castle API'
-        end
-      end
-    end
-
-    def client_user_agent
-      @uname ||= get_uname
-      lang_version = "#{RUBY_VERSION} p#{RUBY_PATCHLEVEL} (#{RUBY_RELEASE_DATE})"
-
-      {
-        :bindings_version => Castle::VERSION,
-        :lang => 'ruby',
-        :lang_version => lang_version,
-        :platform => RUBY_PLATFORM,
-        :publisher => 'castle',
-        :uname => @uname
-      }
-    end
-
-    def get_uname
-      `uname -a 2>/dev/null`.strip if RUBY_PLATFORM =~ /linux|darwin/i
-    rescue Errno::ENOMEM # couldn't create subprocess
-      "uname lookup failed"
-    end
-  end
-end

data/lib/castle-rb/client.rb

@@ -1,67 +0,0 @@
-module Castle
-  class Client
-    attr_accessor :do_not_track, :api
-
-    def initialize(request, response)
-      cookie_id = extract_cookie(request, response)['__cid'] || ''
-      ip = request.ip
-      headers = header_string(request)
-
-      @api = API.new(cookie_id, ip, headers)
-    end
-
-    def fetch_review(id)
-      @api.request("reviews/#{id}", nil, method: :get)
-    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
-
-
-    private
-
-    # Extract the cookie set by the Castle Javascript
-    def extract_cookie(request, response)
-      if response.class.name == 'ActionDispatch::Cookies::CookieJar'
-        Castle::CookieStore::Rack.new(response)
-      else
-        Castle::CookieStore::Base.new(request, response)
-      end
-    end
-
-    # Serialize HTTP headers
-    def header_string(request)
-      scrub_headers = ['Cookie']
-
-      headers = request.env.keys.grep(/^HTTP_/).map do |header|
-        name = header.gsub(/^HTTP_/, '').split('_').map(&:capitalize).join('-')
-        unless scrub_headers.include?(name)
-          { name => request.env[header] }
-        end
-      end.compact.inject(:merge)
-
-      JSON.generate(headers || {})
-    end
-  end
-end

data/lib/castle-rb/configuration.rb

@@ -1,48 +0,0 @@
-module Castle
-  class << self
-    def configure(config_hash=nil)
-      if config_hash
-        config_hash.each do |k,v|
-          config.send("#{k}=", v)
-        end
-      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
-
-  class Configuration
-    attr_accessor :request_timeout
-    attr_accessor :source_header
-
-    def initialize
-      self.request_timeout = 30.0
-      self.api_endpoint =
-        ENV['CASTLE_API_ENDPOINT'] || 'https://api.castle.io/v1'
-    end
-
-    def api_secret
-      ENV['CASTLE_API_SECRET'] || @_api_secret || ''
-    end
-
-    def api_secret=(value)
-      @_api_secret = value
-    end
-
-    def api_endpoint
-      @_api_endpoint
-    end
-
-    def api_endpoint=(value)
-      @_api_endpoint = URI(value)
-    end
-  end
-end

data/lib/castle-rb/errors.rb

@@ -1,15 +0,0 @@
-class Castle::Error < Exception; end
-
-class Castle::RequestError < Castle::Error; end
-class Castle::SecurityError < Castle::Error; end
-class Castle::ConfigurationError < Castle::Error; end
-
-class Castle::ApiError < Castle::Error; end
-
-class Castle::BadRequestError < Castle::ApiError; end
-class Castle::ForbiddenError < Castle::ApiError; end
-class Castle::NotFoundError < Castle::ApiError; end
-class Castle::UserUnauthorizedError < Castle::ApiError; end
-class Castle::InvalidParametersError < Castle::ApiError; end
-
-class Castle::UnauthorizedError < Castle::ApiError; end

data/lib/castle-rb/version.rb

@@ -1,3 +0,0 @@
-module Castle
-  VERSION = "2.2.0"
-end

data/spec/api_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe Castle::API do
-  let(:api) { Castle::API.new('abcd', '1.2.3.4', '{}') }
-
-  it 'handles timeout' do
-    stub_request(:any, /api.castle.io/).to_timeout
-    expect {
-      api.request('authenticate', user_id: '1234')
-    }.to raise_error(Castle::RequestError)
-  end
-
-  it 'handles non-OK response code' do
-    stub_request(:any, /api.castle.io/).to_return(status: 400)
-    expect {
-      api.request('authenticate', user_id: '1234')
-    }.to raise_error(Castle::BadRequestError)
-  end
-
-  it 'handles custom API endpoint' do
-    stub_request(:any, /new.herokuapp.com/)
-
-    api_endpoint = 'http://new.herokuapp.com:3000/v2'
-    Castle.config.api_endpoint = api_endpoint
-    uri = URI(api_endpoint)
-
-    api.request('authenticate', user_id: '1234')
-    assert_requested :post,
-      "#{api_endpoint.gsub(/new/, ":secret@new")}/authenticate", times: 1
-  end
-end

data/spec/client_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-class Request < Rack::Request
-  def delegate?; false; end
-end
-
-describe Castle::Client do
-  let(:ip) {'1.2.3.4' }
-  let(:cookie_id) { 'abcd' }
-  let(:env) do
-    Rack::MockRequest.env_for('/',
-      'HTTP_X_FORWARDED_FOR' => '1.2.3.4',
-      'HTTP_COOKIE' => "__cid=#{cookie_id};other=efgh"
-    )
-  end
-  let(:request) { Request.new(env) }
-  let(:client) { Castle::Client.new(request, nil) }
-  let(:review_id) { '12356789' }
-
-  it 'parses the request' do
-    expect(Castle::API).to receive(:new).with(cookie_id, ip,
-      "{\"X-Forwarded-For\":\"#{ip}\"}").and_call_original
-
-    client = Castle::Client.new(request, nil)
-    client.authenticate({name: '$login.succeeded', user_id: '1234'})
-  end
-
-  it 'identifies' do
-    client.identify( user_id: '1234', traits: { name: 'Jo' })
-    assert_requested :post, 'https://:secret@api.castle.io/v1/identify',
-      times: 1,
-      body: { user_id: '1234', traits: { name: 'Jo' } }
-  end
-
-  it 'authenticates' do
-    client.authenticate(name: '$login.succeeded', user_id: '1234')
-    assert_requested :post, 'https://:secret@api.castle.io/v1/authenticate',
-      times: 1,
-      body: { name: '$login.succeeded', user_id: "1234" }
-  end
-
-  it 'tracks' do
-    client.track(name: '$login.succeeded', user_id: '1234')
-    assert_requested :post, 'https://:secret@api.castle.io/v1/track',
-      times: 1,
-      body: { name: '$login.succeeded', user_id: "1234" }
-  end
-
-  it 'fetches review' do
-    client.fetch_review(review_id)
-
-    assert_requested :get, "https://:secret@api.castle.io/v1/reviews/#{review_id}",
-      times: 1
-  end
-end