tradier 0.1.0

data/lib/tradier/balance.rb

@@ -0,0 +1,17 @@
+require 'tradier/base'
+
+module Tradier
+  class Balance < Tradier::Base
+
+    attr_reader :account_number, :account_type, :cash_available, \
+    :cash_margin_value, :dividend_balance, :equity_value, :long_liquid_value, \
+    :long_market_value, :market_value, :net_value, :option_requirement, \
+    :prev_cash_available, :prev_maintenance_call, :short_liquid_value, \
+    :short_market_value, :sweep, :accumFedAmt, :accumFedPrev, :bopmvEqty, \
+    :cashMgnCashAv, :optnAddtlReqAmt, :currType
+
+    def self.from_response(body={})
+      new(body[:balances] || body)
+    end
+  end
+end

data/lib/tradier/base.rb

@@ -0,0 +1,76 @@
+module Tradier
+  class Base
+
+    def self.from_response(body={})
+      new(body)
+    end
+
+    # Define methods that retrieve the value from an initialized instance variable Hash, using the attribute as a key
+    #
+    # @param attrs [Array, Set, Symbol]
+    def self.attr_reader(*attrs)
+      mod = Module.new do
+        attrs.each do |attribute|
+          define_method attribute do
+            @attrs[attribute.to_sym]
+          end
+          define_method "#{attribute}?" do
+            !!@attrs[attribute.to_sym]
+          end
+        end
+      end
+      const_set(:Attributes, mod)
+      include mod
+    end
+
+    # Initializes a new object
+    #
+    # @param attrs [Hash]
+    # @return [Tradier::Base]
+    def initialize(attrs={})
+      @attrs = attrs
+    end
+
+    # Fetches an attribute of an object using hash notation
+    #
+    # @param method [String, Symbol] Message to send to the object
+    def [](method)
+      send(method.to_sym)
+    rescue NoMethodError
+      nil
+    end
+
+    # Retrieve the attributes of an object
+    #
+    # @return [Hash]
+    def attrs
+      @attrs
+    end
+    alias to_hash attrs
+
+    # Update the attributes of an object
+    #
+    # @param attrs [Hash]
+    # @return [Tradier::Base]
+    def update(attrs)
+      @attrs.update(attrs)
+      self
+    end
+
+    protected
+
+    # @param attr [Symbol]
+    # @param other [Tradier::Base]
+    # @return [Boolean]
+    def attr_equal(attr, other)
+      self.class == other.class && !other.send(attr).nil? && send(attr) == other.send(attr)
+    end
+
+    # @param other [Tradier::Base]
+    # @return [Boolean]
+    def attrs_equal(other)
+      self.class == other.class && !other.attrs.empty? && attrs == other.attrs
+    end
+
+  end
+end

data/lib/tradier/calendar.rb

@@ -0,0 +1,23 @@
+require 'tradier/base'
+
+module Tradier
+  class Calendar < Tradier::Base
+
+    # Create a new [Tradier::Calendar] instance from a response
+    #
+    # @param body [Hash]
+    # @return [Tradier::Calendar]
+    def self.from_response(body={})
+      new(body)
+    end
+
+    def month
+      @_month ||= @attrs[:calendar][:days][:month]
+    end
+
+    def year
+      @_year ||= @attrs[:calendar][:days][:year]
+    end
+
+  end
+end

data/lib/tradier/client.rb

