finnhubrb 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 305ff27db99c18e1a76d1034fd69b568e89b45fd8cfba42a030199b03e4ba4f2
+  data.tar.gz: a65a7dc065c422855d5a4a6685349c6a634be771b517586541ab90e43e1c9fde
+SHA512:
+  metadata.gz: c8cc6932d02616b872f2ac87737acde0ce0d4b951d72f76875edf32f4fc8e1ac37d37dc67ba59570bdd1a0d5fe4ec9463939748e6dfd8e950a6f029e94c63478
+  data.tar.gz: b0323e588781a3eabd6f49347f0985e51dd5d0eb872a02e07790aaa20a8407aab5adc8d5ef7d1ff477ebd134a3e9ca5dbff750c8622388b78d5e4de284f6fd6f

data/FinnhubRB.gemspec

@@ -0,0 +1,24 @@
+# lib = File.expand_path("../lib", __FILE__)
+# $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+ require "rake"
+
+Gem::Specification.new do |s|
+  s.name        = "finnhubrb"
+  s.version	    = "1.0.0"
+  s.authors     = ["Stefano Martin"]
+  s.email       = ["stefano.martin87@gmail.com"]
+  s.homepage    = "https://github.com/StefanoMartin/FinnhubRB"
+  s.license     = "MIT"
+  s.summary     = "A gem for Alpha Vantage"
+  s.description = "A ruby wrapper for Finnhub's HTTP API"
+  s.platform	   = Gem::Platform::RUBY
+  s.require_paths = ["lib"]
+  s.files         = FileList["lib/*", "spec/**/*", "FinnhubRB.gemspec", "Gemfile", "LICENSE.md", "README.md"].to_a
+  s.add_runtime_dependency "httparty", "~>0.17.0", ">= 0.17.0"
+  s.add_runtime_dependency "oj", "~>3.9.0", ">= 3.9.0"
+  s.add_runtime_dependency "faye-websocket", "~>0.10.9", ">= 0.10.9"
+  s.add_development_dependency "pry-byebug", '~> 0'
+  s.add_development_dependency "rspec", "~>3.5", ">=3.5"
+  s.add_development_dependency "awesome_print", "~>1.7", ">= 1.7"
+  s.add_development_dependency "eventmachine", "~>1.2.7", ">= 1.2.7"
+end

data/Gemfile

@@ -0,0 +1,12 @@
+source "https://rubygems.org"
+
+gem "httparty", ">= 0.17.1"
+gem "oj", ">= 3.9.2"
+gem "faye-websocket", ">= 0.10.9"
+gem "eventmachine", "1.2.7"
+
+group :development, :test do
+  gem "pry-byebug"
+	gem "rspec",  ">= 3.5"
+	gem "awesome_print", ">= 1.7"
+end

