twelvedata_ruby 0.1.1

data/lib/twelvedata_ruby/error.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module TwelvedataRuby
+  class Error < StandardError
+    DEFAULT_MSGS = {
+      "EndpointError" => "Endpoint is not valid. %{invalid}",
+      "EndpointNameError" => "`%{invalid}` is not a correct endpoint. Valid values are: `%{valid_names}`",
+      "EndpointParametersKeysError" => "Invalid parameters found: `%{invalid}`. Valid parameters for `%{name}` "\
+        "endpoint are: `%{parameters}`. Please see: `Twelvedata::Endpoint#parameters` for more details",
+      "EndpointRequiredParametersError" => "Missing values for required parameters: `%{invalid}`. "\
+        "`%{name}` endpoint required parameters are: `%{required}`.",
+      "ResponseError" => "Encountered an error from the response"
+    }.freeze
+
+    attr_reader :attrs
+
+    def initialize(args={})
+      @attrs = args[:attrs] || {}
+      super((args[:message] || DEFAULT_MSGS[Utils.demodulize(self.class)]) % @attrs)
+    end
+  end
+
+  class EndpointError < Error
+    def initialize(**args)
+      endpoint = args[:endpoint]
+      super(
+        attrs: {
+          name: endpoint.name,
+          invalid: args[:invalid],
+          valid_names: endpoint.class.names.join(", "),
+          parameters: endpoint&.parameters_keys&.send(:join, ", "),
+          required: endpoint&.required_parameters&.send(:join, ", ")
+        }
+      )
+    end
+  end
+
+  class EndpointNameError < EndpointError; end
+
+  class EndpointParametersKeysError < EndpointError; end
+
+  class EndpointRequiredParametersError < EndpointError; end
+
+  class ResponseError < Error
+    API_ERROR_CODES_MAP = {
+      400 => "BadRequestResponseError",
+      401 => "UnauthorizedResponseError",
+      403 => "ForbiddenResponseError",
+      404 => "NotFoundResponseError",
+      414 => "ParameterTooLongResponseError",
+      429 => "TooManyRequestsResponseError",
+      500 => "InternalServerResponseError"
+    }.freeze
+    HTTP_ERROR_CODES_MAP = {
+      404 => "PageNotFoundResponseError",
+    }.freeze
+
+    def self.error_code_klass(code, error_type=:api)
+      error_type = :api unless %i[api http].member?(error_type)
+
+      TwelvedataRuby::ResponseError.const_get("#{error_type.upcase}_ERROR_CODES_MAP")[code]
+    end
+
+    attr_reader :json, :code, :request
+
+    def initialize(json:, request:, attrs: nil, message: nil, code: nil)
+      @json = json.is_a?(Hash) ? json : {}
+      @code = code || @json[:code]
+      @attrs = attrs || {}
+      @request = request
+      super(attrs: @attrs, message: "#{@json[:message] || message}")
+    end
+  end
+
+  class BadRequestResponseError < ResponseError; end
+
+  class UnauthorizedResponseError < ResponseError; end
+
+  class ForbiddenResponseError < ResponseError; end
+
+  class NotFoundResponseError < ResponseError; end
+
+  class PageNotFoundResponseError < ResponseError; end
+
+  class ParameterTooLongResponseError < ResponseError; end
+
+  class TooManyRequestsResponseError < ResponseError; end
+
+  class InternalServerResponseErro < ResponseError; end
+end

data/lib/twelvedata_ruby/request.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require "forwardable"
+module TwelvedataRuby
+  class Request
+    extend Forwardable
+
+    DEFAULT_HTTP_VERB = :get
+
+    attr_reader :endpoint
+
+    def initialize(name, **query_params)
+      self.endpoint = Endpoint.new(name, **query_params)
+    end
+    def_delegators :endpoint, :name, :valid?, :query_params, :errors
+
+    def fetch
+      Client.instance.fetch(self)
+    end
+
+    def http_verb
+      return_nil_unless_valid { endpoint.definition[:http_verb] || DEFAULT_HTTP_VERB }
+    end
+
+    def params
+      {params: endpoint.query_params}
+    end
+
+    def relative_url
+      return_nil_unless_valid { name.to_s }
+    end
+
+    def full_url
+      return_nil_unless_valid { "#{Client.origin[:origin]}/#{relative_url}" }
+    end
+
+    def to_h
+      return_nil_unless_valid { {http_verb: http_verb, relative_url: relative_url}.merge(params: params) }
+    end
+
+    def to_a
+      return_nil_unless_valid { [http_verb, relative_url, params] }
+    end
+    alias build to_a
+
+    private
+
+    attr_writer :endpoint
+
+    def return_nil_unless_valid(&block)
+      Utils.return_nil_unless_true(valid?) { block.call }
+    end
+  end
+end