@@ -0,0 +1,89 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'multi_json'
+require 'tradier/api/accounts'
+require 'tradier/api/markets'
+require 'tradier/api/orders'
+require 'tradier/api/watchlists'
+require 'tradier/configurable'
+require 'tradier/error/client_error'
+require 'tradier/error/decode_error'
+
+module Tradier
+  # Wrapper for the Tradier REST API
+  class Client
+    include Tradier::API::Accounts
+    include Tradier::API::Markets
+    include Tradier::API::Orders
+    include Tradier::API::Watchlists
+    include Tradier::Configurable
+
+    # Initializes a new Client object
+    #
+    # @param options [Hash]
+    # @return [Tradier::Client]
+    def initialize(options={})
+      Tradier::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", options[key] || Tradier.instance_variable_get(:"@#{key}"))
+      end
+    end
+
+    # Perform an HTTP DELETE request
+    def delete(path, params={})
+      request(:delete, path, params)
+    end
+
+    # Perform an HTTP GET request
+    def get(path, params={})
+      request(:get, path, params)
+    end
+
+    # Perform an HTTP POST request
+    def post(path, params={})
+      request(:post, path, params)
+    end
+
+    # Perform an HTTP PUT request
+    def put(path, params={})
+      request(:put, path, params)
+    end
+
+    private
+
+    # Returns a proc that can be used to setup the Faraday::Request headers
+    #
+    # @param method [Symbol]
+    # @param path [String]
+    # @param params [Hash]
+    # @return [Proc]
+    def request_setup(method, path, params)
+      Proc.new do |request|
+        request.headers[:authorization] = "Bearer #{@access_token}"
+      end
+    end
+
+    def request(method, request_path, params={}, signature_params=params)
+      request_setup = request_setup(method, versioned_path(request_path), params)
+      connection.send(method.to_sym, versioned_path(request_path), params, &request_setup).env
+    rescue Faraday::Error::ClientError
+      raise Tradier::Error::ClientError
+    rescue MultiJson::DecodeError
+      raise Tradier::Error::DecodeError
+    end
+
+    # Returns a Faraday::Connection object
+    #
+    # @return [Faraday::Connection]
+    def connection
+      @connection ||= begin
+        connection_options = {:builder => @middleware}
+        Faraday.new(@endpoint, @connection_options.merge(connection_options))
+      end
+    end
+
+    def versioned_path(request_path)
+      @version + request_path
+    end
+
+  end
+end

data/lib/tradier/clock.rb

@@ -0,0 +1,21 @@
+require 'tradier/base'
+
+module Tradier
+  class Clock < Tradier::Base
+
+    attr_reader :description, :next_change, :next_state, :state
+
+    def date
+      return unless @date || @attrs[:date]
+
+      @date ||= Date.parse(@attrs[:date])
+    end
+
+    def time
+      return unless @time || @attrs[:timestamp]
+
+      @time ||= Time.at(@attrs[:timestamp].to_i)
+    end
+
+  end
+end

data/lib/tradier/configurable.rb

@@ -0,0 +1,76 @@
+require 'forwardable'
+require 'tradier/error/configuration_error'
+
+module Tradier
+  module Configurable
+    extend Forwardable
+    attr_writer :access_token
+    attr_accessor :endpoint, :connection_options, :middleware, :version
+    def_delegator :options, :hash
+
+    class << self
+
+      def keys
+        @keys ||= [
+          :access_token,
+          :endpoint,
+          :version,
+          :connection_options,
+          :middleware
+        ]
+      end
+
+    end
+
+    # Convenience method to allow configuration options to be set in a block
+    #
+    # @raise [Tradier::Error::ConfigurationError] Error is raised when supplied
+    #   Tradier credentials are not a String or Symbol.
+    def configure
+      yield self
+      validate_credentials!
+      self
+    end
+
+    # @return [Boolean]
+    def credentials?
+      credentials.values.all?
+    end
+
+    def reset!
+      Tradier::Configurable.keys.each do |key|
+        instance_variable_set(:"@#{key}", Tradier::Default.options[key])
+      end
+      self
+    end
+    alias setup reset!
+
+    private
+
+    # @return [Hash]
+    def credentials
+      { :access_token => @access_token }
+    end
+
+    # @return [Hash]
+    def options
+      Hash[Tradier::Configurable.keys.map{|key| [key, instance_variable_get(:"@#{key}")]}]
+    end
+
+    # Ensures that all credentials set during configuration are of a
+    # valid type. Valid types are String and Symbol.
+    #
+    # @raise [Tradier::Error::ConfigurationError] Error is raised when
+    #   supplied Tradier credentials are not a String or Symbol.
+    def validate_credentials!
+      credentials.each do |credential, value|
+        next if value.nil?
+
+        unless value.is_a?(String) || value.is_a?(::Symbol)
+          raise(Error::ConfigurationError, "Invalid #{credential} specified: #{value} must be a string or symbol.")
+        end
+      end
+    end
+
+  end
+end

data/lib/tradier/core_ext/enumerable.rb

@@ -0,0 +1,9 @@
+require 'celluloid/autostart'
+
+module Enumerable
+  # Simple parallel map using Celluloid::Futures
+  def pmap(&block)
+    futures = map { |elem| Celluloid::Future.new(elem, &block) }
+    futures.map { |future| future.value }
+  end
+end

data/lib/tradier/default.rb