data/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 Stefano Martin
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,237 @@
+FinnhubRB
+=========================================================
+
+[Finnhub](https://finnhub.io/) is an API for retrieving Stock
+market data in JSON or CSV format.
+FinnhubRB is a wrapper Gem to use Finnhub with Ruby. FinnhubRB is based
+on the [HTTP API of Finnhub](https://finnhub.io/docs/api).
+
+To install FinnhubRB: `gem install finnhubrb`
+
+To use it in your application: `require "finnhubrb"`
+
+## How to test
+
+To test the Gem create a config.yml file inside the folder /spec with inside a line
+
+``` ruby
+key: [YOUR KEY]
+```
+
+Then run "rspec spec/test_all.rb".
+
+## Support
+
+* Without a premium account, testing is hard and I could have missed something. Any bug, suggestions and improvements are more than welcome. Please do not be shy to create issues or pull requests.
+* This is a personal project, any stars for giving your support will make a man happy.
+
+## Client
+
+To contact Alpha Vantage you need to use a valid key that you can require from [here](https://finnhub.io/register).
+
+To setup your clients use:
+
+``` ruby
+client = Finnhub::Client.new(key: "YOURKEY")
+```
+
+If you want to see the request that the client will do to Finnhub you can
+setup verbose equal to true.
+
+``` ruby
+  client.verbose = true # You can setup this during the initialization too
+```
+
+## Stock
+
+Finnhub::Stock is used to manage a stock class.
+To create a new Stock class you can use a client.
+
+``` ruby
+stock = client.stock symbol: "AAPL"
+```
+
+Several methods are available under this class:
+
+``` ruby
+  stock.symbol # Return the symbol
+  stock.profile # Retrieve profile of the stock
+  stock.ceo_compensation # Retrieve compensation of the stock's CEO
+  stock.recommendation # Retrieve recommendation about this stock
+  stock.price_target # Retrieve price target about this stock
+  stock.option_chain # Retrieve option chain about this stock
+  stock.earnings # Retrieve earnings about this stock
+  stock.news # Retrieve news about this stock (only US)
+  stock.sentiment # Retrieve social sentiment about this stock (only US)
+  stock.peers(plain: true) # Retrieve peers company similar to the one chosen
+  stock.peers # Like the previous one, but the results are Finnhub::Stock instances
+  stock.pattern # Retrieve pattern
+  stock.support_resistance # Retrieve support resistance
+  stock.technical_indicators # Retrieve techinical indicators
+```
+
+To create a timeseries you can use:
+
+``` ruby
+  stock.timeseries(count: 100) # Return the last 100 entries (default count is 100)
+  stock.timeseries(resolution: "D") # Resolution is daily "D", alternative are 1, 5, 15, 30, 60, D, W, M) where the numeric one are for minutes (default resolution is "D")
+  stock.timeseries(from: Time.now-24*30*3600, to: Time.now) # Fetch from a date to another date (default from: nil, to: nil)
+  stock.timeseries(format: "json") # Return the output in json or in csv (default format: "json")
+```
+
+Remember count and from/to are exclusive. If you use one, you cannot use the other two.
+The methods "open", "high", "low", "close", "volume" and "status" will not work if you use format csv.
+
+``` ruby
+  timeseries = stock.timeseries(from: Time.now-24*30*3600, to: Time.now, resolution: 60)
+  timeseries.output # Return output obtained from the request
+  timeseris.timestamps # Return timestamps obtained from the request
+  timeseries.open # Return open obtained from the request  
+  timeseries.low # Return low obtained from the request
+  timeseries.close # Return close obtained from the request
+  timeseries.volume # Return volume obtained from the request
+  timeseries.status # Return status obtained from the request  
+```
+
+## Crypto
+
+To analyse a crypto currency you should start by choosing which crypto exchange you want to analyse.
+
+``` ruby
+client.crypto_exchanges # Retrieve the available crypto exchanges on Finnhub (Finnhub::Crypto_Exchange instances)
+client.crypto_exchanges(plain: true) # As above, but it returns simply the output of the request
+crypto_exchange = client.crypto_exchange(name: "NAME_CRYPTO_EXCHANGE") # Create a single instance of Finnhub::Crypto_Exchange
+```
+
+After that you can choose, in that crypto exchange which symbol you want to check.
+
+``` ruby
+crypto_exchange.symbols # Retrieve the available crypto symbols on the chosen crypto exchange (Finnhub::Crypto_Symbol instances)
+crypto_exchange.symbols(plain: true) # As above, but it returns simply the output of the request
+crypto_symbol = crypto_exchange.symbol(symbol: "BTC") # Create a single instance of Finnhub::Crypto_Symbol
+```
+
+From crypto_symbol instance you can retrieve some interesting information.
+
+``` ruby
+crypto_symbol.exchange # Exchange of the crypto_symbol
+crypto_symbol.hasWM # If it has week and month
+crypto_symbol.displaySymbol # Displayed symbol
+crypto_symbol.symbol # Symbol of the crypto currency
+```
+
+Furthermore you can create a timeseries with the same logic used for Stock timeseries.
+
+``` ruby
+  timeseries = crypto_symbol.timeseries(from: Time.now-24*30*3600, to: Time.now, resolution: 60)
+  timeseries.output # Return output obtained from the request
+  timeseris.timestamps # Return timestamps obtained from the request
+  timeseries.open # Return open obtained from the request  
+  timeseries.low # Return low obtained from the request
+  timeseries.close # Return close obtained from the request
+  timeseries.volume # Return volume obtained from the request
+  timeseries.status # Return status obtained from the request  
+```
+
+## Forex
+
+To analyse a forex exchange you should start by choosing which forex exchange you want to analyse.
+
+``` ruby
+client.forex_exchanges # Retrieve the available forex exchanges on Finnhub (Finnhub::Forex_Exchange instances)
+client.forex_exchanges(plain: true) # As above, but it returns simply the output of the request
+forex_exchange = client.forex_exchange(name: "NAME_FOREX_EXCHANGE") # Create a single instance of Finnhub::Forex_Exchange
+```
+
+After that you can choose, in that forex exchange which symbol you want to check.
+
+``` ruby
+forex_exchange.symbols # Retrieve the available forex symbols on the chosen forex exchange (Finnhub::Forex_Symbol instances)
+forex_exchange.symbols(plain: true) # As above, but it returns simply the output of the request
+forex_symbol = forex_exchange.symbol(symbol: "USD") # Create a single instance of Finnhub::Forex_Symbol
+```
+
+From forex_symbol instance you can retrieve some interesting information.
+
+``` ruby
+forex_symbol.exchange # Exchange of the crypto_symbol
+forex_symbol.hasWM # If it has week and month
+forex_symbol.displaySymbol # Displayed symbol
+forex_symbol.symbol # Symbol of the crypto currency
+```
+
+Furthermore you can create a timeseries with the same logic used for Stock timeseries.
+
+``` ruby
+  timeseries = forex_symbol.timeseries(from: Time.now-24*30*3600, to: Time.now, resolution: 60)
+  timeseries.output # Return output obtained from the request
+  timeseris.timestamps # Return timestamps obtained from the request
+  timeseries.open # Return open obtained from the request  
+  timeseries.low # Return low obtained from the request
+  timeseries.close # Return close obtained from the request
+  timeseries.volume # Return volume obtained from the request
+  timeseries.status # Return status obtained from the request  
+```
+
+## Merge
+
+You can retrieve information about company that are merging in relation of a given country.
+
+``` ruby
+client.merge_countries # Retrieve the available merge countries on Finnhub (Finnhub::Merge_Country instances)
+client.merge_countries(plain: true) # As above, but it returns simply the output of the request
+country = client.merge_country(country: "France") # Create a single instance of Finnhub::Merge_Country
+country.merger # Fetch information about the company that are going to merge
+```
+
+## Economic Code
+
+You can retrieve information about economic_codes.
+
+``` ruby
+client.economic_codes # Retrieve the available economic_codes on Finnhub (Finnhub::Economic_Code instances)
+client.economic_codes(plain: true) # As above, but it returns simply the output of the request
+economic = client.economic_code(code: "CODE") # Create a single instance of Finnhub::Economic_Code
+economic.data # Data of economic_code
+economic.data(plaint: true) # As above, but it returns simply the output of the request
+```
+
+## News and calendar
+
+You can retrieve news and calendar in the following way.
+
+``` ruby
+client.news(category: "forex") # Retrieve news by category (general, forex, crypto, merger) and by minId (default 0)
+client.economic_calendar # Retrieve economic calendar
+client.earnings_calendar # Retrieve earning calendar
+client.ipo_calendar # Retrieve IPO calendar
+client.ico_calendar # Retrieve ICO calendar
+```
+
+## Websocket
+
+Here an example of how to create websocket.
+
+``` ruby
+Thread.new do
+  EM.run do
+    websocket = client.websocket # Create websocket
+    websocket.on :message do |event|
+      result = event.data # Result is not parsed
+    end
+    websocket.on :close do |event|
+      result = [:close, event.code, event.reason]
+      websocket = nil
+    end  
+  end
+end
+
+websocket.subscribe("AAPL") # Subscribe to a stock
+websocket.unsubscribe("AAPL") # Unubscribe to a stock
+```
+
+The symbol under subscribe/unsubscribe can be a string of a stock, a crypto_symbol or a forex_symbol. Or in alternative can be a Finnhub::Stock, Finnhub::Crypto_Symbol, or a Finnhub::Forex_Symbol instance.
+
+## Errors
+
+Error from FinnhubRB are returned under Finnhub::Error exception. You can use e.code to retrieve the code returned to a not successful request.

data/lib/Analysis.rb

@@ -0,0 +1,15 @@
+module Finnhub
+  module Analysis
+    def pattern(resolution: "D")
+      @client.request("/scan/pattern?symbol=#{@symbol}&resolution=#{resolution}")
+    end
+
+    def support_resistance(resolution: "D")
+      @client.request("/scan/support-resistance?symbol=#{@symbol}&resolution=#{resolution}")
+    end
+
+    def technical_indicators(resolution: "D")
+      @client.request("/scan/technical-indicator?symbol=#{@symbol}&resolution=#{resolution}")
+    end
+  end
+end

data/lib/Calendar.rb

@@ -0,0 +1,19 @@
+module Finnhub
+  module Calendar
+    def economic_calendar
+      request("/calendar/economic")
+    end
+
+    def earnings_calendar
+      request("/calendar/earnings")
+    end
+
+    def ipo_calendar
+      request("/calendar/ipo")
+    end
+
+    def ico_calendar
+      request("/calendar/ico")
+    end
+  end
+end

data/lib/Client.rb

@@ -0,0 +1,106 @@
+module Finnhub
+  class Client
+    include Calendar
+
+    BASE_URI = 'https://finnhub.io/api/v1'
+
+    def initialize(key:, verbose: false)
+      @apikey = key
+      @verbose = verbose
+    end
+
+    attr_accessor :verbose
+    attr_reader :apikey
+
+    def request(url)
+      send_url = "#{BASE_URI}#{url}"
+      send_url += send_url.include?("?") ? "&" : "?"
+      send_url += "token=#{@apikey}"
+
+      puts "\nGET #{send_url}\n" if @verbose
+      response = HTTParty.get(send_url)
+      if @verbose
+        puts "\nCODE: #{response.code}\n"
+        puts "OUTPUT: #{response.body}\n"
+      end
+
+      if response.code == 200
+        data = response.body
+        if data[0] == "[" || data[0] == "{"
+          data = Oj.load(data, symbol_keys: true)
+          return data
+        elsif data.include?("\n")
+          return data
+        else
+          raise Finnhub::Error.new message: data, code: response.code
+        end
+      else
+        raise Finnhub::Error.new message: data, code: response.code
+      end
+
+    rescue Finnhub::Error => e
+      raise e
+    rescue StandardError => e
+      raise Finnhub::Error.new message: "Failed request: #{e.message}"
+    end
+
+    def websocket
+      Finnhub::Websocket.new(@apikey)
+    end
+
+    def stock(symbol:)
+      Finnhub::Stock.new(client: self, symbol: symbol)
+    end
+
+    def forex_exchanges(plain: false)
+      output = request("/forex/exchange")
+      return output if plain
+
+      output.map{|o| Finnhub::Forex_Exchange.new(client: self, name: o)}
+    end
+
+    def forex_exchange(name:)
+      Finnhub::Forex_Exchange.new(client: self, name: name)
+    end
+
+    def crypto_exchanges(plain: false)
+      output = request("/crypto/exchange")
+      return output if plain
+
+      output.map{|o| Finnhub::Crypto_Exchange.new(client: self, name: o)}
+    end
+
+    def crypto_exchange(name:)
+      Finnhub::Crypto_Exchange.new(client: self, name: name)
+    end
+
+    def news(category: "general", minId: nil)
+      url = "/news?category=#{category}"
+      url += "&minId=#{minId}" unless minId.nil?
+      request(url)
+    end
+
+    def merge_countries(plain: false)
+      output = request("/merger/country")
+      return output if plain
+
+      output.map{|o| Finnhub::Merge_Country.new(client: self, country: o)}
+    end
+
+    def merge_country(country:)
+      Finnhub::Merge_Country.new(client: self, country: country)
+    end
+
+    def economic_codes(plain: false)
+      output = request("/economic/code")
+      return output if plain
+
+      output.map{|o| Finnhub::Economic_Code.new(client: self, code: o[0], description: o[1])}
+    end
+
+    def economic_code(code:, description: nil)
+      Finnhub::Economic_Code.new(client: self, code: code,
+        description: description)
+    end
+  end
+end