data/lib/twelvedata_ruby/response.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "csv"
+module TwelvedataRuby
+  class Response
+    CSV_COL_SEP = ";"
+    HTTP_STATUSES = {http_error: (400..600), success: (200..299)}.freeze
+    CONTENT_TYPE_HANDLERS = {
+      json: {parser: :json_parser, dumper: :json_dumper},
+      csv: {parser: :csv_parser, dumper: :csv_dumper},
+      plain: {parser: :plain_parser, dumper: :to_s}
+    }.freeze
+
+    class << self
+      def resolve(http_response, request)
+        if http_status_codes.member?(http_response.status)
+          new(http_response: http_response, request: request)
+        else
+          resolve_error(http_response, request)
+        end
+      end
+
+      def resolve_error(http_response, request)
+        error_attribs = if http_response.respond_to?(:error) && http_response.error
+                          {message: http_response.error.message, code: http_response.error.class.name}
+                        else
+                          {message: http_response.body.to_s, code: http_response.status}
+                        end
+        TwelvedataRuby::ResponseError.new(json: (error_attribs || {}), request: request)
+      end
+
+      def http_status_codes
+        @http_status_codes ||= HTTP_STATUSES.values.map(&:to_a).flatten
+      end
+    end
+
+    attr_reader :http_response, :headers, :body, :request
+
+    def initialize(http_response:, request:, headers: nil, body: nil)
+      self.http_response = http_response
+      self.headers = headers || http_response.headers
+      self.body = body || http_response.body
+    end
+
+    def attachment_filename
+      return nil unless headers["content-disposition"]
+
+      @attachment_filename ||= headers["content-disposition"].split("filename=").last.delete("\"")
+    end
+
+    def body_parser
+      CONTENT_TYPE_HANDLERS[content_type][:parser]
+    end
+
+    def content_type
+      @content_type ||= headers["content-type"].match(%r{^.+/([a-z]+).*$})&.send(:[], 1)&.to_sym
+    end
+
+    def csv_parser
+      chunk_parsed = nil
+      opts = {col_sep: CSV_COL_SEP}
+      body.each do |chk|
+        chunk_parsed = chunk_parsed&.send(:push, CSV.parse(chk, **opts)) || CSV.parse(chk, **opts.merge(headers: true))
+      end
+      chunk_parsed
+    end
+
+    def csv_dumper
+      parsed_body.is_a?(CSV::Table) ? parsed_body.to_csv : nil
+    end
+
+    def dumped_parsed_body
+      @dumped_parsed_body ||=
+        parsed_body.respond_to?(parsed_body_dumper) ? parsed_body.send(parsed_body_dumper) : send(parsed_body_dumper)
+    end
+
+    def error
+      klass_name = ResponseError.error_code_klass(status_code, success_http_status? ? :api : :http)
+      return unless klass_name
+      TwelvedataRuby.const_get(klass_name)
+        .new(json: parsed_body, request: request, code: status_code, message: parsed_body)
+    end
+
+    def http_status_code
+      http_response&.status
+    end
+
+    def json_dumper
+      parsed_body.is_a?(Hash) ? JSON.dump(parsed_body) : nil
+    end
+
+    def json_parser
+      JSON.parse(body, symbolize_names: true)
+    end
+
+    def parsed_body
+      @parsed_body ||= send(body_parser)
+    end
+
+    def parsed_body_dumper
+      CONTENT_TYPE_HANDLERS[content_type][:dumper]
+    end
+
+    def plain_parser
+      body.to_s
+    end
+
+    def status_code
+      @status_code ||= parsed_body.is_a?(Hash) ? parsed_body[:code] : http_status_code
+    end
+
+    def success_http_status?
+      @success_http_status ||= HTTP_STATUSES[:success].member?(http_status_code) || false
+    end
+
+    def to_disk_file(file_fullpath=attachment_filename)
+      return nil unless file_fullpath
+
+      begin
+        file = File.open(file_fullpath, "w")
+        file.puts dumped_parsed_body
+        file
+      ensure
+        file&.close
+      end
+    end
+
+    private
+
+    attr_writer :http_response, :headers, :body, :request
+  end
+end

data/lib/twelvedata_ruby/utils.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module TwelvedataRuby
+  module Utils
+    def self.demodulize(obj)
+      obj.to_s.gsub(/^.+::/, "")
+    end
+
+    # Converts a string to integer an all integer or nothing
+    def self.to_d(obj, default_value=nil)
+      return obj if obj.is_a?(Integer)
+
+      obj.to_s.match(/^\d+$/) {|m| Integer(m[0]) } || default_value
+    end
+
+    def self.camelize(str)
+      str.to_s.split("_").map(&:capitalize).join
+    end
+
+    def self.empty_to_nil(obj)
+      !obj.nil? && obj.empty? ? nil : obj
+    end
+
+    def self.to_a(objects)
+      objects.is_a?(Array) ? objects : [objects]
+    end
+
+    def self.call_block_if_truthy(truthy_val, return_this=nil, &block)
+      truthy_val ? block.call : return_this
+    end
+
+    def self.return_nil_unless_true(is_true, &block)
+      call_block_if_truthy(is_true == true) { block.call }
+    end
+  end
+end

