tradingview-screener 0.2.0

data/lib/tradingview_screener/client.rb

@@ -0,0 +1,206 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module TradingviewScreener
+  class Error < StandardError; end
+
+  class RequestError < Error
+    attr_reader :status, :body
+
+    def initialize(message, status: nil, body: nil)
+      super(message)
+      @status = status
+      @body = body
+    end
+  end
+
+  class Client
+    DEFAULT_HEADERS = {
+      "accept" => "application/json, text/plain, */*; q=0.01",
+      "content-type" => "text/plain;charset=UTF-8",
+      "origin" => "https://www.tradingview.com",
+      "referer" => "https://www.tradingview.com/",
+      "user-agent" => "tradingview-screener-rb/#{VERSION}"
+    }.freeze
+
+    attr_reader :timeout, :cookies, :headers, :label_product, :proxy
+
+    def initialize(timeout: 20, cookies: nil, headers: nil, label_product: "screener-stock", proxy: nil)
+      @timeout = timeout
+      @cookies = normalize_cookies(cookies)
+      @headers = DEFAULT_HEADERS.merge(stringify_keys(headers || {}))
+      @label_product = label_product
+      @proxy = normalize_proxy(proxy)
+    end
+
+    def get(url)
+      uri = URI(url)
+      request = Net::HTTP::Get.new(uri)
+      headers.each { |key, value| request[key] = value }
+      # HTML pages prefer browser-like accept; keep caller override if provided.
+      cookie = cookie_header
+      request["cookie"] = cookie unless cookie.nil? || cookie.empty?
+
+      response = perform(uri, request)
+      body = response.body.to_s
+      unless response.is_a?(Net::HTTPSuccess)
+        raise RequestError.new(
+          "request failed: HTTP #{response.code} #{response.message}",
+          status: response.code.to_i,
+          body: body
+        )
+      end
+      body
+    end
+
+    def post(url, payload)
+      uri = build_uri(url)
+      request = Net::HTTP::Post.new(uri)
+      headers.each { |key, value| request[key] = value }
+      cookie = cookie_header
+      request["cookie"] = cookie unless cookie.nil? || cookie.empty?
+      request.body = JSON.generate(payload)
+
+      response = perform(uri, request)
+      body = response.body.to_s
+      unless response.is_a?(Net::HTTPSuccess)
+        raise RequestError.new(
+          "scanner request failed: HTTP #{response.code} #{response.message}",
+          status: response.code.to_i,
+          body: body
+        )
+      end
+
+      JSON.parse(body)
+    rescue JSON::ParserError => e
+      raise RequestError.new("invalid scanner JSON: #{e.message}", status: response&.code&.to_i, body: body)
+    end
+
+    def perform(uri, request)
+      if socks_proxy?
+        request_via_socks(uri, request)
+      else
+        build_http(uri).request(request)
+      end
+    end
+
+    private
+
+    def build_uri(url)
+      uri = URI(url)
+      if label_product && !label_product.empty? && !uri.query.to_s.include?("label-product=")
+        params = URI.decode_www_form(uri.query.to_s) + [["label-product", label_product]]
+        uri.query = URI.encode_www_form(params)
+      end
+      uri
+    end
+
+    def build_http(uri)
+      http =
+        if http_proxy?
+          Net::HTTP::Proxy(
+            proxy["host"],
+            proxy["port"],
+            proxy["username"],
+            proxy["password"]
+          ).new(uri.host, uri.port)
+        else
+          Net::HTTP.new(uri.host, uri.port)
+        end
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = timeout
+      http.read_timeout = timeout
+      http
+    end
+
+    def request_via_socks(uri, request)
+      require "socksify/http"
+      http = Net::HTTP.SOCKSProxy(proxy["host"], proxy["port"]).new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == "https"
+      http.open_timeout = timeout
+      http.read_timeout = timeout
+      http.request(request)
+    rescue LoadError
+      raise Error, "socks proxy requires the socksify gem; add gem 'socksify' and bundle install"
+    end
+
+    def cookie_header
+      return if cookies.nil? || cookies.empty?
+
+      cookies.map { |key, value| "#{key}=#{value}" }.join("; ")
+    end
+
+    def normalize_cookies(value)
+      case value
+      when nil then {}
+      when Hash then stringify_keys(value)
+      when String
+        value.split(";").each_with_object({}) do |part, memo|
+          key, val = part.strip.split("=", 2)
+          next if key.nil? || key.empty? || val.nil?
+
+          memo[key] = val
+        end
+      else
+        raise ArgumentError, "cookies must be Hash or Cookie header String"
+      end
+    end
+
+    def normalize_proxy(value)
+      case value
+      when nil, ""
+        nil
+      when Hash
+        hash = stringify_keys(value)
+        scheme = (hash["scheme"] || hash["type"] || hash["value"] || "http").to_s.downcase
+        host = first_present(hash["host"], hash["hostname"], hash.dig("extra", "host"))
+        port = first_present(hash["port"], hash.dig("extra", "port"))
+        username = first_present(hash["username"], hash["user"], hash.dig("extra", "username"), hash.dig("extra", "id"))
+        password = first_present(hash["password"], hash["pass"], hash.dig("extra", "password"), hash.dig("extra", "secret"))
+        return nil if blank?(host) || blank?(port)
+
+        {
+          "scheme" => scheme,
+          "host" => host.to_s,
+          "port" => port.to_i,
+          "username" => username,
+          "password" => password
+        }.compact
+      when String
+        uri = URI.parse(value)
+        {
+          "scheme" => (blank?(uri.scheme) ? "http" : uri.scheme).to_s.downcase,
+          "host" => uri.host,
+          "port" => uri.port,
+          "username" => uri.user,
+          "password" => uri.password
+        }.compact
+      else
+        raise ArgumentError, "proxy must be Hash, URL String, or nil"
+      end
+    end
+
+    def http_proxy?
+      proxy && %w[http https].include?(proxy["scheme"].to_s)
+    end
+
+    def socks_proxy?
+      proxy && proxy["scheme"].to_s.start_with?("socks")
+    end
+
+    def stringify_keys(hash)
+      hash.each_with_object({}) { |(k, v), memo| memo[k.to_s] = v }
+    end
+
+    def blank?(value)
+      value.nil? || (value.respond_to?(:empty?) && value.empty?) || (value.is_a?(String) && value.strip.empty?)
+    end
+
+    def first_present(*values)
+      values.find { |value| !blank?(value) }
+    end
+  end
+end