@@ -0,0 +1,75 @@
+require 'faraday'
+require 'faraday_middleware'
+require 'tradier/configurable'
+require 'tradier/error/client_error'
+require 'tradier/error/server_error'
+require 'tradier/response/parse_json'
+require 'tradier/response/raise_error'
+require 'tradier/version'
+
+module Tradier
+  module Default
+    ENDPOINT = 'https://api.tradier.com' unless defined? Tradier::Default::ENDPOINT
+
+    VERSION = 'v1' unless defined?(Tradier::Default::VERSION)
+
+    CONNECTION_OPTIONS = {
+      :headers => {
+        :accept => 'application/json',
+        :user_agent => "Tradier Ruby Gem #{Tradier::VERSION}",
+      },
+      :request => {
+        :open_timeout => 5,
+        :timeout => 10,
+      }
+    } unless defined? Tradier::Default::CONNECTION_OPTIONS
+
+    MIDDLEWARE = Faraday::Builder.new do |builder|
+      # Convert request params to "www-form-urlencoded"
+      builder.use Faraday::Request::UrlEncoded
+      # Parse JSON response bodies using MultiJson
+      builder.use Tradier::Response::ParseJson
+      # # Handle 4xx server responses
+      builder.use Tradier::Response::RaiseError, Tradier::Error::ClientError
+      # # Handle 5xx server responses
+      builder.use Tradier::Response::RaiseError, Tradier::Error::ServerError
+      # Set Faraday's HTTP adapter
+      builder.adapter Faraday.default_adapter
+    end unless defined? Tradier::Default::MIDDLEWARE
+
+    class << self
+
+      # @return [Hash]
+      def options
+        Hash[Tradier::Configurable.keys.map{|key| [key, send(key)]}]
+      end
+
+      # @return [String]
+      def access_token
+        ENV['TRADIER_ACCESS_TOKEN']
+      end
+
+      # @return [String]
+      def endpoint
+        ENDPOINT
+      end
+
+      def version
+        VERSION
+      end
+
+      def connection_options
+        CONNECTION_OPTIONS
+      end
+
+      # @note Faraday's middleware stack implementation is comparable to that of Rack middleware.  The order of middleware is important: the first middleware on the list wraps all others, while the last middleware is the innermost one.
+      # @see https://github.com/technoweenie/faraday#advanced-middleware-usage
+      # @see http://mislav.uniqpath.com/2011/07/faraday-advanced-http/
+      # @return [Faraday::Builder]
+      def middleware
+        MIDDLEWARE
+      end
+
+    end
+  end
+end

data/lib/tradier/error.rb

@@ -0,0 +1,34 @@
+module Tradier
+  # Custom error class for rescuing from all Tradier errors
+  class Error < StandardError
+    attr_reader :wrapped_exception
+
+    # @return [Hash]
+    def self.errors
+      @errors ||= descendants.each_with_object({}) do |klass, hash|
+        hash[klass::HTTP_STATUS_CODE] = klass if defined?(klass::HTTP_STATUS_CODE)
+        hash.update(klass.errors)
+      end
+    end
+
+    # @return [Array]
+    def self.descendants
+      ObjectSpace.each_object(::Class).select{|klass| klass < self}
+    end
+
+    # Initializes a new Error object
+    #
+    # @param exception [Exception, String]
+    # @param response_headers [Hash]
+    # @return [Tradier::Error]
+    def initialize(exception=$!, response_headers={})
+      @wrapped_exception = exception
+      exception.respond_to?(:backtrace) ? super(exception.message) : super(exception.to_s)
+    end
+
+    def backtrace
+      @wrapped_exception.respond_to?(:backtrace) ? @wrapped_exception.backtrace : super
+    end
+
+  end
+end

data/lib/tradier/error/bad_gateway.rb

@@ -0,0 +1,11 @@
+require 'tradier/error/server_error'
+
+module Tradier
+  class Error
+    # Raised when Tradier returns the HTTP status code 502
+    class BadGateway < Tradier::Error::ServerError
+      HTTP_STATUS_CODE = 502
+      MESSAGE = "Tradier is down or being upgraded."
+    end
+  end
+end

data/lib/tradier/error/bad_request.rb

@@ -0,0 +1,10 @@
+require 'tradier/error/client_error'
+
+module Tradier
+  class Error
+    # Raised when Tradier returns the HTTP status code 400
+    class BadRequest < Tradier::Error::ClientError
+      HTTP_STATUS_CODE = 400
+    end
+  end
+end