data/twelvedata_ruby.gemspec

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative "lib/twelvedata_ruby"
+
+Gem::Specification.new do |spec|
+  spec.name = "twelvedata_ruby"
+  spec.version = TwelvedataRuby::VERSION
+  spec.authors = ["Kendo Camajalan, KCD"]
+  spec.email = ["ken.d.camajalan@pm.me"]
+  spec.summary = "A Ruby client library that provides helping hands in accessing Twelve Data API's stock, \
+                 forex, crypto, and other financial data"
+  spec.description = "A Ruby gem for accessing Twelve Data's API."
+  spec.homepage = "https://github.com/kanroyalhigh/twelvedata_ruby"
+  spec.license = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
+
+  # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["source_code_uri"] = "https://github.com/kanroyalhigh/twelvedata_ruby"
+  spec.metadata["changelog_uri"] = "https://github.com/kanroyalhigh/twelvedata_ruby/CHANGELOG.md"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject {|f| f.match(%r{\A(?:test|spec|features)/}) }
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{\Aexe/}) {|f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  spec.add_dependency "httpx", "~> 0.14.5"
+  spec.add_development_dependency "rake", "~> 13.0", ">= 13.0.3"
+  spec.add_development_dependency "rspec", "~> 3.10.0"
+  spec.add_development_dependency "rubocop", "~> 1.17.0"
+  spec.add_development_dependency "simplecov", "~> 0.21", ">= 0.21.2"
+  spec.add_development_dependency "webmock", "~> 3.13", ">= 3.13.0"
+end

metadata

@@ -0,0 +1,201 @@
+--- !ruby/object:Gem::Specification
+name: twelvedata_ruby
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Kendo Camajalan, KCD
+autorequire:
+bindir: exe
+cert_chain: []
+date: 2021-07-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httpx
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.14.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '13.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.3
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.0
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.17.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.17.0
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.21.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.21'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.21.2
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.13.0
+description: A Ruby gem for accessing Twelve Data's API.
+email:
+- ken.d.camajalan@pm.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- doc/TwelvedataRuby.html
+- doc/TwelvedataRuby/BadRequestResponseError.html
+- doc/TwelvedataRuby/Client.html
+- doc/TwelvedataRuby/Endpoint.html
+- doc/TwelvedataRuby/EndpointError.html
+- doc/TwelvedataRuby/EndpointNameError.html
+- doc/TwelvedataRuby/EndpointParametersKeysError.html
+- doc/TwelvedataRuby/EndpointRequiredParametersError.html
+- doc/TwelvedataRuby/Error.html
+- doc/TwelvedataRuby/ForbiddenResponseError.html
+- doc/TwelvedataRuby/InternalServerResponseErro.html
+- doc/TwelvedataRuby/NotFoundResponseError.html
+- doc/TwelvedataRuby/PageNotFoundResponseError.html
+- doc/TwelvedataRuby/ParameterTooLongResponseError.html
+- doc/TwelvedataRuby/Request.html
+- doc/TwelvedataRuby/Response.html
+- doc/TwelvedataRuby/ResponseError.html
+- doc/TwelvedataRuby/TooManyRequestsResponseError.html
+- doc/TwelvedataRuby/UnauthorizedResponseError.html
+- doc/TwelvedataRuby/Utils.html
+- doc/_index.html
+- doc/class_list.html
+- doc/css/common.css
+- doc/css/full_list.css
+- doc/css/style.css
+- doc/file.README.html
+- doc/file_list.html
+- doc/frames.html
+- doc/index.html
+- doc/js/app.js
+- doc/js/full_list.js
+- doc/js/jquery.js
+- doc/method_list.html
+- doc/top-level-namespace.html
+- lib/twelvedata_ruby.rb
+- lib/twelvedata_ruby/client.rb
+- lib/twelvedata_ruby/endpoint.rb
+- lib/twelvedata_ruby/error.rb
+- lib/twelvedata_ruby/request.rb
+- lib/twelvedata_ruby/response.rb
+- lib/twelvedata_ruby/utils.rb
+- twelvedata_ruby.gemspec
+homepage: https://github.com/kanroyalhigh/twelvedata_ruby
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/kanroyalhigh/twelvedata_ruby
+  source_code_uri: https://github.com/kanroyalhigh/twelvedata_ruby
+  changelog_uri: https://github.com/kanroyalhigh/twelvedata_ruby/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.4.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.15
+signing_key:
+specification_version: 4
+summary: A Ruby client library that provides helping hands in accessing Twelve Data
+  API's stock,                  forex, crypto, and other financial data
+test_files: []