data/lib/tradingview_screener/predicate.rb

@@ -0,0 +1,107 @@
+# frozen_string_literal: true
+
+module TradingviewScreener
+  # Arel-like column node used inside where().
+  #
+  #   Screener[:close].gt(Screener[:SMA20])
+  #   Screener[:volume].gte(1_000_000)
+  #   Screener[:close].between(10, 300)
+  class Predicate
+    attr_reader :left, :operation, :right
+
+    def initialize(left, operation, right = nil)
+      @left = left.to_s
+      @operation = operation.to_s
+      @right = unwrap(right)
+    end
+
+    def to_h
+      { "left" => left, "operation" => operation, "right" => right }
+    end
+
+    def inspect
+      "#<#{self.class} #{left} #{operation} #{right.inspect}>"
+    end
+
+    private
+
+    def unwrap(value)
+      case value
+      when Predicate then value.left
+      when Field then value.name
+      when Symbol then value.to_s
+      else value
+      end
+    end
+  end
+
+  class Field
+    attr_reader :name
+
+    def initialize(name)
+      @name = name.to_s
+    end
+
+    def gt(other) = Predicate.new(name, "greater", other)
+    def gte(other) = Predicate.new(name, "egreater", other)
+    def lt(other) = Predicate.new(name, "less", other)
+    def lte(other) = Predicate.new(name, "eless", other)
+    def eq(other) = Predicate.new(name, "equal", other)
+    def not_eq(other) = Predicate.new(name, "nequal", other)
+    def between(min, max) = Predicate.new(name, "in_range", [unwrap(min), unwrap(max)])
+    def not_between(min, max) = Predicate.new(name, "not_in_range", [unwrap(min), unwrap(max)])
+    def in(values) = Predicate.new(name, "in_range", Array(values))
+    def not_in(values) = Predicate.new(name, "not_in_range", Array(values))
+    def has(values) = Predicate.new(name, "has", values)
+    def has_none_of(values) = Predicate.new(name, "has_none_of", values)
+    def matches(value) = Predicate.new(name, "match", value)
+    def does_not_match(value) = Predicate.new(name, "nmatch", value)
+    def blank = Predicate.new(name, "empty", nil)
+    def present = Predicate.new(name, "nempty", nil)
+    def crosses(other) = Predicate.new(name, "crosses", other)
+    def crosses_above(other) = Predicate.new(name, "crosses_above", other)
+    def crosses_below(other) = Predicate.new(name, "crosses_below", other)
+
+    def >(other) = gt(other)
+    def >=(other) = gte(other)
+    def <(other) = lt(other)
+    def <=(other) = lte(other)
+    def ==(other) = eq(other)
+    def !=(other) = not_eq(other)
+
+    def inspect
+      "#<#{self.class} #{name}>"
+    end
+
+    private
+
+    def unwrap(value)
+      value.is_a?(Field) ? value.name : value
+    end
+  end
+
+  # Operator wrappers for hash-style where:
+  #   where(close: gt(:SMA20), volume: gte(1_000_000), price: 10..300)
+  module Predicates
+    module_function
+
+    def gt(value) = Op.new("greater", value)
+    def gte(value) = Op.new("egreater", value)
+    def lt(value) = Op.new("less", value)
+    def lte(value) = Op.new("eless", value)
+    def not_eq(value) = Op.new("nequal", value)
+    def has(value) = Op.new("has", value)
+    def has_none_of(value) = Op.new("has_none_of", value)
+
+    class Op
+      attr_reader :operation, :value
+
+      def initialize(operation, value)
+        @operation = operation
+        @value = value.is_a?(Field) || value.is_a?(Symbol) ? value.to_s.sub(/\A:/, "") : value
+        @value = value.name if value.is_a?(Field)
+        @value = value.to_s if value.is_a?(Symbol)
+      end
+    end
+  end
+end