repo stringlengths 5 92 | file_url stringlengths 80 287 | file_path stringlengths 5 197 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 7 values | commit_sha stringlengths 40 40 | retrieved_at stringdate 2026-01-04 15:37:27 2026-01-04 17:58:21 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/spec/dummy/config/boot.rb | spec/dummy/config/boot.rb | # Set up gems listed in the Gemfile.
ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../../../Gemfile', __FILE__)
require 'bundler/setup' if File.exists?(ENV['BUNDLE_GEMFILE'])
$LOAD_PATH.unshift File.expand_path('../../../../lib', __FILE__)
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/spec/dummy/config/initializers/filter_parameter_logging.rb | spec/dummy/config/initializers/filter_parameter_logging.rb | # Be sure to restart your server when you modify this file.
# Configure sensitive parameters which will be filtered from the log file.
Rails.application.config.filter_parameters += [:password]
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/spec/dummy/config/initializers/session_store.rb | spec/dummy/config/initializers/session_store.rb | # Be sure to restart your server when you modify this file.
Dummy::Application.config.session_store :cookie_store, key: '_dummy_session'
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/spec/dummy/config/initializers/wrap_parameters.rb | spec/dummy/config/initializers/wrap_parameters.rb | # Be sure to restart your server when you modify this file.
# This file contains settings for ActionController::ParamsWrapper which
# is enabled by default.
# Enable parameter wrapping for JSON. You can disable this by setting :format to an empty array.
ActiveSupport.on_load(:action_controller) do
wrap_parameters format: [:json] if respond_to?(:wrap_parameters)
end
# To enable root element in JSON for ActiveRecord objects.
# ActiveSupport.on_load(:active_record) do
# self.include_root_in_json = true
# end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/spec/dummy/config/initializers/inflections.rb | spec/dummy/config/initializers/inflections.rb | # Be sure to restart your server when you modify this file.
# Add new inflection rules using the following format. Inflections
# are locale specific, and you may define rules for as many different
# locales as you wish. All of these examples are active by default:
# ActiveSupport::Inflector.inflections(:en) do |inflect|
# inflect.plural /^(ox)$/i, '\1en'
# inflect.singular /^(ox)en/i, '\1'
# inflect.irregular 'person', 'people'
# inflect.uncountable %w( fish sheep )
# end
# These inflection rules are supported but not enabled by default:
# ActiveSupport::Inflector.inflections(:en) do |inflect|
# inflect.acronym 'RESTful'
# end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/spec/dummy/config/initializers/bitcoin_payable.rb | spec/dummy/config/initializers/bitcoin_payable.rb | BitcoinPayable.config.master_public_key = "tpubD6NzVbkrYhZ4X3cxCktWVsVvMDd35JbNdhzZxb1aeDCG7LfN6KbcDQsqiyJHMEQGJURRgdxGbFBBF32Brwb2LsfpE2jQfCZKwzNBBMosjfm"
BitcoinPayable.config.node_path = "m/0/"
BitcoinPayable.config.adapter = "blockchain_info" | ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/spec/dummy/config/initializers/backtrace_silencers.rb | spec/dummy/config/initializers/backtrace_silencers.rb | # Be sure to restart your server when you modify this file.
# You can add backtrace silencers for libraries that you're using but don't wish to see in your backtraces.
# Rails.backtrace_cleaner.add_silencer { |line| line =~ /my_noisy_library/ }
# You can also remove all the silencers if you're trying to debug a problem that might stem from framework code.
# Rails.backtrace_cleaner.remove_silencers!
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/spec/dummy/config/initializers/mime_types.rb | spec/dummy/config/initializers/mime_types.rb | # Be sure to restart your server when you modify this file.
# Add new mime types for use in respond_to blocks:
# Mime::Type.register "text/richtext", :rtf
# Mime::Type.register_alias "text/html", :iphone
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/spec/dummy/config/initializers/secret_token.rb | spec/dummy/config/initializers/secret_token.rb | # Be sure to restart your server when you modify this file.
# Your secret key is used for verifying the integrity of signed cookies.
# If you change this key, all old signed cookies will become invalid!
# Make sure the secret is at least 30 characters and all random,
# no regular words or you'll be exposed to dictionary attacks.
# You can use `rake secret` to generate a secure secret key.
# Make sure your secret_key_base is kept private
# if you're sharing your code publicly.
Dummy::Application.config.secret_key_base = '138c9dde72de8eb2544bc525694ea35b9cf95cb3703796f4c1863593c46838206cf9a0fb1872729d14c1fcf59cf22690c3777e9f66e15a30603a75f78da01498'
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/spec/dummy/config/environments/test.rb | spec/dummy/config/environments/test.rb | Dummy::Application.configure do
# Settings specified here will take precedence over those in config/application.rb.
# The test environment is used exclusively to run your application's
# test suite. You never need to work with it otherwise. Remember that
# your test database is "scratch space" for the test suite and is wiped
# and recreated between test runs. Don't rely on the data there!
config.cache_classes = true
# Do not eager load code on boot. This avoids loading your whole application
# just for the purpose of running a single test. If you are using a tool that
# preloads Rails for running tests, you may have to set it to true.
config.eager_load = false
# Configure static asset server for tests with Cache-Control for performance.
config.serve_static_assets = true
config.static_cache_control = "public, max-age=3600"
# Show full error reports and disable caching.
config.consider_all_requests_local = true
config.action_controller.perform_caching = false
# Raise exceptions instead of rendering exception templates.
config.action_dispatch.show_exceptions = false
# Disable request forgery protection in test environment.
config.action_controller.allow_forgery_protection = false
# Tell Action Mailer not to deliver emails to the real world.
# The :test delivery method accumulates sent emails in the
# ActionMailer::Base.deliveries array.
config.action_mailer.delivery_method = :test
# Print deprecation notices to the stderr.
config.active_support.deprecation = :stderr
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/spec/dummy/config/environments/development.rb | spec/dummy/config/environments/development.rb | Dummy::Application.configure do
# Settings specified here will take precedence over those in config/application.rb.
# In the development environment your application's code is reloaded on
# every request. This slows down response time but is perfect for development
# since you don't have to restart the web server when you make code changes.
config.cache_classes = false
# Do not eager load code on boot.
config.eager_load = false
# Show full error reports and disable caching.
config.consider_all_requests_local = true
config.action_controller.perform_caching = false
# Don't care if the mailer can't send.
config.action_mailer.raise_delivery_errors = false
# Print deprecation notices to the Rails logger.
config.active_support.deprecation = :log
# Raise an error on page load if there are pending migrations
config.active_record.migration_error = :page_load
# Debug mode disables concatenation and preprocessing of assets.
# This option may cause significant delays in view rendering with a large
# number of complex assets.
config.assets.debug = true
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/spec/dummy/config/environments/production.rb | spec/dummy/config/environments/production.rb | Dummy::Application.configure do
# Settings specified here will take precedence over those in config/application.rb.
# Code is not reloaded between requests.
config.cache_classes = true
# Eager load code on boot. This eager loads most of Rails and
# your application in memory, allowing both thread web servers
# and those relying on copy on write to perform better.
# Rake tasks automatically ignore this option for performance.
config.eager_load = true
# Full error reports are disabled and caching is turned on.
config.consider_all_requests_local = false
config.action_controller.perform_caching = true
# Enable Rack::Cache to put a simple HTTP cache in front of your application
# Add `rack-cache` to your Gemfile before enabling this.
# For large-scale production use, consider using a caching reverse proxy like nginx, varnish or squid.
# config.action_dispatch.rack_cache = true
# Disable Rails's static asset server (Apache or nginx will already do this).
config.serve_static_assets = false
# Compress JavaScripts and CSS.
config.assets.js_compressor = :uglifier
# config.assets.css_compressor = :sass
# Do not fallback to assets pipeline if a precompiled asset is missed.
config.assets.compile = false
# Generate digests for assets URLs.
config.assets.digest = true
# Version of your assets, change this if you want to expire all your assets.
config.assets.version = '1.0'
# Specifies the header that your server uses for sending files.
# config.action_dispatch.x_sendfile_header = "X-Sendfile" # for apache
# config.action_dispatch.x_sendfile_header = 'X-Accel-Redirect' # for nginx
# Force all access to the app over SSL, use Strict-Transport-Security, and use secure cookies.
# config.force_ssl = true
# Set to :debug to see everything in the log.
config.log_level = :info
# Prepend all log lines with the following tags.
# config.log_tags = [ :subdomain, :uuid ]
# Use a different logger for distributed setups.
# config.logger = ActiveSupport::TaggedLogging.new(SyslogLogger.new)
# Use a different cache store in production.
# config.cache_store = :mem_cache_store
# Enable serving of images, stylesheets, and JavaScripts from an asset server.
# config.action_controller.asset_host = "http://assets.example.com"
# Precompile additional assets.
# application.js, application.css, and all non-JS/CSS in app/assets folder are already added.
# config.assets.precompile += %w( search.js )
# Ignore bad email addresses and do not raise email delivery errors.
# Set this to true and configure the email server for immediate delivery to raise delivery errors.
# config.action_mailer.raise_delivery_errors = false
# Enable locale fallbacks for I18n (makes lookups for any locale fall back to
# the I18n.default_locale when a translation can not be found).
config.i18n.fallbacks = true
# Send deprecation notices to registered listeners.
config.active_support.deprecation = :notify
# Disable automatic flushing of the log to improve performance.
# config.autoflush_log = false
# Use default logging formatter so that PID and timestamp are not suppressed.
config.log_formatter = ::Logger::Formatter.new
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable.rb | lib/bitcoin_payable.rb | require 'net/http'
require 'interactor'
require 'bitcoin_payable/config'
require 'bitcoin_payable/version'
require 'bitcoin_payable/has_bitcoin_payment'
require 'bitcoin_payable/tasks'
require 'bitcoin_payable/bitcoin_calculator'
require 'bitcoin_payable/engine'
# Require all the adapter files
require 'bitcoin_payable/adapters/base'
require 'bitcoin_payable/adapters/blockchain_info_adapter'
require 'bitcoin_payable/adapters/blockcypher_adapter'
require 'bitcoin_payable/adapters/blocktrail_adapter'
require 'bitcoin_payable/adapters/btc_com_adapter'
require 'bitcoin_payable/adapters/bitcoind'
# Require all the interactor files
require 'bitcoin_payable/interactors/webhook_notification_processor'
require 'bitcoin_payable/interactors/transaction_processor/process_transaction'
require 'bitcoin_payable/interactors/transaction_processor/update_payment_amounts'
require 'bitcoin_payable/interactors/transaction_processor/organizer'
require 'bitcoin_payable/interactors/bitcoin_payment_processor/determine_payment_status'
require 'bitcoin_payable/interactors/bitcoin_payment_processor/process_transactions_for_payment'
module BitcoinPayable
def self.config(&block)
@@config ||= BitcoinPayable::Config.instance
block_given? ? block.call(@@config) : @@config
end
end
require 'bitcoin_payable/bitcoin_payment_transaction'
require "bitcoin_payable/address"
require 'bitcoin_payable/bitcoin_payment'
require 'bitcoin_payable/currency_conversion'
ActiveSupport.on_load(:active_record) do
include BitcoinPayable::Model
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/generators/bitcoin_payable/install_generator.rb | lib/generators/bitcoin_payable/install_generator.rb | require 'rails/generators'
require 'rails/generators/active_record'
module BitcoinPayable
class InstallGenerator < ::Rails::Generators::Base
include ::Rails::Generators::Migration
source_root File.expand_path('../templates', __FILE__)
desc 'Generates (but does not run) a migration to add a bitcoin payment tables.'
def create_migration_file
migration_template 'create_bitcoin_payments.rb', 'db/migrate/create_bitcoin_payments.rb', migration_version: migration_version
migration_template 'create_bitcoin_payment_transactions.rb', 'db/migrate/create_bitcoin_payment_transactions.rb', migration_version: migration_version
migration_template 'create_currency_conversions.rb', 'db/migrate/create_currency_conversions.rb', migration_version: migration_version
migration_template 'add_btc_conversion_to_bitcoin_payments.rb', 'db/migrate/add_btc_conversion_to_bitcoin_payments.rb', migration_version: migration_version
migration_template 'add_confirmations_to_bitcoin_payment_transactions.rb', 'db/migrate/add_confirmations_to_bitcoin_payment_transactions.rb', migration_version: migration_version
end
def self.next_migration_number(dirname)
::ActiveRecord::Generators::Base.next_migration_number(dirname)
end
def rails5?
Rails.version.start_with? '5'
end
def migration_version
if rails5?
"[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
end
end
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/generators/bitcoin_payable/templates/create_currency_conversions.rb | lib/generators/bitcoin_payable/templates/create_currency_conversions.rb | class CreateCurrencyConversions < ActiveRecord::Migration<%= migration_version %>
def change
create_table :currency_conversions do |t|
t.float "currency"
t.integer "btc"
t.datetime "created_at"
t.datetime "updated_at"
end
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/generators/bitcoin_payable/templates/create_bitcoin_payments.rb | lib/generators/bitcoin_payable/templates/create_bitcoin_payments.rb | class CreateBitcoinPayments < ActiveRecord::Migration<%= migration_version %>
def change
create_table :bitcoin_payments do |t|
t.string :payable_type
t.integer :payable_id
t.string :currency
t.string :reason
t.integer :price
t.float :btc_amount_due, default: 0
t.string :address
t.string :state
t.datetime :created_at
t.datetime :updated_at
end
add_index :bitcoin_payments, [:payable_type, :payable_id]
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/generators/bitcoin_payable/templates/add_confirmations_to_bitcoin_payment_transactions.rb | lib/generators/bitcoin_payable/templates/add_confirmations_to_bitcoin_payment_transactions.rb | class AddConfirmationsToBitcoinPaymentTransactions < ActiveRecord::Migration<%= migration_version %>
def change
add_column :bitcoin_payment_transactions, :confirmations, :integer, default: 0
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/generators/bitcoin_payable/templates/add_btc_conversion_to_bitcoin_payments.rb | lib/generators/bitcoin_payable/templates/add_btc_conversion_to_bitcoin_payments.rb | class AddBtcConversionToBitcoinPayments < ActiveRecord::Migration<%= migration_version %>
def change
add_column :bitcoin_payments, :btc_conversion, :integer
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/generators/bitcoin_payable/templates/create_bitcoin_payment_transactions.rb | lib/generators/bitcoin_payable/templates/create_bitcoin_payment_transactions.rb | class CreateBitcoinPaymentTransactions < ActiveRecord::Migration<%= migration_version %>
def change
create_table :bitcoin_payment_transactions do |t|
t.integer :estimated_value
t.string :transaction_hash
t.string :block_hash
t.datetime :block_time
t.datetime :estimated_time
t.integer :bitcoin_payment_id
t.integer :btc_conversion
end
add_index :bitcoin_payment_transactions, :bitcoin_payment_id
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/version.rb | lib/bitcoin_payable/version.rb | module BitcoinPayable
VERSION = "0.7.53"
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/currency_conversion.rb | lib/bitcoin_payable/currency_conversion.rb | module BitcoinPayable
class CurrencyConversion < ::ActiveRecord::Base
validates :btc, presence: true
end
end | ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/bitcoin_payment.rb | lib/bitcoin_payable/bitcoin_payment.rb | #require 'bitcoin-addrgen'
require 'money-tree'
require 'aasm'
module BitcoinPayable
class BitcoinPayment < ::ActiveRecord::Base
include AASM
belongs_to :payable, polymorphic: true
has_many :transactions, class_name: "BitcoinPayable::BitcoinPaymentTransaction"
validates :reason, presence: true
validates :price, presence: true
before_create :populate_currency_and_amount_due
after_create :populate_address
after_create :subscribe_to_address_push_notifications, if: :webhooks_enabled
aasm :column => 'state' do
state :pending, :initial => true
state :partial_payment, :paid_in_full, :comped, :confirmed
after_all_transitions :notify_status_changed
event :confirm do
transitions :from => [:pending, :paid_in_full, :partial_payment], :to => :confirmed
end
event :paid do
after do
notify_payable
# desubscribe_tx_notifications
end
transitions :from => [:pending, :partial_payment], :to => :paid_in_full
end
event :partially_paid do
transitions :from => :pending, :to => :partial_payment
end
event :comp do
after do
notify_payable
end
transitions :from => [:pending, :partial_payment], :to => :comped
end
end
def all_transactions_confirmed?
self.transactions.all?{|tx| tx.confirmed?}
end
def currency_amount_paid
# => Round to 0 decimal places so there aren't any partial cents
self.transactions.inject(0) { |sum, tx| sum + (BitcoinPayable::BitcoinCalculator.convert_satoshis_to_bitcoin(tx.estimated_value) * tx.btc_conversion) }.round(0)
end
def currency_amount_due
self.price - currency_amount_paid
end
def calculate_btc_amount_due
btc_rate = BitcoinPayable::CurrencyConversion.last.btc
BitcoinPayable::BitcoinCalculator.exchange_price currency_amount_due, btc_rate
end
private
def populate_currency_and_amount_due
self.currency ||= BitcoinPayable.config.currency
self.btc_amount_due = calculate_btc_amount_due
self.btc_conversion = CurrencyConversion.last.btc
end
def populate_address
self.update(address: Address.create(self.id))
end
def notify_status_changed
if self.payable.respond_to?(:bitcoin_payment_status_changed)
self.payable.bitcoin_payment_status_changed(aasm.from_state, aasm.to_state)
end
end
def notify_payable
if self.payable.respond_to?(:bitcoin_payment_paid)
self.payable.bitcoin_payment_paid
end
end
# Subscribe to a push notification that will alert us via a webhook when a transaction is received for this address
def subscribe_to_address_push_notifications
adapter = BitcoinPayable::Adapters::Base.fetch_adapter
adapter.subscribe_to_address_push_notifications(self)
end
def webhooks_enabled
BitcoinPayable.config.allowwebhooks
end
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/address.rb | lib/bitcoin_payable/address.rb | module BitcoinPayable
class Address
def self.create(id)
if BitcoinPayable.config.master_public_key
master = MoneyTree::Node.from_serialized_address BitcoinPayable.config.master_public_key
node = master.node_for_path BitcoinPayable.config.node_path + id.to_s
else
raise "MASTER_SEED or MASTER_PUBLIC_KEY is required"
end
node.to_address(network: BitcoinPayable.config.network)
end
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/bitcoin_calculator.rb | lib/bitcoin_payable/bitcoin_calculator.rb | module BitcoinPayable
class BitcoinCalculator
def self.convert_satoshis_to_bitcoin(satoshis)
satoshis * 0.00000001
end
def self.convert_bitcoins_to_satoshis(bitcoins)
bitcoins / 0.00000001
end
def self.exchange_price(price, exchange_rate)
(price.to_f / exchange_rate.to_f).round(8)
end
end
end | ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/config.rb | lib/bitcoin_payable/config.rb | require 'singleton'
module BitcoinPayable
class Config
include Singleton
attr_accessor(
# Core
:master_public_key,
:node_path,
:currency,
:adapter,
:adapter_api_key,
:testnet,
:confirmations,
:payment_variance,
:processing_days,
:adapter_url,
:request_delay,
# Pricing
:bitcoinaverage_key,
:open_exchange_key,
:rate_calculation,
# Webhooks
:allowwebhooks,
:webhook_subdomain,
:webhook_domain,
:webhook_port
)
def initialize
@currency ||= :cad
@confirmations ||= 6
@rate_calculation ||= :daily_average
@request_delay ||= 0.5
# Allow a number of cents difference between price and payment amount
# to account for payments very close to the price.
# Even though we honour the price for 30 minutes,
# there will still be payments made close to the time limit that are very close to the amount due.
@payment_variance ||= 0
# Only process payments once for the last X number of days
@processing_days ||= 30
end
def network
@testnet == false ? :bitcoin : :bitcoin_testnet
end
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/has_bitcoin_payment.rb | lib/bitcoin_payable/has_bitcoin_payment.rb | module BitcoinPayable
module Model
def self.included(base)
base.send :extend, ClassMethods
end
module ClassMethods
def has_bitcoin_payments(options = {})
has_many :bitcoin_payments, -> {order(:id)}, class_name: "BitcoinPayable::BitcoinPayment", as: 'payable'
end
end
end
end | ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/tasks.rb | lib/bitcoin_payable/tasks.rb | require 'rake'
require 'bitcoin_payable/commands/pricing_processor'
require 'bitcoin_payable/commands/payment_processor'
namespace :bitcoin_payable do
desc "Process the prices and update the payments"
task :process_prices => :environment do
BitcoinPayable::PricingProcessor.perform
end
desc "Connect to HelloBlock.io and process payments"
task :process_payments => :environment do
BitcoinPayable::PaymentProcessor.perform
end
end | ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/engine.rb | lib/bitcoin_payable/engine.rb | module BitcoinPayable
class Engine < Rails::Engine; end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/bitcoin_payment_transaction.rb | lib/bitcoin_payable/bitcoin_payment_transaction.rb | module BitcoinPayable
class BitcoinPaymentTransaction < ::ActiveRecord::Base
belongs_to :bitcoin_payment
before_save :add_conversion
def add_conversion
adapter = BitcoinPayable::Adapters::Base.fetch_adapter
self.btc_conversion ||= bitcoin_payment.btc_conversion
end
def confirmed?
self.confirmations.to_i >= BitcoinPayable.config.confirmations
end
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/commands/payment_processor.rb | lib/bitcoin_payable/commands/payment_processor.rb | module BitcoinPayable
class PaymentProcessor
def self.perform
new.perform
end
def perform
BitcoinPayable::BitcoinPayment.
where(state: [:pending, :partial_payment, :paid_in_full]).
where("created_at > ?", (BitcoinPayable.config.processing_days.to_i).days.ago).each do |payment|
sleep_amount = BitcoinPayable.config.request_delay.to_f
begin
puts "Checking address: #{ payment.address }"
BitcoinPayable::Interactors::BitcoinPaymentProcessor::ProcessTransactionsForPayment.call(
payment: payment
)
rescue JSON::ParserError
# Back off for 60 seconds as most APIs throttle in request/min window
sleep_amount = 60
puts "Error processing response from server. Possible API issue or your Quota has been exceeded"
end
# Cloudflare limits requests to 1200 req / 5 minutes
# or 4 requests / 1 second
# So we will sleep for 500ms after each request by default
sleep(sleep_amount)
end
end
end
end | ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/commands/pricing_processor.rb | lib/bitcoin_payable/commands/pricing_processor.rb | module BitcoinPayable
class PricingProcessor
def self.perform
new.perform
end
def perform
# => Store three previous price ranges
# => get_currency TODO: enable this again
# => Defaulting to 1.00 for now
rate = CurrencyConversion.create!(currency: 1.00, btc: get_btc)
# => Loop through all unpaid payments and update them with the new price
# => If it has been 20 mins since they have been updated
BitcoinPayable::BitcoinPayment.where(state: ['pending', 'partial_payment']).where("updated_at < ? OR btc_amount_due = 0", 30.minutes.ago).each do |bp|
bp.update!(btc_amount_due: bp.calculate_btc_amount_due, btc_conversion: rate.btc)
end
end
def get_btc
uri = URI.parse("https://apiv2.bitcoinaverage.com/indices/local/ticker/BTC#{BitcoinPayable.config.currency.to_s.upcase}")
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri.request_uri)
request["x-ba-key"] = BitcoinPayable.config.bitcoinaverage_key
response = http.request(request)
hash = JSON.parse(response.body)
prices = {
last: hash["last"],
high: hash["high"],
low: hash["low"],
daily_average: hash["averages"]["day"],
weekly_average: hash["averages"]["week"],
monthly_average: hash["averages"]["month"]
}
rate = prices[BitcoinPayable.config.rate_calculation] || prices[:daily_average]
rate.to_f * 100.00
end
def get_currency
#uri = URI("http://rate-exchange.appspot.com/currency?from=#{BitcoinPayable.config.currency}&to=USD")
#rate = JSON.parse(Net::HTTP.get(uri))["rate"]
uri = URI("http://openexchangerates.org/api/latest.json?app_id=#{BitcoinPayable.config.open_exchange_key}")
response = JSON.parse(Net::HTTP.get(uri))
response["rates"][BitcoinPayable.config.currency.to_s.upcase]
end
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/interactors/webhook_notification_processor.rb | lib/bitcoin_payable/interactors/webhook_notification_processor.rb | module BitcoinPayable::Interactors
class WebhookNotificationProcessor
include Interactor
def call
adapter = BitcoinPayable::Adapters::Base.fetch_adapter
bitcoin_payment = BitcoinPayable::BitcoinPayment.find(context.params[:bitcoin_payment_id])
address = context.params[:addresses].keys.last
if bitcoin_payment && bitcoin_payment.address == address
transaction = adapter.convert_transactions(context.params, address)
BitcoinPayable::Interactors::TransactionProcessor::Organizer.call(
bitcoin_payment: bitcoin_payment,
transaction: transaction
)
BitcoinPayable::Interactors::BitcoinPaymentProcessor::DeterminePaymentStatus.call(
bitcoin_payment: bitcoin_payment
)
end
end
end
end | ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/interactors/bitcoin_payment_processor/determine_payment_status.rb | lib/bitcoin_payable/interactors/bitcoin_payment_processor/determine_payment_status.rb | module BitcoinPayable::Interactors::BitcoinPaymentProcessor
class DeterminePaymentStatus
include Interactor
def call
fiat_paid = context.bitcoin_payment.currency_amount_paid
if fiat_paid >= [(context.bitcoin_payment.price - BitcoinPayable.config.payment_variance), 0].max
handle_paid_in_full unless context.bitcoin_payment.confirmed?
elsif fiat_paid > 0
handle_partial_paid
end
end
private
def handle_paid_in_full
if context.bitcoin_payment.all_transactions_confirmed?
# This payment is already paid in full, we should check the confirmation count
context.bitcoin_payment.confirm!
elsif !context.bitcoin_payment.paid_in_full?
# This payment has not been marked as paid yet, let's mark it
context.bitcoin_payment.paid!
end
end
def handle_partial_paid
unless context.bitcoin_payment.partial_payment?
context.bitcoin_payment.partially_paid!
end
end
end
end | ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/interactors/bitcoin_payment_processor/process_transactions_for_payment.rb | lib/bitcoin_payable/interactors/bitcoin_payment_processor/process_transactions_for_payment.rb | module BitcoinPayable::Interactors::BitcoinPaymentProcessor
class ProcessTransactionsForPayment
include Interactor
def call
adapter = BitcoinPayable::Adapters::Base.fetch_adapter
adapter.fetch_transactions_for_address(context.payment.address).each do |tx|
next if tx.nil?
BitcoinPayable::Interactors::TransactionProcessor::Organizer.call(
bitcoin_payment: context.payment,
transaction: tx
)
end
# Determine the status of this payment even if there are no transactions
# Could be comped or discounted
BitcoinPayable::Interactors::BitcoinPaymentProcessor::DeterminePaymentStatus.call(
bitcoin_payment: context.payment
)
end
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/interactors/transaction_processor/update_payment_amounts.rb | lib/bitcoin_payable/interactors/transaction_processor/update_payment_amounts.rb | module BitcoinPayable::Interactors::TransactionProcessor
class UpdatePaymentAmounts
include Interactor
def call
context.bitcoin_payment.update_attributes(
btc_amount_due: context.bitcoin_payment.calculate_btc_amount_due,
btc_conversion: BitcoinPayable::CurrencyConversion.last.btc
)
end
end
end | ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/interactors/transaction_processor/organizer.rb | lib/bitcoin_payable/interactors/transaction_processor/organizer.rb | module BitcoinPayable::Interactors::TransactionProcessor
class Organizer
include Interactor::Organizer
organize [
BitcoinPayable::Interactors::TransactionProcessor::ProcessTransaction,
BitcoinPayable::Interactors::TransactionProcessor::UpdatePaymentAmounts
]
end
end | ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/interactors/transaction_processor/process_transaction.rb | lib/bitcoin_payable/interactors/transaction_processor/process_transaction.rb | module BitcoinPayable::Interactors::TransactionProcessor
class ProcessTransaction
include Interactor
def call
context.bitcoin_payment_transaction = context.bitcoin_payment.transactions.find_by_transaction_hash(context.transaction[:txHash])
if context.bitcoin_payment_transaction
# We have this transaction, update it's number of confirmations
context.bitcoin_payment_transaction.update(confirmations: context.transaction[:confirmations])
else
# We have never seen this transaction, let's create it
context.bitcoin_payment_transaction = context.bitcoin_payment.transactions.create!(
estimated_value: context.transaction[:estimatedTxValue],
transaction_hash: context.transaction[:txHash],
block_hash: context.transaction[:blockHash],
block_time: (Time.at(context.transaction[:blockTime]) if context.transaction[:blockTime]),
estimated_time: (Time.at(context.transaction[:estimatedTxTime]) if context.transaction[:estimatedTxTime]),
btc_conversion: context.bitcoin_payment.btc_conversion,
confirmations: context.transaction[:confirmations]
)
end
end
end
end | ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/adapters/blockcypher_adapter.rb | lib/bitcoin_payable/adapters/blockcypher_adapter.rb | require 'blockcypher'
module BitcoinPayable::Adapters
class BlockcypherAdapter < Base
def initialize
if BitcoinPayable.config.testnet
@blockcypher = BlockCypher::Api.new(network: BlockCypher::TEST_NET_3)
else
@blockcypher = BlockCypher::Api.new
end
super
end
def fetch_transactions_for_address(address)
address_full_txs = @blockcypher.address_full_txs(address)
address_full_txs['txs'].map{|tx| convert_transactions(tx, address)}
end
private
def convert_transactions(transaction, address)
{
txHash: transaction["hash"],
blockHash: transaction["block_hash"],
blockTime: DateTime.iso8601(transaction["confirmed"]),
estimatedTxTime: DateTime.iso8601(transaction["received"]),
estimatedTxValue: transaction['outputs'].sum{|out| out['addresses'].join.eql?(address) ? out["value"] : 0},
confirmations: transaction["confirmations"]
}
end
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/adapters/blockchain_info_adapter.rb | lib/bitcoin_payable/adapters/blockchain_info_adapter.rb | module BitcoinPayable::Adapters
class BlockchainInfoAdapter < Base
def initialize
if BitcoinPayable.config.testnet
raise "Testnet not supported"
else
@url = "https://blockchain.info"
end
end
def fetch_transactions_for_address(address)
url = "#{@url}/rawaddr/#{address}"
url += "?api_code=" + BitcoinPayable.config.adapter_api_key if BitcoinPayable.config.adapter_api_key
uri = URI.parse(url)
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri.request_uri)
response = http.request(request)
hash = JSON.parse(response.body)
hash['txs'].map{|tx| convert_transactions(tx, address)}
end
private
def latest_block
url = "#{@url}/latestblock"
url += "?api_code=" + BitcoinPayable.config.adapter_api_key if BitcoinPayable.config.adapter_api_key
uri = URI.parse(url)
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri.request_uri)
response = http.request(request)
JSON.parse(response.body)
end
def convert_transactions(transaction, address)
confirmations = latest_block["height"].to_i - transaction["block_height"].to_i + 1
{
txHash: transaction["hash"],
blockHash: nil, # Not supported
blockTime: nil, # Not supported
estimatedTxTime: transaction["time"],
estimatedTxValue: transaction['out'].sum{|out| out['addr'].eql?(address) ? out["value"] : 0},
confirmations: confirmations
}
end
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/adapters/btc_com_adapter.rb | lib/bitcoin_payable/adapters/btc_com_adapter.rb | require 'blockcypher'
module BitcoinPayable::Adapters
class BtcComAdapter < Base
def initialize
if BitcoinPayable.config.testnet
raise "Testnet not supported"
else
@url = "https://chain.api.btc.com"
end
end
def fetch_transactions_for_address(address)
url = "#{@url}/v3/address/#{address}/tx"
url += "?api_key=" + BitcoinPayable.config.adapter_api_key if BitcoinPayable.config.adapter_api_key
uri = URI.parse(url)
http = Net::HTTP.new(uri.host, uri.port)
http.use_ssl = true
request = Net::HTTP::Get.new(uri.request_uri)
response = http.request(request)
hash = JSON.parse(response.body)
if hash["data"] && hash['data']["list"]
hash['data']["list"].map{|tx| convert_transactions(tx, address)}
else
[]
end
end
private
def convert_transactions(transaction, address)
{
txHash: transaction["hash"],
blockHash: transaction["block_hash"],
blockTime: transaction["block_time"],
estimatedTxTime: transaction["created_at"],
estimatedTxValue: transaction["balance_diff"],
confirmations: transaction["confirmations"]
}
end
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/adapters/blocktrail_adapter.rb | lib/bitcoin_payable/adapters/blocktrail_adapter.rb | require 'blocktrail'
module BitcoinPayable::Adapters
class BlocktrailAdapter < Base
def initialize
if BitcoinPayable.config.testnet
@client ||= Blocktrail::Client.new(testnet: true)
else
@client ||= Blocktrail::Client.new
end
super
end
def fetch_transactions_for_address(address)
transactions = @client.address_transactions(address)
transactions["data"].map do |tx|
convert_transactions(
{"data" => tx},
address
)
end
end
def convert_transactions(transaction, address)
tx_data = transaction["data"]
{
txHash: tx_data["hash"],
blockHash: tx_data["block_hash"],
blockTime: (tx_data["block_time"] ? DateTime.parse(tx_data["block_time"]).to_time.to_i : nil),
confirmations: tx_data["confirmations"],
estimatedTxTime: (tx_data["first_seen_at"] ? DateTime.parse(tx_data["first_seen_at"]).to_time.to_i : nil),
estimatedTxValue: tx_data["estimated_value"]
}
end
# Create a Blocktrail subscription for this address
def subscribe_to_address_push_notifications(payment)
# Update the webhook to tell Blocktrail where to post to when a transaction is received
@client.setup_webhook(
webhook_url(payment),
payment.id
)
# Subscribe to the address to the webhook
@client.subscribe_address_transactions(
payment.id,
payment.address,
BitcoinPayable.config.confirmations
)
end
# Unsubscribe from the Blocktrail subscription for this address
def unsubscribe_to_address_push_notifications(payment)
@client.unsubscribe_address_transactions(payment.id, payment.address)
rescue Blocktrail::Exceptions::ObjectNotFound => e
puts "Blocktrail subscription for address #{address} not found: #{e}"
end
private
def webhook_url(payment)
Rails.application.routes.url_for(
user: ENV['BITCOIN_PAYABLE_WEBHOOK_USER'],
password: ENV['BITCOIN_PAYABLE_WEBHOOK_PASS'],
controller: "bitcoin_payable/bitcoin_payment_transaction",
action: "notify_transaction",
bitcoin_payment_id: payment.id,
host: BitcoinPayable.config.webhook_domain
)
end
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/adapters/base.rb | lib/bitcoin_payable/adapters/base.rb | module BitcoinPayable::Adapters
class Base
def self.fetch_adapter
if BitcoinPayable.config.adapter.blank?
raise "Please specify an adapter"
else
api = BitcoinPayable.config.adapter
adapter_class = api.camelize + 'Adapter'
adapter_class = BitcoinPayable::Adapters.const_get(adapter_class)
adapter = adapter_class.new
end
end
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/lib/bitcoin_payable/adapters/bitcoind.rb | lib/bitcoin_payable/adapters/bitcoind.rb | module BitcoinPayable::Adapters
class BitcoindAdapter < Base
def initialize
if BitcoinPayable.config.testnet
raise "Testnet not supported"
else
@uri = URI.parse(BitcoinPayable.config.adapter_url)
end
end
def fetch_transactions_for_address(address)
post_body = { 'method' => 'query', 'params' => address, 'id' => 'jsonrpc' }.to_json
http = Net::HTTP.new(@uri.host, @uri.port)
request = Net::HTTP::Post.new(@uri.request_uri)
request.basic_auth @uri.user, @uri.password
request.content_type = 'application/json'
request.body = post_body
response = http.request(request).body
puts response.inspect
end
private
def convert_transactions(transaction, address)
{
txHash: transaction["hash"],
blockHash: transaction["block_hash"],
blockTime: transaction["block_time"],
estimatedTxTime: transaction["created_at"],
estimatedTxValue: transaction['outputs'].sum{|out| out['addresses'].join.eql?(address) ? out["value"] : 0},
confirmations: transaction["confirmations"]
}
end
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
Sailias/bitcoin_payable | https://github.com/Sailias/bitcoin_payable/blob/14e8c4fb9e2bc181869ea9fb76c97b78ecea429b/config/routes.rb | config/routes.rb | Rails.application.routes.draw do
if BitcoinPayable.config.allowwebhooks
post 'bitcoin_payable/notify_transaction/:bitcoin_payment_id', to: 'bitcoin_payable/bitcoin_payment_transaction#notify_transaction'
end
end
| ruby | MIT | 14e8c4fb9e2bc181869ea9fb76c97b78ecea429b | 2026-01-04T17:57:32.429118Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/spec/spec_helper.rb | spec/spec_helper.rb | # frozen_string_literal: true
require "simplecov"
SimpleCov.add_filter "spec"
SimpleCov.add_filter "version"
if ENV["CI"] || ENV["TRAVIS"] || ENV["COVERALLS"] || ENV["JENKINS_URL"]
require "coveralls"
Coveralls.wear!
else
SimpleCov.start
end
require "bundler/setup"
Bundler.setup
require "proxy_fetcher"
Dir["./spec/support/**/*.rb"].sort.each { |f| require f }
adapter = ENV["BUNDLE_GEMFILE"][%r{.+/(.+)\.gemfile}i, 1] || :nokogiri
puts "Configured adapter: '#{adapter}'"
ProxyFetcher.configure do |config|
config.adapter = adapter
end
RSpec.configure do |config|
config.order = "random"
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/spec/support/manager_examples.rb | spec/support/manager_examples.rb | # frozen_string_literal: true
RSpec.shared_examples "a manager" do
before :all do
@cached_manager = ProxyFetcher::Manager.new
end
it "loads proxy list on initialization by default" do
expect(@cached_manager.proxies).not_to be_empty
end
it "doesn't load proxy list on initialization if `refresh` argument was set to false" do
manager = ProxyFetcher::Manager.new(refresh: false)
expect(manager.proxies).to be_empty
end
it "returns valid Proxy objects" do
expect(@cached_manager.proxies).to all(be_a(ProxyFetcher::Proxy))
@cached_manager.proxies.each do |proxy|
expect(proxy.addr).to match(/\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/i)
expect(proxy.port).to be_a_kind_of(Numeric)
expect(proxy.type).not_to be_empty
expect(proxy.country).not_to be_empty
expect(proxy.anonymity).not_to be_empty
expect(proxy.response_time).to be_nil.or(be_a_kind_of(Numeric))
end
end
it "returns raw proxies (HOST:PORT)" do
expect(@cached_manager.raw_proxies).to all(be_a(String))
end
it "cleanup proxy list from dead servers" do
allow_any_instance_of(ProxyFetcher::Proxy).to receive(:connectable?).and_return(false)
manager = ProxyFetcher::Manager.new
expect do
manager.cleanup!
end.to change { manager.proxies }.to([])
end
it "doesn't pollute the output with array of proxies" do
manager = ProxyFetcher::Manager.new(refresh: false)
expect(manager.inspect).to eq(manager.to_s)
end
it "returns first proxy" do
manager = ProxyFetcher::Manager.new
first_proxy = manager.proxies.first
expect(manager.get).to eq(first_proxy)
expect(manager.proxies.first).not_to eq(first_proxy)
end
it "returns first valid proxy" do
manager = ProxyFetcher::Manager.new(refresh: false)
proxies = Array.new(5) { instance_double("ProxyFetcher::Proxy", connectable?: false) }
manager.instance_variable_set(:@proxies, proxies)
connectable_proxy = instance_double("ProxyFetcher::Proxy")
allow(connectable_proxy).to receive(:connectable?).and_return(true)
manager.proxies[0..2].each { |proxy| proxy.instance_variable_set(:@addr, "192.168.1.1") }
manager.proxies[2] = connectable_proxy
expect(manager.get!).to eq(connectable_proxy)
expect(manager.proxies.size).to be(3)
expect(manager.get!).to eq(connectable_proxy)
expect(manager.proxies.size).to be(1)
end
it "returns nothing if proxy list is empty" do
manager = ProxyFetcher::Manager.new(refresh: false)
expect(manager.get).to be_nil
expect(manager.get!).to be_nil
end
it "returns random proxy" do
expect(@cached_manager.random).to be_an_instance_of(ProxyFetcher::Proxy)
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/spec/proxy_fetcher/version_spec.rb | spec/proxy_fetcher/version_spec.rb | # frozen_string_literal: true
RSpec.describe ProxyFetcher::VERSION do
it { expect(ProxyFetcher::VERSION::STRING).to match(/^\d+\.\d+\.\d+(\.\w+)?$/) }
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/spec/proxy_fetcher/proxy_spec.rb | spec/proxy_fetcher/proxy_spec.rb | # frozen_string_literal: true
require "spec_helper"
describe ProxyFetcher::Proxy do
let(:proxy) { described_class.new(addr: "192.169.1.1", port: 8080, type: "HTTP") }
it "can initialize a new proxy object" do
proxy = described_class.new(addr: "192.169.1.1", port: 8080, type: "HTTP")
expect(proxy).not_to be_nil
expect(proxy.addr).to eq("192.169.1.1")
expect(proxy.port).to eq(8080)
expect(proxy.type).to eq("HTTP")
end
it "checks schema" do
proxy.type = ProxyFetcher::Proxy::HTTP
expect(proxy.http?).to be_truthy
expect(proxy.https?).to be_falsey
expect(proxy.ssl?).to be_falsey
proxy.type = ProxyFetcher::Proxy::HTTPS
expect(proxy.https?).to be_truthy
expect(proxy.http?).to be_truthy
expect(proxy.ssl?).to be_truthy
proxy.type = ProxyFetcher::Proxy::SOCKS4
expect(proxy.socks4?).to be_truthy
expect(proxy.ssl?).to be_truthy
proxy.type = ProxyFetcher::Proxy::SOCKS5
expect(proxy.socks5?).to be_truthy
expect(proxy.ssl?).to be_truthy
end
it "not connectable if IP addr is wrong" do
proxy.addr = "192.168.1.0"
expect(proxy.connectable?).to be_falsey
end
it "not connectable if there are some error during connection request" do
allow_any_instance_of(HTTP::Client).to receive(:head).and_raise(HTTP::TimeoutError)
expect(proxy.connectable?).to be_falsey
end
it "returns URI::Generic" do
expect(proxy.uri).to be_a(URI::Generic)
expect(proxy.uri.host).not_to be_empty
expect(proxy.uri.port).not_to be_nil
end
it "returns URL" do
expect(proxy.url).to be_a(String)
end
it "returns URL with scheme" do
expect(proxy.url(scheme: true)).to include("://")
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/spec/proxy_fetcher/configuration_spec.rb | spec/proxy_fetcher/configuration_spec.rb | # frozen_string_literal: true
require "spec_helper"
describe ProxyFetcher::Configuration do
before { ProxyFetcher.config.reset! }
after { ProxyFetcher.config.reset! }
context "custom HTTP client" do
it "successfully setups if class has all the required methods" do
class MyHTTPClient
def self.fetch(url)
url
end
end
expect { ProxyFetcher.config.http_client = MyHTTPClient }.not_to raise_error
end
it "failed on setup if required methods are missing" do
MyWrongHTTPClient = Class.new
expect { ProxyFetcher.config.http_client = MyWrongHTTPClient }
.to raise_error(ProxyFetcher::Exceptions::WrongCustomClass)
end
end
context "custom proxy validator" do
it "successfully setups if class has all the required methods" do
class MyProxyValidator
def self.connectable?(*)
true
end
end
expect { ProxyFetcher.config.proxy_validator = MyProxyValidator }.not_to raise_error
end
it "failed on setup if required methods are missing" do
MyWrongProxyValidator = Class.new
expect { ProxyFetcher.config.proxy_validator = MyWrongProxyValidator }
.to raise_error(ProxyFetcher::Exceptions::WrongCustomClass)
end
end
context "custom provider" do
it "fails on registration if provider class already registered" do
expect { ProxyFetcher::Configuration.register_provider(:xroxy, Class.new) }
.to raise_error(ProxyFetcher::Exceptions::RegisteredProvider)
end
it "fails on proxy list fetching if provider doesn't registered" do
ProxyFetcher.config.provider = :not_existing_provider
expect { ProxyFetcher::Manager.new }
.to raise_error(ProxyFetcher::Exceptions::UnknownProvider)
end
end
context "custom HTML parsing adapter" do
it "fails if adapter can't be installed" do
old_adapter = ProxyFetcher.config.adapter.dup
class CustomAdapter < ProxyFetcher::Document::AbstractAdapter
def self.install_requirements!
require "not_existing_gem"
end
end
ProxyFetcher.config.adapter = CustomAdapter
expect { ProxyFetcher.config.adapter_class }
.to raise_error(ProxyFetcher::Exceptions::AdapterSetupError)
ProxyFetcher.config.adapter = old_adapter
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/spec/proxy_fetcher/manager_spec.rb | spec/proxy_fetcher/manager_spec.rb | # frozen_string_literal: true
require "spec_helper"
describe ProxyFetcher::Manager do
it "can initialize with a proxies from file(s)" do
manager = described_class.new(refresh: false, file: "spec/fixtures/proxies.txt")
expect(manager.proxies.size).to be(14)
manager = described_class.new(
refresh: false,
file: ["spec/fixtures/proxies.txt", "spec/fixtures/proxies.txt"]
)
expect(manager.proxies.size).to be(14)
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/spec/proxy_fetcher/providers/proxy_classes_spec.rb | spec/proxy_fetcher/providers/proxy_classes_spec.rb | # frozen_string_literal: true
require "spec_helper"
describe "Proxy classes" do
[
[:free_proxy_list, "FreeProxyList"],
[:free_proxy_list_socks, "FreeProxyListSocks"],
[:free_proxy_list_ssl, "FreeProxyListSSL"],
[:free_proxy_list_us, "FreeProxyListUS"],
[:http_tunnel, "HTTPTunnel"],
[:mtpro, "MTPro"],
[:proxy_list, "ProxyList"],
[:proxypedia, "Proxypedia"],
[:xroxy, "XRoxy"]
].each do |(provider_name, provider_klass)|
describe Object.const_get("ProxyFetcher::Providers::#{provider_klass}") do
before :all do
ProxyFetcher.config.provider = provider_name
end
it_behaves_like "a manager"
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/spec/proxy_fetcher/providers/base_spec.rb | spec/proxy_fetcher/providers/base_spec.rb | # frozen_string_literal: true
require "spec_helper"
describe ProxyFetcher::Providers::Base do
before { ProxyFetcher.config.reset! }
after { ProxyFetcher.config.reset! }
it "does not allows to use not implemented methods" do
NotImplementedCustomProvider = Class.new(ProxyFetcher::Providers::Base)
ProxyFetcher::Configuration.register_provider(:provider_without_methods, NotImplementedCustomProvider)
ProxyFetcher.config.provider = :provider_without_methods
expect { ProxyFetcher::Manager.new }.to raise_error(NotImplementedError) do |error|
expect(error.message).to include("provider_url")
end
# implement one of the methods
NotImplementedCustomProvider.class_eval do
def provider_url
"http://provider.com"
end
end
expect { ProxyFetcher::Manager.new }.to raise_error(NotImplementedError) do |error|
expect(error.message).to include("xpath")
end
end
it "logs failed to load proxy providers" do
CustomProvider = Class.new(ProxyFetcher::Providers::Base) do
def load_proxy_list(*)
doc = load_document("https://google.com", {})
doc.xpath('//table[contains(@class, "table")]/tr[(not(@id="proxy-table-header")) and (count(td)>2)]')
end
end
logger = Logger.new(StringIO.new)
ProxyFetcher::Configuration.register_provider(:custom_provider, CustomProvider)
ProxyFetcher.config.provider = :custom_provider
ProxyFetcher.config.logger = logger
allow_any_instance_of(HTTP::Client).to receive(:get).and_raise(StandardError)
expect(logger).to receive(:warn).with(%r{Failed to process request to http[s:/]})
ProxyFetcher::Manager.new
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/spec/proxy_fetcher/providers/multiple_providers_spec.rb | spec/proxy_fetcher/providers/multiple_providers_spec.rb | # frozen_string_literal: true
require "spec_helper"
describe "Multiple proxy providers" do
before { ProxyFetcher.config.reset! }
after { ProxyFetcher.config.reset! }
it "combine proxies from multiple providers" do
proxy_stub = ProxyFetcher::Proxy.new(addr: "192.168.1.1", port: 8080)
# Each proxy provider will return 2 proxies
ProxyFetcher::Configuration.providers_registry.providers.each do |_name, klass|
allow_any_instance_of(klass).to receive(:load_proxy_list).and_return([1, 2])
allow_any_instance_of(klass).to receive(:to_proxy).and_return(proxy_stub)
end
all_providers = ProxyFetcher::Configuration.registered_providers
ProxyFetcher.config.providers = all_providers
expect(ProxyFetcher::Manager.new.proxies.size).to eq(all_providers.size * 2)
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/spec/proxy_fetcher/client/client_spec.rb | spec/proxy_fetcher/client/client_spec.rb | # frozen_string_literal: true
require "spec_helper"
require "json"
begin
require "webrick"
rescue LoadError
# nop
end
require "evil-proxy"
require "evil-proxy/async"
describe ProxyFetcher::Client do
before :all do
ProxyFetcher.configure do |config|
config.provider = :xroxy
config.client_timeout = 5
config.logger = ProxyFetcher::NullLogger.new
end
quiet = ENV.key?("LOG_MITM") ? ENV["LOG_MITM"] == "false" : true
@server = EvilProxy::MITMProxyServer.new Port: 3128, Quiet: quiet
@server.start
end
after :all do
@server.shutdown
end
let(:local_proxy) { ProxyFetcher::Proxy.new(addr: "127.0.0.1", port: 3128, type: "HTTP, HTTPS") }
# Use local proxy server in order to avoid side effects, non-working proxies, etc
before :each do
ProxyFetcher::Client::ProxiesRegistry.manager.instance_variable_set(:'@proxies', [local_proxy])
allow_any_instance_of(ProxyFetcher::Providers::Base).to receive(:fetch_proxies).and_return([local_proxy])
end
context "GET request with the valid proxy" do
it "successfully returns page content for HTTP" do
content = ProxyFetcher::Client.get("http://httpbin.org/get")
expect(content).not_to be_empty
end
# TODO: oh this SSL / MITM proxies ....
xit "successfully returns page content for HTTPS" do
content = ProxyFetcher::Client.get("https://httpbin.org/get")
expect(content).not_to be_empty
end
it "successfully returns page content using custom proxy" do
content = ProxyFetcher::Client.get("http://httpbin.org/get", options: { proxy: local_proxy })
expect(content).not_to be_empty
end
end
context "POST request with the valid proxy" do
it "successfully returns page content for HTTP" do
headers = {
"X-Proxy-Fetcher-Version" => ProxyFetcher::VERSION::STRING
}
content = ProxyFetcher::Client.post(
"http://httpbin.org/post",
{ param: "value" },
headers: headers
)
expect(content).not_to be_empty
json = JSON.parse(content)
expect(json["headers"]["X-Proxy-Fetcher-Version"]).to eq(ProxyFetcher::VERSION::STRING)
expect(json["headers"]["User-Agent"]).to eq(ProxyFetcher.config.user_agent)
end
end
# TODO: EvilProxy incompatible with latest Ruby/Webrick
# @see https://github.com/bbtfr/evil-proxy/issues/10
if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("2.6")
context "PUT request with the valid proxy" do
it "successfully returns page content for HTTP" do
content = ProxyFetcher::Client.put("http://httpbin.org/put", "param=PutValue")
expect(content).not_to be_empty
json = JSON.parse(content)
expect(json["form"]["param"]).to eq("PutValue")
end
end
context "PATCH request with the valid proxy" do
it "successfully returns page content for HTTP" do
content = ProxyFetcher::Client.patch("http://httpbin.org/patch", param: "value")
expect(content).not_to be_empty
json = JSON.parse(content)
expect(json["form"]["param"]).to eq("value")
end
end
end
context "DELETE request with the valid proxy" do
it "successfully returns page content for HTTP" do
content = ProxyFetcher::Client.delete("http://httpbin.org/delete")
expect(content).not_to be_empty
end
end
context "HEAD request with the valid proxy" do
it "successfully works" do
content = ProxyFetcher::Client.head("http://httpbin.org")
expect(content).to be_empty
end
end
context "retries" do
it "raises an error when reaches max retries limit" do
allow(ProxyFetcher::Client::Request).to receive(:execute).and_raise(StandardError)
expect { ProxyFetcher::Client.get("http://httpbin.org", options: { max_retries: 10 }) }
.to raise_error(ProxyFetcher::Exceptions::MaximumRetriesReached)
end
xit "raises an error when http request returns an error" do
allow_any_instance_of(HTTP::Client).to receive(:get).and_return(StandardError.new)
expect { ProxyFetcher::Client.get("http://httpbin.org") }
.to raise_error(ProxyFetcher::Exceptions::MaximumRetriesReached)
end
it "refreshes proxy lists if no proxy found" do
allow(ProxyFetcher::Manager.new).to receive(:proxies).and_return([])
expect { ProxyFetcher::Client.get("http://httpbin.org") }
.not_to raise_error
end
end
xcontext "redirects" do
it "follows redirect when present" do
content = ProxyFetcher::Client.get("http://httpbin.org/absolute-redirect/2")
expect(content).not_to be_empty
end
it "raises an error when reaches max redirects limit" do
expect { ProxyFetcher::Client.get("http://httpbin.org/absolute-redirect/11") }
.to raise_error(ProxyFetcher::Exceptions::MaximumRedirectsReached)
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/spec/proxy_fetcher/document/adapters_spec.rb | spec/proxy_fetcher/document/adapters_spec.rb | # frozen_string_literal: true
require "spec_helper"
describe ProxyFetcher::Document::Adapters do
describe "#lookup" do
it "returns predefined adapters if symbol or string passed" do
expect(described_class.lookup("nokogiri")).to eq(ProxyFetcher::Document::NokogiriAdapter)
expect(described_class.lookup(:oga)).to eq(ProxyFetcher::Document::OgaAdapter)
end
it "returns self if class passed" do
expect(described_class.lookup(Struct)).to eq(Struct)
end
it "raises an exception if passed value is blank" do
expect { described_class.lookup(nil) }.to raise_error(ProxyFetcher::Exceptions::BlankAdapter)
expect { described_class.lookup("") }.to raise_error(ProxyFetcher::Exceptions::BlankAdapter)
end
it "raises an exception if adapter doesn't exist" do
expect { described_class.lookup("wrong") }.to raise_error(ProxyFetcher::Exceptions::UnknownAdapter)
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/spec/proxy_fetcher/document/node_spec.rb | spec/proxy_fetcher/document/node_spec.rb | # frozen_string_literal: true
require "spec_helper"
describe ProxyFetcher::Document::Node do
context "overridable methods" do
it "raises an error" do
node = ProxyFetcher::Document::Node.new("")
%w[content html].each do |method|
expect { node.public_send(method) }.to raise_error do |error|
expect(error.message).to include("`#{method}` must be implemented")
end
end
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher.rb | lib/proxy_fetcher.rb | # frozen_string_literal: true
require "uri"
require "http"
require "logger"
require "#{File.dirname(__FILE__)}/proxy_fetcher/version"
require "#{File.dirname(__FILE__)}/proxy_fetcher/exceptions"
require "#{File.dirname(__FILE__)}/proxy_fetcher/configuration"
require "#{File.dirname(__FILE__)}/proxy_fetcher/configuration/providers_registry"
require "#{File.dirname(__FILE__)}/proxy_fetcher/proxy"
require "#{File.dirname(__FILE__)}/proxy_fetcher/manager"
require "#{File.dirname(__FILE__)}/proxy_fetcher/null_logger"
require "#{File.dirname(__FILE__)}/proxy_fetcher/utils/http_client"
require "#{File.dirname(__FILE__)}/proxy_fetcher/utils/proxy_validator"
require "#{File.dirname(__FILE__)}/proxy_fetcher/utils/proxy_list_validator"
require "#{File.dirname(__FILE__)}/proxy_fetcher/client/client"
require "#{File.dirname(__FILE__)}/proxy_fetcher/client/request"
require "#{File.dirname(__FILE__)}/proxy_fetcher/client/proxies_registry"
require "#{File.dirname(__FILE__)}/proxy_fetcher/document"
require "#{File.dirname(__FILE__)}/proxy_fetcher/document/adapters"
require "#{File.dirname(__FILE__)}/proxy_fetcher/document/node"
require "#{File.dirname(__FILE__)}/proxy_fetcher/document/adapters/abstract_adapter"
require "#{File.dirname(__FILE__)}/proxy_fetcher/document/adapters/nokogiri_adapter"
require "#{File.dirname(__FILE__)}/proxy_fetcher/document/adapters/oga_adapter"
##
# Ruby / JRuby lib for managing proxies
module ProxyFetcher
# ProxyFetcher providers namespace
module Providers
require "#{File.dirname(__FILE__)}/proxy_fetcher/providers/base"
require "#{File.dirname(__FILE__)}/proxy_fetcher/providers/free_proxy_list"
require "#{File.dirname(__FILE__)}/proxy_fetcher/providers/free_proxy_list_socks"
require "#{File.dirname(__FILE__)}/proxy_fetcher/providers/free_proxy_list_ssl"
require "#{File.dirname(__FILE__)}/proxy_fetcher/providers/free_proxy_list_us"
require "#{File.dirname(__FILE__)}/proxy_fetcher/providers/http_tunnel"
require "#{File.dirname(__FILE__)}/proxy_fetcher/providers/mtpro"
require "#{File.dirname(__FILE__)}/proxy_fetcher/providers/proxy_list"
require "#{File.dirname(__FILE__)}/proxy_fetcher/providers/proxypedia"
require "#{File.dirname(__FILE__)}/proxy_fetcher/providers/xroxy"
end
@__config_access_lock__ = Mutex.new
@__config_definition_lock__ = Mutex.new
# Main ProxyFetcher module.
class << self
##
# Returns ProxyFetcher configuration.
#
# @return [ProxyFetcher::Configuration]
# Configuration object.
#
# @example
# ProxyFetcher.config
#
# #=> #<ProxyFetcher::Configuration:0x0000000241eec8 @user_agent="Mozilla/5.0, ...", @pool_size=10,
# @client_timeout=3, @proxy_validation_timeout=3, @provider_proxies_load_timeout=30,
# @http_client=ProxyFetcher::HTTPClient, @proxy_validator=ProxyFetcher::ProxyValidator,
# @providers=[:free_proxy_list, ...], @adapter=ProxyFetcher::Document::NokogiriAdapter>
#
def config
@__config_definition_lock__.synchronize do
@config ||= ProxyFetcher::Configuration.new
end
end
##
# Configures ProxyFetcher and yields config object for additional manipulations.
# @yieldreturn [optional, types, ...] description
#
# @return [ProxyFetcher::Configuration]
# Configuration object.
#
def configure
@__config_access_lock__.synchronize { yield config }
end
# Returns ProxyFetcher logger instance.
#
# @return [Logger, ProxyFetcher::NullLogger] logger object
#
def logger
return @logger if defined?(@logger)
@logger = config.logger || NullLogger.new
end
private
# Configures default adapter if it isn't defined by the user.
# @api private
#
def configure_adapter!
config.adapter = Configuration::DEFAULT_ADAPTER if config.adapter.nil?
end
end
configure_adapter!
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/version.rb | lib/proxy_fetcher/version.rb | # frozen_string_literal: true
module ProxyFetcher
##
# ProxyFetcher gem version.
def self.gem_version
Gem::Version.new VERSION::STRING
end
##
# ProxyFetcher gem semantic versioning.
module VERSION
# Major version number
MAJOR = 0
# Minor version number
MINOR = 17
# Smallest version number
TINY = 0
# Full version number
STRING = [MAJOR, MINOR, TINY].compact.join(".")
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/null_logger.rb | lib/proxy_fetcher/null_logger.rb | # frozen_string_literal: true
module ProxyFetcher
class NullLogger
# @return [nil]
def unknown(*)
nil
end
# @return [nil]
def fatal(*)
nil
end
# @return [nil]
def error(*)
nil
end
# @return [nil]
def warn(*)
nil
end
# @return [nil]
def info(*)
nil
end
# @return [nil]
def debug(*)
nil
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/exceptions.rb | lib/proxy_fetcher/exceptions.rb | # frozen_string_literal: true
module ProxyFetcher
# Base exception class for all the ProxyFetcher exceptions.
Error = Class.new(StandardError)
# ProxyFetcher exceptions namespace
module Exceptions
# Exception for wrong custom classes (such as ProxyValidator or HTTP Client).
class WrongCustomClass < Error
# Initialize new exception
#
# @return [WrongCustomClass]
#
def initialize(klass, methods)
required_methods = Array(methods).join(", ")
super("#{klass} must respond to [#{required_methods}] class methods!")
end
end
# Exception for wrong provider name, that raises when configured provider
# that is not registered via <code>register_provider</code> interface.
class UnknownProvider < Error
# Initialize new exception
#
# @param provider_name [String] provider name
#
# @return [UnknownProvider]
#
def initialize(provider_name)
super("unregistered proxy provider `#{provider_name}`")
end
end
# Exception for cases when user tries to register already existing provider.
class RegisteredProvider < Error
# Initialize new exception
#
# @param name [String, Symbol] provider name
#
# @return [RegisteredProvider]
#
def initialize(name)
super("`#{name}` provider already registered!")
end
end
# Exception for cases when HTTP client reached maximum count of redirects
# trying to process HTTP request.
class MaximumRedirectsReached < Error
# Initialize new exception
#
# @return [MaximumRedirectsReached]
#
def initialize(*)
super("maximum redirects reached")
end
end
# Exception for cases when HTTP client reached maximum count of retries
# trying to process HTTP request. Can occur when request failed by timeout
# multiple times.
class MaximumRetriesReached < Error
# Initialize new exception
#
# @return [MaximumRetriesReached]
#
def initialize(*)
super("reached the maximum number of retries")
end
end
# Exception for cases when user tries to set wrong HTML parser adapter
# in the configuration.
class UnknownAdapter < Error
# Initialize new exception
#
# @param name [String] configured adapter name
#
# @return [UnknownAdapter]
#
def initialize(name)
super("unknown adapter '#{name}'")
end
end
# Exception for cases when user tries to set <code>nil</code> HTML parser adapter
# in the configuration (or just forget to change it).
class BlankAdapter < Error
# Initialize new exception
#
# @return [BlankAdapter]
#
def initialize(*)
super(<<-MSG.strip.squeeze
you need to specify adapter for HTML parsing: ProxyFetcher.config.adapter = :nokogiri.
You can use one of the predefined adapters (:nokogiri or :oga) or your own implementation.
MSG
)
end
end
# Exception for cases when HTML parser adapter can't be installed.
# It will print the reason (backtrace) of the exception that caused an error.
class AdapterSetupError < Error
# Initialize new exception
#
# @param adapter_name [String] configured adapter name
# @param error [String] full setup error (backtrace)
#
# @return [AdapterSetupError]
#
def initialize(adapter_name, error)
adapter = demodulize(adapter_name.gsub("Adapter", ""))
super("can't setup '#{adapter}' adapter during the following error:\n\t#{error}'")
end
private
# Returns just class name removing it's namespace.
#
# @param path [String]
# full class name
#
# @return [String] demodulized class name
#
def demodulize(path)
path = path.to_s
index = path.rindex("::")
index ? path[(index + 2)..-1] : path
end
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/proxy.rb | lib/proxy_fetcher/proxy.rb | # frozen_string_literal: true
module ProxyFetcher
# Proxy object
class Proxy
# @!attribute [rw] addr
# @return [String] address (IP or domain)
attr_accessor :addr
# @!attribute [rw] port
# @return [Integer] port
attr_accessor :port
# @!attribute [rw] type
# @return [String] type (SOCKS, HTTP(S))
attr_accessor :type
# @!attribute [rw] country
# @return [String] country or country code
attr_accessor :country
# @!attribute [rw] response_time
# @return [Integer] response time (value and measurements depends on the provider)
attr_accessor :response_time
# @!attribute [rw] anonymity
# @return [String] anonymity level (high, elite, transparent, etc)
attr_accessor :anonymity
# Proxy types
TYPES = [
HTTP = "HTTP",
HTTPS = "HTTPS",
SOCKS4 = "SOCKS4",
SOCKS5 = "SOCKS5"
].freeze
# Proxy type predicates (#socks4?, #https?)
#
# @return [Boolean]
# true if proxy of requested type, otherwise false.
#
TYPES.each do |proxy_type|
define_method "#{proxy_type.downcase}?" do
!type.nil? && type.upcase.include?(proxy_type)
end
end
# Returns true if proxy is secure (works through https, socks4 or socks5).
#
# @return [Boolean]
# true if proxy is secure, otherwise false.
#
def ssl?
https? || socks4? || socks5?
end
# Initialize new Proxy
#
# @param attributes [Hash]
# proxy attributes
#
# @return [Proxy]
#
def initialize(attributes = {})
attributes.each do |attr, value|
public_send("#{attr}=", value)
end
end
# Checks if proxy object is connectable (can be used as a proxy for
# HTTP requests).
#
# @return [Boolean]
# true if proxy connectable, otherwise false.
#
def connectable?
ProxyFetcher.config.proxy_validator.connectable?(addr, port)
end
alias valid? connectable?
# Returns <code>URI::Generic</code> object with host and port values of the proxy.
#
# @return [URI::Generic]
# URI object.
#
def uri
URI::Generic.build(host: addr, port: port)
end
# Returns <code>String</code> object with <i>addr:port</i> values of the proxy.
#
# @param scheme [Boolean]
# Indicates if URL must include proxy type
#
# @return [String]
# true if proxy connectable, otherwise false.
#
def url(scheme: false)
if scheme
URI::Generic.build(scheme: type, host: addr, port: port).to_s
else
URI::Generic.build(host: addr, port: port).to_s
end
end
def ==(other)
other.is_a?(Proxy) && addr == other.addr && port == other.port
end
def eql?(other)
hash.eql?(other.hash)
end
def hash
[addr.hash, port.hash].hash
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/configuration.rb | lib/proxy_fetcher/configuration.rb | # frozen_string_literal: true
module ProxyFetcher
# ProxyFetcher configuration. Stores all the options for dealing
# with HTTP requests, adapters, custom classes.
#
class Configuration
# @!attribute client_timeout
# @return [Integer]
# HTTP request timeout (connect / open) for [ProxyFetcher::Client]
attr_accessor :client_timeout
# @!attribute provider_proxies_load_timeout
# @return [Integer]
# HTTP request timeout (connect / open) for loading
# of proxies list by provider
attr_accessor :provider_proxies_load_timeout
# @!attribute proxy_validation_timeout
# @return [Integer]
# HTTP request timeout (connect / open) for proxy
# validation with [ProxyFetcher::ProxyValidator]
attr_accessor :proxy_validation_timeout
# to save compatibility
alias timeout client_timeout
alias timeout= client_timeout=
# @!attribute pool_size
# @return [Integer] proxy validator pool size (max number of threads)
attr_accessor :pool_size
# @!attribute user_agent
# @return [String] User-Agent string
attr_accessor :user_agent
# @!attribute [r] logger
# @return [Logger] Logger object
attr_accessor :logger
# @!attribute [r] adapter
# @return [#to_s] HTML parser adapter
attr_reader :adapter
# @!attribute [r] http_client
# @return [Object] HTTP client class
attr_reader :http_client
# @!attribute [r] proxy_validator
# @return [Object] proxy validator class
attr_reader :proxy_validator
# @!attribute [r] providers
# @return [Array<String, Symbol>] proxy providers list to be used
attr_reader :providers
# User-Agent string that will be used by the ProxyFetcher HTTP client (to
# send requests via proxy) and to fetch proxy lists from the sources.
#
# Default is Google Chrome 60, but can be changed in <code>ProxyFetcher.config</code>.
#
DEFAULT_USER_AGENT = "Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 " \
"(KHTML, like Gecko) Chrome/60.0.3112 Safari/537.36"
# HTML parser adapter name.
#
# Default is Nokogiri, but can be changed in <code>ProxyFetcher.config</code>.
#
DEFAULT_ADAPTER = :nokogiri
@__adapter_lock__ = Mutex.new
class << self
# Registry for handling proxy providers.
#
# @return [ProxyFetcher::ProvidersRegistry]
# providers registry
#
def providers_registry
@providers_registry ||= ProvidersRegistry.new
end
# Register new proxy provider. Requires provider name and class
# that will process proxy list.
#
# @param name [String, Symbol]
# name of the provider
#
# @param klass [Class]
# Class that will fetch and process proxy list
#
def register_provider(name, klass)
providers_registry.register(name, klass)
end
# Returns registered providers names.
#
# @return [Array<String, Symbol>]
# registered providers names
#
def registered_providers
providers_registry.providers.keys
end
end
# Initialize ProxyFetcher configuration with default options.
#
# @return [ProxyFetcher::Configuration]
# ProxyFetcher gem configuration object
#
def initialize
reset!
end
# Sets default configuration options
def reset!
@logger = Logger.new($stdout)
@user_agent = DEFAULT_USER_AGENT
@pool_size = 10
@client_timeout = 3
@provider_proxies_load_timeout = 30
@proxy_validation_timeout = 3
@http_client = HTTPClient
@proxy_validator = ProxyValidator
self.providers = self.class.registered_providers
end
def adapter=(value)
remove_instance_variable(:@adapter_class) if defined?(@adapter_class)
@adapter = value
end
def adapter_class
self.class.instance_variable_get(:@__adapter_lock__).synchronize do
return @adapter_class if defined?(@adapter_class)
@adapter_class = ProxyFetcher::Document::Adapters.lookup(adapter)
@adapter_class.setup!
@adapter_class
end
end
# Setups collection of providers that will be used to fetch proxies.
#
# @param value [String, Symbol, Array<String, Symbol>]
# provider names
#
def providers=(value)
@providers = Array(value)
end
alias provider providers
alias provider= providers=
# Setups HTTP client class that will be used to fetch proxy lists.
# Validates class for the required methods to be defined.
#
# @param klass [Class]
# HTTP client class
#
def http_client=(klass)
@http_client = setup_custom_class(klass, required_methods: :fetch)
end
# Setups class that will be used to validate proxy lists.
# Validates class for the required methods to be defined.
#
# @param klass [Class]
# Proxy validator class
#
def proxy_validator=(klass)
@proxy_validator = setup_custom_class(klass, required_methods: :connectable?)
end
private
# Checks if custom class has some required class methods
def setup_custom_class(klass, required_methods: [])
unless klass.respond_to?(*required_methods)
raise ProxyFetcher::Exceptions::WrongCustomClass.new(klass, required_methods)
end
klass
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/manager.rb | lib/proxy_fetcher/manager.rb | # frozen_string_literal: true
module ProxyFetcher
# ProxyFetcher Manager class for interacting with proxy lists from various providers.
class Manager
REFRESHER_LOCK = Mutex.new
class << self
def from_files(files, **options)
new(**options.merge(files: Array(files)))
end
alias from_file from_files
end
# @!attribute [r] proxies
# @return [Array<ProxyFetcher::Proxy>] An array of proxies
attr_reader :proxies
# Initialize ProxyFetcher Manager instance for managing proxies
#
# refresh: true - load proxy list from the remote server on initialization
# refresh: false - just initialize the class, proxy list will be empty ([])
#
# @return [Manager]
#
def initialize(**options)
if options.fetch(:refresh, true)
refresh_list!(options.fetch(:filters, {}))
else
@proxies = []
end
files = Array(options.fetch(:file, options.fetch(:files, [])))
load_proxies_from_files!(files) if files&.any?
cleanup! if options.fetch(:validate, false)
end
# Update current proxy list using configured providers.
#
# @param filters [Hash] providers filters
#
def refresh_list!(filters = nil)
@proxies = []
threads = []
ProxyFetcher.config.providers.each do |provider_name|
threads << Thread.new do
Thread.current.report_on_exception = false
provider = ProxyFetcher::Configuration.providers_registry.class_for(provider_name)
provider_filters = filters && filters.fetch(provider_name.to_sym, filters)
provider_proxies = provider.fetch_proxies!(provider_filters)
REFRESHER_LOCK.synchronize do
@proxies.concat(provider_proxies)
end
end
end
threads.each(&:join)
@proxies
end
alias fetch! refresh_list!
# Pop just first proxy (and back it to the end of the proxy list).
#
# @return [ProxyFetcher::Proxy, NilClass]
# proxy object from the list
#
def get
return if @proxies.empty?
first_proxy = @proxies.shift
@proxies << first_proxy
first_proxy
end
alias pop get
# Pop first valid proxy (and back it to the end of the proxy list)
# Invalid proxies will be removed from the list
#
# @return [ProxyFetcher::Proxy, NilClass]
# proxy object from the list
#
def get!
index = proxies.find_index(&:connectable?)
return if index.nil?
proxy = proxies.delete_at(index)
tail = proxies[index..-1]
@proxies = tail << proxy
proxy
end
alias pop! get!
# Loads proxies from files.
#
# @param proxy_files [String, Array<String,Pathname>]
# file path of list of files to load
#
def load_proxies_from_files!(proxy_files)
proxy_files = Array(proxy_files)
return if proxy_files.empty?
proxy_files.each do |proxy_file|
File.foreach(proxy_file, chomp: true) do |proxy_string|
addr, port = proxy_string.split(":", 2)
port = Integer(port) if port
@proxies << Proxy.new(addr: addr, port: port)
end
end
@proxies.uniq!
end
# Clean current proxy list from dead proxies (that doesn't respond by timeout)
#
# @return [Array<ProxyFetcher::Proxy>]
# list of valid proxies
def cleanup!
valid_proxies = ProxyListValidator.new(@proxies).validate
@proxies &= valid_proxies
end
alias validate! cleanup!
# Returns random proxy
#
# @return [Proxy]
# random proxy from the loaded list
#
def random_proxy
proxies.sample
end
alias random random_proxy
# Returns array of proxy URLs (just schema + host + port)
#
# @return [Array<String>]
# collection of proxies
#
def raw_proxies
proxies.map(&:url)
end
# @private No need to put all the attr_readers to the output
def inspect
to_s
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/document.rb | lib/proxy_fetcher/document.rb | # frozen_string_literal: true
module ProxyFetcher
# HTML document abstraction class. Used to work with different HTML parser adapters
# such as Nokogiri, Oga or a custom one. Stores <i>backend</i< that will handle all
# the DOM manipulation logic.
class Document
# @!attribute [r] backend
# @return [Object] Backend object that handles DOM processing
attr_reader :backend
# Parses raw HTML data to abstract ProxyFetcher document.
#
# @param data [String] HTML
#
# @return [ProxyFetcher::Document]
# ProxyFetcher document model
#
def self.parse(data)
new(ProxyFetcher.config.adapter_class.parse(data))
end
# Initialize abstract ProxyFetcher HTML Document
#
# @return [Document]
#
def initialize(backend)
@backend = backend
end
# Searches elements by XPath selector.
#
# @return [Array<ProxyFetcher::Document::Node>]
# collection of nodes
#
def xpath(*args)
backend.xpath(*args).map { |node| backend.proxy_node.new(node) }
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/configuration/providers_registry.rb | lib/proxy_fetcher/configuration/providers_registry.rb | # frozen_string_literal: true
module ProxyFetcher
# ProxyFetcher providers registry that stores all registered proxy providers.
class ProvidersRegistry
# Returns providers hash where <i>key</i> is the name of the provider
# and <i>value</i> is an associated class.
#
# @return [Hash]
# registered providers
#
def providers
@providers ||= {}
end
# Add custom provider to common registry.
# Requires proxy provider name ('xroxy' for example) and a class
# that implements the parsing logic.
#
# @param name [String, Symbol]
# provider name
#
# @param klass [Class]
# provider class
#
# @raise [ProxyFetcher::Exceptions::RegisteredProvider]
# provider already registered
#
def register(name, klass)
raise ProxyFetcher::Exceptions::RegisteredProvider, name if providers.key?(name.to_sym)
providers[name.to_sym] = klass
end
# Returns a class for specific provider if it is registered
# in the registry. Otherwise throws an exception.
#
# @param provider_name [String, Symbol]
# provider name
#
# @return [Class]
# provider class
#
# @raise [ProxyFetcher::Exceptions::UnknownProvider]
# provider is unknown
#
def class_for(provider_name)
provider_name = provider_name.to_sym
providers.fetch(provider_name)
rescue KeyError
raise ProxyFetcher::Exceptions::UnknownProvider, provider_name
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/utils/http_client.rb | lib/proxy_fetcher/utils/http_client.rb | # frozen_string_literal: true
module ProxyFetcher
# Default ProxyFetcher HTTP client used to fetch proxy lists from
# the different providers. Uses ProxyFetcher configuration options
# for sending HTTP requests to providers URLs.
class HTTPClient
# @!attribute [r] url
# @return [String] URL
attr_reader :url
# @!attribute [r] HTTP method
# @return [String] HTTP method verb
attr_reader :method
# @!attribute [r] HTTP params
# @return [Hash] params
attr_reader :params
# @!attribute [r] HTTP headers
# @return [Hash] headers
attr_reader :headers
# @!attribute [r] http
# @return [Net::HTTP] HTTP client
attr_reader :http
# @!attribute [r] ssl_ctx
# @return [OpenSSL::SSL::SSLContext] SSL context
attr_reader :ssl_ctx
# @!attribute [r] timeout
# @return [Integer] Request timeout
attr_reader :timeout
# Fetches resource content by sending HTTP request to it.
# Synthetic sugar to simplify URIes fetching.
#
# @param url [String] URL
#
# @return [String]
# resource content
#
def self.fetch(*args, **kwargs, &block)
new(*args, **kwargs, &block).fetch
end
# Initialize HTTP client instance
#
# @return [HTTPClient]
#
def initialize(url, method: :get, params: {}, headers: {})
@url = url.to_s
@method = method.to_sym
@params = params
@headers = headers
unless HTTP::Request::METHODS.include?(@method)
raise ArgumentError, "'#{@method}' is a wrong HTTP method name"
end
@timeout = ProxyFetcher.config.provider_proxies_load_timeout
@http = build_http_engine
@ssl_ctx = build_ssl_context
end
# Fetches resource content by sending HTTP request to it.
#
# @return [String]
# response body
#
def fetch(**options)
response = perform_http_request
return response if options.fetch(:raw, false)
response.body.to_s
rescue StandardError => e
ProxyFetcher.config.logger.warn("Failed to process request to #{url} (#{e.message})")
""
end
protected
def build_ssl_context
OpenSSL::SSL::SSLContext.new.tap do |context|
context.verify_mode = OpenSSL::SSL::VERIFY_NONE
end
end
def build_http_engine
HTTP.headers(default_headers.merge(headers)).timeout(connect: timeout, read: timeout)
end
def perform_http_request(http_method: method, http_params: params)
http.public_send(
http_method,
url,
form: http_params,
ssl_context: ssl_ctx
)
end
# Default HTTP client headers
#
# @return [Hash]
# hash of HTTP headers
#
def default_headers
{
"User-Agent" => ProxyFetcher.config.user_agent
}
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/utils/proxy_list_validator.rb | lib/proxy_fetcher/utils/proxy_list_validator.rb | # frozen_string_literal: true
module ProxyFetcher
# This class validates list of proxies.
# Each proxy is validated using <code>ProxyFetcher::ProxyValidator</code>.
class ProxyListValidator
# @!attribute [r] proxies
# @return [Array<ProxyFetcher::Proxy>] Source array of proxies
attr_reader :proxies
# @!attribute [r] valid_proxies
# @return [Array<ProxyFetcher::Proxy>] Array of valid proxies after validation
attr_reader :valid_proxies
# @param [Array<ProxyFetcher::Proxy>] *proxies
# Any number of <code>ProxyFetcher::Proxy</code> to validate
def initialize(*proxies)
@proxies = proxies.flatten
end
# Performs validation
#
# @return [Array<ProxyFetcher::Proxy>]
# list of valid proxies
def validate
target_proxies = @proxies.dup
target_proxies_lock = Mutex.new
connectable_proxies = []
connectable_proxies_lock = Mutex.new
threads = []
ProxyFetcher.config.pool_size.times do
threads << Thread.new do
loop do
proxy = target_proxies_lock.synchronize { target_proxies.shift }
break unless proxy
if proxy.connectable?
connectable_proxies_lock.synchronize { connectable_proxies << proxy }
end
end
end
end
threads.each(&:join)
@valid_proxies = connectable_proxies
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/utils/proxy_validator.rb | lib/proxy_fetcher/utils/proxy_validator.rb | # frozen_string_literal: true
module ProxyFetcher
# Default ProxyFetcher proxy validator that checks either proxy
# connectable or not. It tries to send HEAD request to default
# URL to check if proxy can be used (aka connectable?).
class ProxyValidator
# Default URL that will be used to check if proxy can be used.
URL_TO_CHECK = "https://google.com"
# Short variant to validate proxy.
#
# @param address [String] proxy address or IP
# @param port [String, Integer] proxy port
#
# @return [Boolean]
# true if connection to the server using proxy established, otherwise false
#
def self.connectable?(address, port)
new(address, port).connectable?
end
# Initialize new ProxyValidator instance
#
# @param address [String] Proxy address or IP
# @param port [String, Integer] Proxy port
# @param options [Hash] proxy options
# @option username [String] Proxy authentication username
# @option password [String] Proxy authentication password
# @option headers [Hash] Proxy headers
#
# @return [ProxyValidator]
#
def initialize(address, port, options: {})
timeout = ProxyFetcher.config.proxy_validation_timeout
proxy = [address, port.to_i]
if options[:username] && options[:password]
proxy << options[:username]
proxy << options[:password]
end
proxy << options[:headers].to_h if options[:headers]
@http = HTTP.follow.via(*proxy).timeout(connect: timeout, read: timeout)
end
# Checks if proxy is connectable (can be used to connect
# resources via proxy server).
#
# @return [Boolean]
# true if connection to the server using proxy established, otherwise false
#
def connectable?
ssl_context = OpenSSL::SSL::SSLContext.new
ssl_context.verify_mode = OpenSSL::SSL::VERIFY_NONE
@http.head(URL_TO_CHECK, ssl_context: ssl_context).status.success?
rescue StandardError
false
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/providers/proxypedia.rb | lib/proxy_fetcher/providers/proxypedia.rb | # frozen_string_literal: true
module ProxyFetcher
module Providers
# FreeProxyList provider class.
class Proxypedia < Base
# Provider URL to fetch proxy list
def provider_url
"https://proxypedia.org"
end
# [NOTE] Doesn't support filtering
def xpath
"//main/ul/li[position()>1]"
end
# Converts HTML node (entry of N tags) to <code>ProxyFetcher::Proxy</code>
# object.]
#
# @param html_node [Object]
# HTML node from the <code>ProxyFetcher::Document</code> DOM model.
#
# @return [ProxyFetcher::Proxy]
# Proxy object
#
def to_proxy(html_node)
addr, port = html_node.content_at("a").to_s.split(":")
ProxyFetcher::Proxy.new.tap do |proxy|
proxy.addr = addr
proxy.port = Integer(port)
proxy.country = parse_country(html_node)
proxy.anonymity = "Unknown"
proxy.type = ProxyFetcher::Proxy::HTTP
end
end
private
def parse_country(html_node)
text = html_node.content.to_s
text[/\((.+?)\)/, 1] || "Unknown"
end
end
ProxyFetcher::Configuration.register_provider(:proxypedia, Proxypedia)
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/providers/free_proxy_list_ssl.rb | lib/proxy_fetcher/providers/free_proxy_list_ssl.rb | # frozen_string_literal: true
module ProxyFetcher
module Providers
# FreeProxyListSSL provider class.
class FreeProxyListSSL < Base
# Provider URL to fetch proxy list
def provider_url
"https://www.sslproxies.org/"
end
# [NOTE] Doesn't support filtering
def xpath
"//table[./thead/tr/th[contains(text(), 'IP')]]/tbody/tr"
end
# Converts HTML node (entry of N tags) to <code>ProxyFetcher::Proxy</code>
# object.
#
# @param html_node [Object]
# HTML node from the <code>ProxyFetcher::Document</code> DOM model.
#
# @return [ProxyFetcher::Proxy]
# Proxy object
#
def to_proxy(html_node)
ProxyFetcher::Proxy.new.tap do |proxy|
proxy.addr = html_node.content_at("td[1]")
proxy.port = Integer(html_node.content_at("td[2]").gsub(/^0+/, ""))
proxy.country = html_node.content_at("td[4]")
proxy.anonymity = html_node.content_at("td[5]")
proxy.type = ProxyFetcher::Proxy::HTTPS
end
end
end
ProxyFetcher::Configuration.register_provider(:free_proxy_list_ssl, FreeProxyListSSL)
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/providers/free_proxy_list.rb | lib/proxy_fetcher/providers/free_proxy_list.rb | # frozen_string_literal: true
module ProxyFetcher
module Providers
# FreeProxyList provider class.
class FreeProxyList < Base
# Provider URL to fetch proxy list
def provider_url
"https://free-proxy-list.net/"
end
# [NOTE] Doesn't support filtering
def xpath
"//table[./thead/tr/th[contains(text(), 'IP')]]/tbody/tr"
end
# Converts HTML node (entry of N tags) to <code>ProxyFetcher::Proxy</code>
# object.
#
# @param html_node [Object]
# HTML node from the <code>ProxyFetcher::Document</code> DOM model.
#
# @return [ProxyFetcher::Proxy]
# Proxy object
#
def to_proxy(html_node)
ProxyFetcher::Proxy.new.tap do |proxy|
proxy.addr = html_node.content_at("td[1]")
proxy.port = Integer(html_node.content_at("td[2]").gsub(/^0+/, ""))
proxy.country = html_node.content_at("td[4]")
proxy.anonymity = html_node.content_at("td[5]")
proxy.type = parse_type(html_node)
end
end
private
# Parses HTML node to extract proxy type.
#
# @param html_node [Object]
# HTML node from the <code>ProxyFetcher::Document</code> DOM model.
#
# @return [String]
# Proxy type
#
def parse_type(html_node)
https = html_node.content_at("td[6]")
https&.casecmp("yes")&.zero? ? ProxyFetcher::Proxy::HTTPS : ProxyFetcher::Proxy::HTTP
end
end
ProxyFetcher::Configuration.register_provider(:free_proxy_list, FreeProxyList)
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/providers/free_proxy_list_us.rb | lib/proxy_fetcher/providers/free_proxy_list_us.rb | # frozen_string_literal: true
module ProxyFetcher
module Providers
# FreeProxyListUS provider class.
class FreeProxyListUS < Base
# Provider URL to fetch proxy list
def provider_url
"https://www.us-proxy.org/"
end
# [NOTE] Doesn't support filtering
def xpath
"//table[./thead/tr/th[contains(text(), 'IP')]]/tbody/tr"
end
# Converts HTML node (entry of N tags) to <code>ProxyFetcher::Proxy</code>
# object.
#
# @param html_node [Object]
# HTML node from the <code>ProxyFetcher::Document</code> DOM model.
#
# @return [ProxyFetcher::Proxy]
# Proxy object
#
def to_proxy(html_node)
ProxyFetcher::Proxy.new.tap do |proxy|
proxy.addr = html_node.content_at("td[1]")
proxy.port = Integer(html_node.content_at("td[2]").gsub(/^0+/, ""))
proxy.country = html_node.content_at("td[4]")
proxy.anonymity = html_node.content_at("td[5]")
proxy.type = parse_type(html_node)
end
end
private
# Parses HTML node to extract proxy type.
#
# @param html_node [Object]
# HTML node from the <code>ProxyFetcher::Document</code> DOM model.
#
# @return [String]
# Proxy type
#
def parse_type(html_node)
https = html_node.content_at("td[7]")
https&.casecmp("yes")&.zero? ? ProxyFetcher::Proxy::HTTPS : ProxyFetcher::Proxy::HTTP
end
end
ProxyFetcher::Configuration.register_provider(:free_proxy_list_us, FreeProxyListUS)
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/providers/free_proxy_list_socks.rb | lib/proxy_fetcher/providers/free_proxy_list_socks.rb | # frozen_string_literal: true
module ProxyFetcher
module Providers
# FreeProxyListSocks provider class.
class FreeProxyListSocks < Base
# Provider URL to fetch proxy list
def provider_url
"https://www.socks-proxy.net/"
end
# [NOTE] Doesn't support filtering
def xpath
"//table[./thead/tr/th[contains(text(), 'IP')]]/tbody/tr"
end
# Converts HTML node (entry of N tags) to <code>ProxyFetcher::Proxy</code>
# object.
#
# @param html_node [Object]
# HTML node from the <code>ProxyFetcher::Document</code> DOM model.
#
# @return [ProxyFetcher::Proxy]
# Proxy object
#
def to_proxy(html_node)
ProxyFetcher::Proxy.new.tap do |proxy|
proxy.addr = html_node.content_at("td[1]")
proxy.port = Integer(html_node.content_at("td[2]").gsub(/^0+/, ""))
proxy.country = html_node.content_at("td[4]")
proxy.type = parse_type(html_node)
proxy.anonymity = html_node.content_at("td[6]")
end
end
private
# Parses HTML node to extract proxy type.
#
# @param html_node [Object]
# HTML node from the <code>ProxyFetcher::Document</code> DOM model.
#
# @return [String]
# Proxy type
#
def parse_type(html_node)
https = html_node.content_at("td[5]")
return ProxyFetcher::Proxy::SOCKS4 if https&.casecmp("socks4")&.zero?
return ProxyFetcher::Proxy::SOCKS5 if https&.casecmp("socks5")&.zero?
"Unknown"
end
end
ProxyFetcher::Configuration.register_provider(:free_proxy_list_socks, FreeProxyListSocks)
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/providers/proxy_list.rb | lib/proxy_fetcher/providers/proxy_list.rb | # frozen_string_literal: true
require "base64"
module ProxyFetcher
module Providers
# ProxyList provider class.
class ProxyList < Base
# Provider URL to fetch proxy list
def provider_url
"https://proxy-list.org/english/index.php"
end
def xpath
'//div[@class="table-wrap"]/div[@class="table"]/ul'
end
# Converts HTML node (entry of N tags) to <code>ProxyFetcher::Proxy</code>
# object.
#
# @param html_node [Object]
# HTML node from the <code>ProxyFetcher::Document</code> DOM model.
#
# @return [ProxyFetcher::Proxy]
# Proxy object
#
def to_proxy(html_node)
ProxyFetcher::Proxy.new.tap do |proxy|
uri = parse_proxy_uri(html_node)
proxy.addr = uri.host
proxy.port = uri.port
proxy.type = html_node.content_at("li[2]")
proxy.anonymity = html_node.content_at("li[4]")
proxy.country = html_node.find("li[5]//span[@class='country']").attr("title")
end
end
private
# Parses HTML node to extract URI object with proxy host and port.
#
# @param html_node [Object]
# HTML node from the <code>ProxyFetcher::Document</code> DOM model.
#
# @return [URI]
# URI object
#
def parse_proxy_uri(html_node)
full_addr = ::Base64.decode64(html_node.at_css("li script").html.match(/'(.+)'/)[1])
URI.parse("http://#{full_addr}")
end
end
ProxyFetcher::Configuration.register_provider(:proxy_list, ProxyList)
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/providers/base.rb | lib/proxy_fetcher/providers/base.rb | # frozen_string_literal: true
module ProxyFetcher
module Providers
# Base class for all the ProxyFetcher providers.
class Base
# Loads proxy provider page content, extract proxy list from it
# and convert every entry to proxy object.
def fetch_proxies(filters = {})
raw_proxies = load_proxy_list(filters)
proxies = raw_proxies.map { |html_node| build_proxy(html_node) }.compact
proxies.reject { |proxy| proxy.addr.nil? }
end
# For retro-compatibility
alias fetch_proxies! fetch_proxies
def provider_url
raise NotImplementedError, "#{__method__} must be implemented in a descendant class!"
end
def provider_method
:get
end
def provider_params
{}
end
# @return [Hash]
# Provider headers required to fetch the proxy list
#
def provider_headers
{}
end
def xpath
raise NotImplementedError, "#{__method__} must be implemented in a descendant class!"
end
# Just synthetic sugar to make it easier to call #fetch_proxies! method.
def self.fetch_proxies!(*args)
new.fetch_proxies!(*args)
end
protected
# Loads raw provider HTML with proxies.
#
# @param url [String]
# Provider URL
#
# @param filters [#to_h]
# Provider filters (Hash-like object)
#
# @return [String]
# HTML body from the response
#
def load_html(url, filters = {})
unless filters.respond_to?(:to_h)
raise ArgumentError, "filters must be a Hash or respond to #to_h"
end
if filters&.any?
# TODO: query for post request?
uri = URI.parse(url)
uri.query = URI.encode_www_form(provider_params.merge(filters.to_h))
url = uri.to_s
end
ProxyFetcher.config.http_client.fetch(
url,
method: provider_method,
headers: provider_headers,
params: provider_params
)
end
# Loads provider HTML and parses it with internal document object.
#
# @param url [String]
# URL to fetch
#
# @param filters [Hash]
# filters for proxy provider
#
# @return [ProxyFetcher::Document]
# ProxyFetcher document object
#
def load_document(url, filters = {})
html = load_html(url, filters)
ProxyFetcher::Document.parse(html)
end
# Fetches HTML content by sending HTTP request to the provider URL and
# parses the document (built as abstract <code>ProxyFetcher::Document</code>)
# to return all the proxy entries (HTML nodes).
#
# @return [Array<ProxyFetcher::Document::Node>]
# Collection of extracted HTML nodes with full proxy info
#
def load_proxy_list(filters = {})
doc = load_document(provider_url, filters)
doc.xpath(xpath)
end
def build_proxy(*args)
to_proxy(*args)
rescue StandardError => e
ProxyFetcher.logger.warn(
"Failed to build Proxy for #{self.class.name.split("::").last} " \
"due to error: #{e.message}"
)
nil
end
# Convert HTML element with proxy info to ProxyFetcher::Proxy instance.
#
# Abstract method. Must be implemented in a descendant class
#
# @return [Proxy]
# new proxy object from the HTML node
#
def to_proxy(*)
raise NotImplementedError, "#{__method__} must be implemented in a descendant class!"
end
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/providers/xroxy.rb | lib/proxy_fetcher/providers/xroxy.rb | # frozen_string_literal: true
module ProxyFetcher
module Providers
# XRoxy provider class.
class XRoxy < Base
# Provider URL to fetch proxy list
def provider_url
"https://www.xroxy.com/proxylist.htm"
end
def xpath
"//tr[@class='row1' or @class='row0']"
end
# Converts HTML node (entry of N tags) to <code>ProxyFetcher::Proxy</code>
# object.
#
# @param html_node [Object]
# HTML node from the <code>ProxyFetcher::Document</code> DOM model.
#
# @return [ProxyFetcher::Proxy]
# Proxy object
#
def to_proxy(html_node)
ProxyFetcher::Proxy.new.tap do |proxy|
proxy.addr = html_node.content_at("td[1]")
proxy.port = Integer(html_node.content_at("td[2]").gsub(/^0+/, ""))
proxy.anonymity = html_node.content_at("td[3]")
proxy.country = html_node.content_at("td[5]")
proxy.response_time = Integer(html_node.content_at("td[6]"))
proxy.type = html_node.content_at("td[3]")
end
end
end
ProxyFetcher::Configuration.register_provider(:xroxy, XRoxy)
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/providers/http_tunnel.rb | lib/proxy_fetcher/providers/http_tunnel.rb | # frozen_string_literal: true
module ProxyFetcher
module Providers
# HTTPTunnel provider class.
class HTTPTunnel < Base
# Provider URL to fetch proxy list
def provider_url
"http://www.httptunnel.ge/ProxyListForFree.aspx"
end
def xpath
'//table[contains(@id, "GridView")]/tr[(count(td)>2)]'
end
# Converts HTML node (entry of N tags) to <code>ProxyFetcher::Proxy</code>
# object.
#
# @param html_node [Object]
# HTML node from the <code>ProxyFetcher::Document</code> DOM model.
#
# @return [ProxyFetcher::Proxy]
# Proxy object
#
def to_proxy(html_node)
ProxyFetcher::Proxy.new.tap do |proxy|
uri = parse_proxy_uri(html_node)
proxy.addr = uri.host
proxy.port = uri.port
proxy.country = parse_country(html_node)
proxy.anonymity = parse_anonymity(html_node)
proxy.type = ProxyFetcher::Proxy::HTTP
end
end
private
# Parses HTML node to extract URI object with proxy host and port.
#
# @param html_node [Object]
# HTML node from the <code>ProxyFetcher::Document</code> DOM model.
#
# @return [URI]
# URI object
#
def parse_proxy_uri(html_node)
full_addr = html_node.content_at("td[1]")
URI.parse("http://#{full_addr}")
end
# Parses HTML node to extract proxy country.
#
# @param html_node [Object]
# HTML node from the <code>ProxyFetcher::Document</code> DOM model.
#
# @return [String]
# Country code
#
def parse_country(html_node)
html_node.find(".//img").attr("title")
end
# Parses HTML node to extract proxy anonymity level.
#
# @param html_node [Object]
# HTML node from the <code>ProxyFetcher::Document</code> DOM model.
#
# @return [String]
# Anonymity level
#
def parse_anonymity(html_node)
transparency = html_node.content_at("td[5]").to_sym
{
A: "Anonymous",
E: "Elite",
T: "Transparent",
U: "Unknown"
}.fetch(transparency, "Unknown")
end
end
ProxyFetcher::Configuration.register_provider(:http_tunnel, HTTPTunnel)
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/providers/mtpro.rb | lib/proxy_fetcher/providers/mtpro.rb | # frozen_string_literal: true
require "json"
module ProxyFetcher
module Providers
# MTPro provider class.
class MTPro < Base
# Provider URL to fetch proxy list
def provider_url
"https://mtpro.xyz/api/?type=socks"
end
def load_proxy_list(filters = {})
html = load_html(provider_url, filters)
JSON.parse(html)
rescue JSON::ParserError
[]
end
# Converts HTML node (entry of N tags) to <code>ProxyFetcher::Proxy</code>
# object.
#
# @param node [Object]
# HTML node from the <code>ProxyFetcher::Document</code> DOM model.
#
# @return [ProxyFetcher::Proxy]
# Proxy object
#
def to_proxy(node)
ProxyFetcher::Proxy.new.tap do |proxy|
proxy.addr = node["ip"]
proxy.port = Integer(node["port"])
proxy.country = node["country"]
proxy.anonymity = "Unknown"
proxy.type = ProxyFetcher::Proxy::SOCKS5
end
end
end
ProxyFetcher::Configuration.register_provider(:mtpro, MTPro)
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/client/proxies_registry.rb | lib/proxy_fetcher/client/proxies_registry.rb | # frozen_string_literal: true
module ProxyFetcher
module Client
# ProxyFetcher proxies registry for managing proxy lists used by the Client.
# It is used to fetch proxy lists and instantiate Manager object that will
# handle proxies.
class ProxiesRegistry
class << self
# Removes proxy from the list of the current proxy manager
# instance. If no more proxy available, refreshes the list.
#
# @param proxy [ProxyFetcher::Proxy]
# proxy object to remove
#
def invalidate_proxy!(proxy)
manager.proxies.delete(proxy)
manager.refresh_list! if manager.proxies.empty?
end
# Searches for valid proxy or required type (HTTP or secure)
# for requested URL. If no proxy found, than it refreshes proxy list
# and tries again.
#
# @param url [String]
# URL to process with proxy
#
# @return [ProxyFetcher::Proxy]
# gems proxy object
#
def find_proxy_for(url)
proxy = if URI.parse(url).is_a?(URI::HTTPS)
manager.proxies.detect(&:ssl?)
else
manager.get
end
return proxy unless proxy.nil?
manager.refresh_list!
find_proxy_for(url)
end
# Instantiates or returns <code>ProxyFetcher::Manager</code> instance
# for current <code>Thread</code>.
#
# @return [ProxyFetcher::Manager]
# ProxyFetcher manager class
#
def manager
manager = Thread.current[:proxy_fetcher_manager]
return manager unless manager.nil?
Thread.current[:proxy_fetcher_manager] = ProxyFetcher::Manager.new
end
end
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/client/client.rb | lib/proxy_fetcher/client/client.rb | # frozen_string_literal: true
module ProxyFetcher
# ProxyFetcher HTTP client that encapsulates all the logic for sending
# HTTP(S) requests using proxies, automatically fetched and validated by the gem.
module Client
class << self
# Sends HTTP GET request.
#
# @param url [String]
# Requested URL
#
# @param headers [Hash]
# HTTP headers that will be used in the request
#
# @param options [Hash]
# Additional options used by <code>ProxyFetcher::Client</code>
#
# @return [String]
# HTML body from the URL.
#
def get(url, headers: {}, options: {})
request_without_payload(:get, url, headers, options)
end
# Sends HTTP HEAD request.
#
# @param url [String]
# Requested URL
#
# @param headers [Hash]
# HTTP headers that will be used in the request
#
# @param options [Hash]
# Additional options used by <code>ProxyFetcher::Client</code>
#
# @return [String]
# HTML body from the URL.
#
def head(url, headers: {}, options: {})
request_without_payload(:head, url, headers, options)
end
# Sends HTTP POST request.
#
# @param url [String]
# Requested URL
#
# @param payload [String, Hash]
# HTTP payload
#
# @param headers [Hash]
# HTTP headers that will be used in the request
#
# @param options [Hash]
# Additional options used by <code>ProxyFetcher::Client</code>
#
# @return [String]
# HTML body from the URL.
#
def post(url, payload, headers: {}, options: {})
request_with_payload(:post, url, payload, headers, options)
end
# Sends HTTP DELETE request.
#
# @param url [String]
# Requested URL
#
# @param headers [Hash]
# HTTP headers that will be used in the request
#
# @param options [Hash]
# Additional options used by <code>ProxyFetcher::Client</code>
#
# @return [String]
# HTML body from the URL.
#
def delete(url, headers: {}, options: {})
request_without_payload(:delete, url, headers, options)
end
# Sends HTTP PUT request.
#
# @param url [String]
# Requested URL
#
# @param payload [String, Hash]
# HTTP payload
#
# @param headers [Hash]
# HTTP headers that will be used in the request
#
# @param options [Hash]
# Additional options used by <code>ProxyFetcher::Client</code>
#
# @return [String]
# HTML body from the URL.
#
def put(url, payload, headers: {}, options: {})
request_with_payload(:put, url, payload, headers, options)
end
# Sends HTTP PATCH request.
#
# @param url [String]
# Requested URL
#
# @param payload [String, Hash]
# HTTP payload
#
# @param headers [Hash]
# HTTP headers that will be used in the request
#
# @param options [Hash]
# Additional options used by <code>ProxyFetcher::Client</code>
#
# @return [String]
# HTML body from the URL.
#
def patch(url, payload, headers: {}, options: {})
request_with_payload(:patch, url, payload, headers, options)
end
private
# Executes HTTP request with user payload.
#
def request_with_payload(method, url, payload, headers, options)
with_proxy_for(url, options.fetch(:max_retries, 1000)) do |proxy|
opts = options.merge(
payload: payload,
proxy: options.fetch(:proxy, proxy),
headers: default_headers.merge(headers)
)
Request.execute(url: url, method: method, **opts)
end
end
# Executes HTTP request without user payload.
#
def request_without_payload(method, url, headers, options)
with_proxy_for(url, options.fetch(:max_retries, 1000)) do |proxy|
opts = options.merge(
proxy: options.fetch(:proxy, proxy),
headers: default_headers.merge(headers)
)
Request.execute(url: url, method: method, **opts)
end
end
# Default ProxyFetcher::Client http headers. Uses some options
# from the configuration object, such as User-Agent string.
#
# @return [Hash]
# headers
#
def default_headers
{
"User-Agent" => ProxyFetcher.config.user_agent
}
end
# Searches for valid proxy (suitable for URL type) using <code>ProxyFetcher::Manager</code>
# instance and executes the block with found proxy with retries (N times, default is 1000) if
# something goes wrong.
#
# @param url [String] request URL
# @param max_retries [Integer] maximum number of retries
#
# @raise [ProxyFetcher::Error] internal error happened during block execution
#
# Requires refactoring :(
#
def with_proxy_for(url, max_retries = 1000)
tries = 0
begin
proxy = ProxiesRegistry.find_proxy_for(url)
yield(proxy)
rescue ProxyFetcher::Error
raise
rescue StandardError
if max_retries && tries >= max_retries
ProxyFetcher.logger.warn("reached maximum amount of retries (#{max_retries})")
raise ProxyFetcher::Exceptions::MaximumRetriesReached
end
ProxiesRegistry.invalidate_proxy!(proxy)
tries += 1
retry
end
end
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/client/request.rb | lib/proxy_fetcher/client/request.rb | # frozen_string_literal: true
module ProxyFetcher
module Client
# ProxyFetcher::Client HTTP request abstraction.
class Request
# @!attribute [r] method
# @return [String, Symbol] HTTP request method
attr_reader :method
# @!attribute [r] url
# @return [String] Request URL
attr_reader :url
# @!attribute [r] headers
# @return [Hash] HTTP headers
attr_reader :headers
# @!attribute [r] timeout
# @return [Integer] Request timeout
attr_reader :timeout
# @!attribute [r] payload
# @return [String, Hash] Request payload
attr_reader :payload
# @!attribute [r] proxy
# @return [Proxy] Proxy to process the request
attr_reader :proxy
# @!attribute [r] max_redirects
# @return [Integer] Maximum count of requests (if fails)
attr_reader :max_redirects
# @!attribute [r] ssl_options
# @return [Hash] SSL options
attr_reader :ssl_options
# Initializes a new HTTP request and processes it
#
# @return [String]
# response body (requested resource content)
#
def self.execute(**args)
new(**args).execute
end
# Initialize new HTTP request
#
# @return [Request]
#
def initialize(**args)
raise ArgumentError, "args must be a Hash!" unless args.is_a?(Hash)
@url = args.fetch(:url)
@method = args.fetch(:method).to_s.downcase
@headers = (args[:headers] || {}).dup
@payload = args[:payload]
@timeout = args.fetch(:timeout, ProxyFetcher.config.client_timeout)
@ssl_options = args.fetch(:ssl_options, default_ssl_options)
@proxy = args.fetch(:proxy)
@max_redirects = args.fetch(:max_redirects, 10)
@http = build_http_client
end
# Executes HTTP request with defined options.
#
# @return [String]
# response body (requested resource content)
#
def execute
response = send_request
response.body.to_s
rescue HTTP::Redirector::TooManyRedirectsError
raise ProxyFetcher::Exceptions::MaximumRedirectsReached
end
private
# Builds HTTP client.
#
# @return [HTTP::Client]
# HTTP client
#
def build_http_client
HTTP.via(proxy.addr, proxy.port.to_i)
.headers(headers)
.timeout(connect: timeout, read: timeout)
.follow(max_hops: max_redirects)
end
# Default SSL options that will be used for connecting to resources
# the uses secure connection. By default ProxyFetcher wouldn't verify
# SSL certs.
#
# @return [OpenSSL::SSL::SSLContext] SSL context
#
def default_ssl_options
ssl_ctx = OpenSSL::SSL::SSLContext.new
ssl_ctx.verify_mode = OpenSSL::SSL::VERIFY_NONE
ssl_ctx
end
# Sends HTTP request to the URL. Check for the payload and it's type
# in order to build valid request.
#
# @return [HTTP::Response] request response
#
def send_request
if payload
payload_type = payload.is_a?(String) ? :body : :form
@http.public_send(method, url, payload_type => payload, ssl_context: ssl_options)
else
@http.public_send(method, url, ssl_context: ssl_options)
end
end
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/document/node.rb | lib/proxy_fetcher/document/node.rb | # frozen_string_literal: true
module ProxyFetcher
class Document
# Abstract class for storing HTML elements that was parsed by
# one of the <code>ProxyFetcher::Document</code> adapters class.
class Node
# @!attribute [r] node
# @return [Object] original DOM node, parsed by adapter backend
attr_reader :node
# Initialize new HTML node
#
# @return [Node]
#
def initialize(node)
@node = node
end
# Searches for node in children using some selector (CSS or XPath).
#
# @param selector [String] selector (CSS or XPath)
#
# @return [Node] child node
#
def find(selector, method = :at_xpath)
self.class.new(node.public_send(method, selector))
end
# Searches exact HTML element by XPath. Returns only one element.
#
# @return [ProxyFetcher::Document::Node]
# node
#
def at_xpath(*args)
self.class.new(node.at_xpath(*args))
end
# Searches exact HTML element by CSS. Returns only one element.
#
# @return [ProxyFetcher::Document::Node]
# node
#
def at_css(*args)
self.class.new(node.at_css(*args))
end
# Returns clean content (text) for the specific element.
#
# @return [String]
# HTML node content
#
def content_at(*args)
clear(find(*args).content)
end
# Returns HTML node content.
#
# Abstract method, must be implemented for specific adapter class.
#
def content
raise "`#{__method__}` must be implemented for specific adapter class!"
end
# Returns HTML node inner HTML.
#
# Abstract method, must be implemented for specific adapter class.
#
def html
raise "`#{__method__}` must be implemented for specific adapter class!"
end
protected
# Removes whitespaces, tabulation and other "garbage" for the text.
#
# @param text [String]
# text to clear
#
# @return [String]
# clean text
#
def clear(text)
return "" if text.nil? || text.empty?
text.strip.gsub(/\t/i, "")
end
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/document/adapters.rb | lib/proxy_fetcher/document/adapters.rb | # frozen_string_literal: true
module ProxyFetcher
class Document
# ProxyFetcher HTML parser adapters.
#
# ProxyFetcher default supported adapters are:
#
# * Nokogiri
# * Oga
#
# Any custom adapter can be used and must be inherited from
# <code>ProxyFetcher::Document::AbstractAdapter</code>.
class Adapters
# Adapters class name suffix
ADAPTER = "Adapter"
private_constant :ADAPTER
class << self
# Returns HTML parser adapter by it's name or class.
# If name is provided, then it looks for predefined classes
# in <code>ProxyFetcher::Document</code> namespace. Otherwise
# it just returns the passed class.
#
# @param name_or_class [String, Class]
# Adapter name or class
#
def lookup(name_or_class)
raise Exceptions::BlankAdapter if name_or_class.nil? || name_or_class.to_s.empty?
case name_or_class
when Symbol, String
adapter_name = "#{name_or_class.to_s.capitalize}#{ADAPTER}"
ProxyFetcher::Document.const_get(adapter_name)
else
name_or_class
end
rescue NameError
raise Exceptions::UnknownAdapter, name_or_class
end
end
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/document/adapters/nokogiri_adapter.rb | lib/proxy_fetcher/document/adapters/nokogiri_adapter.rb | # frozen_string_literal: true
module ProxyFetcher
class Document
# HTML parser adapter that uses Nokogiri as a backend.
class NokogiriAdapter < AbstractAdapter
# Requires Nokogiri gem to the application.
def self.install_requirements!
require "nokogiri"
end
# Parses raw HTML content with specific gem.
#
# @param data [String]
# HTML content
#
# @return [ProxyFetcher::Document::NokogiriAdapter]
# Object with parsed document
#
def self.parse(data)
new(::Nokogiri::HTML(data))
end
# Nokogiri DOM node
class Node < ProxyFetcher::Document::Node
# Returns HTML node attribute value.
#
# @return [String] attribute value
#
def attr(*args)
clear(node.attr(*args))
end
# Returns HTML node inner text value clean from
# whitespaces, tabs, etc.
#
# @return [String] node inner text
#
def content
clear(node.content)
end
# Returns node inner HTML.
#
# @return [String] inner HTML
#
def html
node.inner_html
end
end
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/document/adapters/abstract_adapter.rb | lib/proxy_fetcher/document/adapters/abstract_adapter.rb | # frozen_string_literal: true
module ProxyFetcher
class Document
# Abstract HTML parser adapter class.
# Handles document manipulations.
class AbstractAdapter
# @!attribute [r] events
# @return [Hash] A hash with events registered within a bus
attr_reader :document
# Initialize adapter
#
# @return [AbstractAdapter]
#
def initialize(document)
@document = document
end
# You can override this method in your own adapter class
#
# @param selector [String]
# XPath selector
#
def xpath(selector)
document.xpath(selector)
end
# Returns <code>Node</code> class that will handle HTML
# nodes for particular adapter.
#
# @return [ProxyFetcher::Document::Node]
# node
#
def proxy_node
self.class.const_get("Node")
end
# Installs adapter requirements.
#
# @raise [Exceptions::AdapterSetupError]
# adapter can't be install due to some error
#
def self.setup!(*args)
install_requirements!(*args)
self
rescue LoadError, StandardError => e
raise Exceptions::AdapterSetupError.new(name, e.message)
end
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
nbulaj/proxy_fetcher | https://github.com/nbulaj/proxy_fetcher/blob/da6baec5750f883899e2862bd8814db7693eee56/lib/proxy_fetcher/document/adapters/oga_adapter.rb | lib/proxy_fetcher/document/adapters/oga_adapter.rb | # frozen_string_literal: true
module ProxyFetcher
class Document
# HTML parser adapter that uses Oga as a backend.
class OgaAdapter < AbstractAdapter
# Requires Oga gem to the application.
def self.install_requirements!
require "oga"
end
# Parses raw HTML content with specific gem.
#
# @param data [String]
# HTML content
#
# @return [ProxyFetcher::Document::OgaAdapter]
# Object with parsed document
#
def self.parse(data)
new(::Oga.parse_html(data))
end
# Oga DOM node
class Node < ProxyFetcher::Document::Node
# Returns HTML node attribute value.
#
# @return [String] attribute value
#
def attr(*args)
clear(node.attribute(*args).value)
end
# Returns HTML node inner text value clean from
# whitespaces, tabs, etc.
#
# @return [String] node inner text
#
def content
clear(node.text)
end
# Returns node inner HTML.
#
# @return [String] inner HTML
#
def html
node.to_xml
end
end
end
end
end
| ruby | MIT | da6baec5750f883899e2862bd8814db7693eee56 | 2026-01-04T17:57:33.093632Z | false |
cavalle/chrome_remote | https://github.com/cavalle/chrome_remote/blob/fdbcebf1ff98827b1d84c07edb453c2aac013b70/spec/spec_helper.rb | spec/spec_helper.rb | require "bundler/setup"
require "chrome_remote"
require "byebug"
require "webmock/rspec"
RSpec.configure do |config|
# Enable flags like --only-failures and --next-failure
config.example_status_persistence_file_path = ".rspec_status"
# Disable RSpec exposing methods globally on `Module` and `main`
config.disable_monkey_patching!
config.expect_with :rspec do |c|
c.syntax = :expect
end
end
Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f }
| ruby | MIT | fdbcebf1ff98827b1d84c07edb453c2aac013b70 | 2026-01-04T17:57:36.815356Z | false |
cavalle/chrome_remote | https://github.com/cavalle/chrome_remote/blob/fdbcebf1ff98827b1d84c07edb453c2aac013b70/spec/support/web_socket_test_server.rb | spec/support/web_socket_test_server.rb | require "em-websocket"
class WebSocketTestServer
attr_reader :host, :port, :msg_handlers, :server, :thread, :path, :query
def initialize(url)
uri = URI.parse(url)
@host = uri.host
@port = uri.port
@path = uri.path
@query = uri.query
@msg_handlers = []
start_reactor
start_server
end
def expect_msg(&block)
msg_handlers << block
end
def send_msg(msg)
server.send msg
end
def close
EM.stop if EM.reactor_running?
thread.join rescue nil #FIXME: Find other way to avoid thread exceptions to be raised again
end
def has_satisfied_all_expectations?
msg_handlers.empty?
end
private
def start_reactor
@thread = Thread.new { EM.run }
thread.abort_on_exception = true
while not EM.reactor_running?; end
end
def start_server
EM::WebSocket.run(:host => host, :port => port) do |ws|
ws.onopen do |handshake|
if handshake.path.to_s != path.to_s
raise "Expected WebSocket path: #{path}. Got: #{handshake.path}"
end
if handshake.query_string.to_s != query.to_s
raise "Expected WebSocket query_string: '#{query}'. Got: '#{handshake.query_string}'"
end
end
ws.onmessage do |msg|
handler = msg_handlers.shift
handler.call(msg)
end
@server = ws
end
end
end
| ruby | MIT | fdbcebf1ff98827b1d84c07edb453c2aac013b70 | 2026-01-04T17:57:36.815356Z | false |
cavalle/chrome_remote | https://github.com/cavalle/chrome_remote/blob/fdbcebf1ff98827b1d84c07edb453c2aac013b70/spec/integration/chrome_remote_spec.rb | spec/integration/chrome_remote_spec.rb | require "spec_helper"
require "json"
RSpec.describe ChromeRemote do
around(:each) do |example|
# TODO should the library implement timeouts on every operation instead?
Timeout::timeout(5) { example.run }
end
WS_URL = "ws://localhost:9222/devtools/page/4a64d04e-f346-4460-be97-98e4a3dbf2fc"
before(:each) do
stub_request(:get, "http://localhost:9222/json").to_return(
body: [{ "type": "page", "webSocketDebuggerUrl": WS_URL }].to_json
)
end
# Server needs to be running before the client
let!(:server) { WebSocketTestServer.new(WS_URL) }
let!(:client) { ChromeRemote.client }
after(:each) { server.close }
describe "Initializing a client" do
it "returns a new client" do
client = double("client")
expect(ChromeRemote::Client).to receive(:new).with(WS_URL, nil) { client }
expect(ChromeRemote.client).to eq(client)
end
it "uses the first page’s webSocketDebuggerUrl" do
stub_request(:get, "http://localhost:9222/json").to_return(
body: [
{ "type": "background_page", "webSocketDebuggerUrl": "ws://one" },
{ "type": "page", "webSocketDebuggerUrl": "ws://two" },
{ "type": "page", "webSocketDebuggerUrl": "ws://three" }
].to_json
)
expect(ChromeRemote::Client).to receive(:new).with("ws://two", nil)
ChromeRemote.client
end
it "retries if no pages are returned" do
request_count = 0
stub_request(:get, "http://localhost:9222/json").to_return do |request|
request_count += 1
if request_count == 1
{ body: [].to_json }
else
{
body: [
{ "type": "page", "webSocketDebuggerUrl": "ws://two" },
].to_json
}
end
end
expect(ChromeRemote::Client).to receive(:new).with("ws://two", nil)
ChromeRemote.client
end
it "gets pages from the given host and port" do
stub_request(:get, "http://192.168.1.1:9292/json").to_return(
body: [{ "type": "page", "webSocketDebuggerUrl": "ws://one" }].to_json
)
expect(ChromeRemote::Client).to receive(:new).with("ws://one", nil)
ChromeRemote.client host: '192.168.1.1', port: 9292
end
it "accepts logger" do
logger = double("logger")
client = double("client")
expect(ChromeRemote::Client).to receive(:new).with(WS_URL, logger) { client }
expect(ChromeRemote.client(logger: logger)).to eq(client)
end
context "with new tab" do
it "creates new tab on the given host and port" do
stub_request(:get, "http://192.168.1.1:9292/json/new?about:blank").to_return(
body: { "type": "page", "webSocketDebuggerUrl": "ws://one" }.to_json
)
expect(ChromeRemote::Client).to receive(:new).with("ws://one", nil)
ChromeRemote.client host: '192.168.1.1', port: 9292, new_tab: true
end
end
end
describe "Logging" do
let(:logger) { double("logger") }
let!(:client) { ChromeRemote.client(logger: logger) }
it "logs incoming and outcoming messages" do
server.expect_msg do |msg|
msg = JSON.parse(msg)
server.send_msg({ id: msg["id"], params: {} }.to_json)
end
expect(logger).to receive(:info).with('SEND ► {"method":"Page.enable","params":{},"id":1}')
expect(logger).to receive(:info).with('◀ RECV {"id":1,"params":{}}')
client.send_cmd('Page.enable')
end
end
describe "Sending commands" do
it "sends commands using the DevTools protocol" do
expected_result = { "frameId" => rand(9999) }
server.expect_msg do |msg|
msg = JSON.parse(msg)
expect(msg["method"]).to eq("Page.navigate")
expect(msg["params"]).to eq("url" => "https://github.com")
expect(msg["id"]).to be_a(Integer)
# Reply with two messages not correlating the msg["id"].
# These two should be ignored by the client
server.send_msg({ method: "RandomEvent" }.to_json)
server.send_msg({ id: 9999, result: {} }.to_json)
# Reply correlated with msg["id"]
server.send_msg({ id: msg["id"],
result: expected_result }.to_json)
end
response = client.send_cmd "Page.navigate", url: "https://github.com"
expect(response).to eq(expected_result)
expect(server).to have_satisfied_all_expectations
end
end
describe "Subscribing to events" do
it "subscribes to events using the DevTools protocol" do
received_events = []
client.on "Network.requestWillBeSent" do |params|
received_events << ["Network.requestWillBeSent", params]
end
client.on "Page.loadEventFired" do |params|
received_events << ["Page.loadEventFired", params]
end
server.send_msg({ method: "RandomEvent" }.to_json) # to be ignored
server.send_msg({ method: "Network.requestWillBeSent", params: { "param" => 1} }.to_json)
server.send_msg({ id: 999, result: { "frameId" => 2 } }.to_json) # to be ignored
server.send_msg({ method: "Page.loadEventFired", params: { "param" => 2} }.to_json)
server.send_msg({ method: "Network.requestWillBeSent", params: { "param" => 3} }.to_json)
expect(received_events).to be_empty # we haven't listened yet
client.listen_until { received_events.size == 3 }
expect(received_events).to eq([
["Network.requestWillBeSent", { "param" => 1}],
["Page.loadEventFired", { "param" => 2}],
["Network.requestWillBeSent", { "param" => 3}],
])
end
it "allows to subscribe multiple times to the same event" do
received_events = []
client.on "Network.requestWillBeSent" do |params|
received_events << :first_handler
end
client.on "Network.requestWillBeSent" do |params|
received_events << :second_handler
end
expect(received_events).to be_empty # we haven't listened yet
server.send_msg({ method: "Network.requestWillBeSent" }.to_json)
client.listen_until { received_events.size == 2 }
expect(received_events).to include(:first_handler)
expect(received_events).to include(:second_handler)
end
it "processes events when sending commands" do
received_events = []
client.on "Network.requestWillBeSent" do |params|
received_events << :first_handler
end
server.expect_msg do |msg|
msg = JSON.parse(msg)
server.send_msg({ method: "Network.requestWillBeSent" }.to_json)
server.send_msg({ id: msg["id"] }.to_json)
end
expect(received_events).to be_empty # we haven't listened yet
client.send_cmd "Page.navigate"
expect(received_events).to eq([:first_handler])
end
it "subscribes to events and process them indefinitely" do
expected_events = rand(10) + 1
received_events = 0
TestError = Class.new(StandardError)
client.on "Network.requestWillBeSent" do |params|
received_events += 1
# the client will listen indefinitely, raise an expection to get out of the loop
raise TestError if received_events == expected_events
end
expected_events.times do
server.send_msg({ method: "Network.requestWillBeSent" }.to_json)
end
expect(received_events).to be_zero # we haven't listened yet
expect{client.listen}.to raise_error(TestError)
expect(received_events).to be(expected_events)
end
end
describe "Waiting for events" do
it "waits for the next instance of an event" do
# first two messages are to be ignored
server.send_msg({ id: 99 }.to_json)
server.send_msg({ method: "Network.requestWillBeSent", params: { "event" => 1 } }.to_json)
server.send_msg({ method: "Page.loadEventFired", params: { "event" => 2 } }.to_json)
server.send_msg({ method: "Network.requestWillBeSent", params: { "event" => 3 } }.to_json)
result = client.wait_for("Page.loadEventFired")
expect(result).to eq({ "event" => 2 })
result = client.wait_for("Network.requestWillBeSent")
expect(result).to eq({ "event" => 3 })
end
it "subscribes and waits for the same event" do
received_events = 0
client.on "Network.requestWillBeSent" do |params|
received_events += 1
end
server.send_msg({ method: "Network.requestWillBeSent" }.to_json)
expect(received_events).to be_zero # we haven't listened yet
result = client.wait_for("Network.requestWillBeSent")
expect(received_events).to eq(1)
end
it "waits for events with custom matcher block" do
server.send_msg({ method: "Page.lifecycleEvent", params: { "name" => "load" }}.to_json)
server.send_msg({ method: "Page.lifecycleEvent", params: { "name" => "DOMContentLoaded" }}.to_json)
result = client.wait_for do |event_name, event_params|
event_name == "Page.lifecycleEvent" && event_params["name"] == "DOMContentLoaded"
end
expect(result).to eq({"name" => "DOMContentLoaded"})
end
end
end
| ruby | MIT | fdbcebf1ff98827b1d84c07edb453c2aac013b70 | 2026-01-04T17:57:36.815356Z | false |
cavalle/chrome_remote | https://github.com/cavalle/chrome_remote/blob/fdbcebf1ff98827b1d84c07edb453c2aac013b70/examples/network_dump_and_screenshot.rb | examples/network_dump_and_screenshot.rb | require 'chrome_remote'
require 'base64'
chrome = ChromeRemote.client
# Enable events
chrome.send_cmd "Network.enable"
chrome.send_cmd "Page.enable"
# Setup handler to log network requests
chrome.on "Network.requestWillBeSent" do |params|
puts params["request"]["url"]
end
# Navigate to github.com and wait for the page to load
chrome.send_cmd "Page.navigate", url: "https://github.com"
chrome.wait_for "Page.loadEventFired"
# Take page screenshot
response = chrome.send_cmd "Page.captureScreenshot"
File.write "screenshot.png", Base64.decode64(response["data"])
| ruby | MIT | fdbcebf1ff98827b1d84c07edb453c2aac013b70 | 2026-01-04T17:57:36.815356Z | false |
cavalle/chrome_remote | https://github.com/cavalle/chrome_remote/blob/fdbcebf1ff98827b1d84c07edb453c2aac013b70/lib/chrome_remote.rb | lib/chrome_remote.rb | require "chrome_remote/version"
require "chrome_remote/client"
require "json"
require "net/http"
module ChromeRemote
class ChromeConnectionError < RuntimeError; end
class << self
DEFAULT_OPTIONS = {
host: "localhost",
port: 9222
}
def client(options = {})
options = DEFAULT_OPTIONS.merge(options)
logger = options.delete(:logger)
Client.new(get_ws_url(options), logger)
end
private
def get_ws_url(options)
path = '/json'
path += '/new?about:blank' if options.key?(:new_tab)
response = Net::HTTP.get(options[:host], path, options[:port])
response = JSON.parse(response)
raise ChromeConnectionError unless response.any?
return response['webSocketDebuggerUrl'] if options.key?(:new_tab)
first_page = response.find {|e| e["type"] == "page"}
raise ChromeConnectionError unless first_page
first_page["webSocketDebuggerUrl"]
rescue ChromeConnectionError
try ||= 0
try += 1
# Wait up to 5 seconds for Chrome to start fully
if try <= 50
sleep 0.1
retry
end
end
end
end
| ruby | MIT | fdbcebf1ff98827b1d84c07edb453c2aac013b70 | 2026-01-04T17:57:36.815356Z | false |
cavalle/chrome_remote | https://github.com/cavalle/chrome_remote/blob/fdbcebf1ff98827b1d84c07edb453c2aac013b70/lib/chrome_remote/version.rb | lib/chrome_remote/version.rb | module ChromeRemote
VERSION = "0.3.0"
end
| ruby | MIT | fdbcebf1ff98827b1d84c07edb453c2aac013b70 | 2026-01-04T17:57:36.815356Z | false |
cavalle/chrome_remote | https://github.com/cavalle/chrome_remote/blob/fdbcebf1ff98827b1d84c07edb453c2aac013b70/lib/chrome_remote/socket.rb | lib/chrome_remote/socket.rb | require "socket"
module ChromeRemote
class Socket
attr_reader :url, :io
def initialize(url)
uri = URI.parse(url)
@url = url
@io = TCPSocket.new(uri.host, uri.port)
end
def write(data)
io.print data
end
def read
io.readpartial(1024)
end
end
end
| ruby | MIT | fdbcebf1ff98827b1d84c07edb453c2aac013b70 | 2026-01-04T17:57:36.815356Z | false |
cavalle/chrome_remote | https://github.com/cavalle/chrome_remote/blob/fdbcebf1ff98827b1d84c07edb453c2aac013b70/lib/chrome_remote/web_socket_client.rb | lib/chrome_remote/web_socket_client.rb | require "websocket/driver"
require "chrome_remote/socket"
module ChromeRemote
class WebSocketClient
attr_reader :socket, :driver, :messages, :status
def initialize(url)
@socket = ChromeRemote::Socket.new(url)
@driver = ::WebSocket::Driver.client(socket)
@messages = []
@status = :closed
setup_driver
start_driver
end
def send_msg(msg)
driver.text msg
end
def read_msg
parse_input until msg = messages.shift
msg
end
private
def setup_driver
driver.on(:message) do |e|
messages << e.data
end
driver.on(:error) do |e|
raise e.message
end
driver.on(:close) do |e|
@status = :closed
end
driver.on(:open) do |e|
@status = :open
end
end
def start_driver
driver.start
parse_input until status == :open
end
def parse_input
@driver.parse(@socket.read)
end
end
end
| ruby | MIT | fdbcebf1ff98827b1d84c07edb453c2aac013b70 | 2026-01-04T17:57:36.815356Z | false |
cavalle/chrome_remote | https://github.com/cavalle/chrome_remote/blob/fdbcebf1ff98827b1d84c07edb453c2aac013b70/lib/chrome_remote/client.rb | lib/chrome_remote/client.rb | require "chrome_remote/web_socket_client"
require "logger"
module ChromeRemote
class Client
attr_reader :ws, :handlers, :logger
def initialize(ws_url, logger = nil)
@ws = WebSocketClient.new(ws_url)
@handlers = Hash.new { |hash, key| hash[key] = [] }
@logger = logger || Logger.new(nil)
@last_id = 0
end
def send_cmd(command, params = {})
msg_id = generate_unique_id
payload = {method: command, params: params, id: msg_id}.to_json
logger.info "SEND ► #{payload}"
ws.send_msg(payload)
msg = read_until { |msg| msg["id"] == msg_id }
msg["result"]
end
def on(event_name, &block)
handlers[event_name] << block
end
def listen_until(&block)
read_until { block.call }
end
def listen
read_until { false }
end
def wait_for(event_name=nil)
if event_name
msg = read_until { |msg| msg["method"] == event_name }
elsif block_given?
msg = read_until { |msg| yield(msg["method"], msg["params"]) }
end
msg["params"]
end
private
def generate_unique_id
@last_id += 1
end
def read_msg
msg = ws.read_msg
logger.info "◀ RECV #{msg}"
msg = JSON.parse(msg)
# Check if it’s an event and invoke any handlers
if event_name = msg["method"]
handlers[event_name].each do |handler|
handler.call(msg["params"])
end
end
msg
end
def read_until(&block)
loop do
msg = read_msg
return msg if block.call(msg)
end
end
end
end
| ruby | MIT | fdbcebf1ff98827b1d84c07edb453c2aac013b70 | 2026-01-04T17:57:36.815356Z | false |
denisdefreyne/cri | https://github.com/denisdefreyne/cri/blob/022de9676b2912b90d3b21f1727680d81ebc1e5d/samples/sample_capture_opts_as_args.rb | samples/sample_capture_opts_as_args.rb | # frozen_string_literal: true
$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
require 'cri'
super_cmd = Cri::Command.define do
name 'super'
usage 'does something super'
summary 'does super stuff'
description 'This command does super stuff.'
option :a, :aaa, 'opt a', argument: :optional
required :b, :bbb, 'opt b'
flag :d, :ddd, 'opt d'
optional :c, :ccc, 'opt c'
forbidden :e, :eee, 'opt e'
end
super_cmd.define_command do
name 'sub'
usage 'does something subby'
summary 'does subby stuff'
description 'This command does subby stuff.'
skip_option_parsing
run do |opts, args|
$stdout.puts 'in subcommand'
$stdout.puts "arguments: #{args.inspect}"
$stdout.puts "options: #{opts.inspect}"
end
end
super_cmd.add_command Cri::Command.new_basic_help
super_cmd.run(ARGV)
| ruby | MIT | 022de9676b2912b90d3b21f1727680d81ebc1e5d | 2026-01-04T17:57:35.186613Z | false |
denisdefreyne/cri | https://github.com/denisdefreyne/cri/blob/022de9676b2912b90d3b21f1727680d81ebc1e5d/samples/sample_nested.rb | samples/sample_nested.rb | # frozen_string_literal: true
$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
require 'cri'
super_cmd = Cri::Command.define do
name 'super'
usage 'does something super'
summary 'does super stuff'
description 'This command does super stuff.'
option :a, :aaa, 'opt a', argument: :optional
required :b, :bbb, 'opt b'
flag :d, :ddd, 'opt d'
optional :c, :ccc, 'opt c'
forbidden :e, :eee, 'opt e'
end
super_cmd.define_command do
name 'sub'
usage 'does something subby'
summary 'does subby stuff'
description 'This command does subby stuff.'
option :m, :mmm, 'opt m', argument: :optional
required :n, :nnn, 'opt n'
flag :p, :ppp, 'opt p'
forbidden :q, :qqq, 'opt q'
optional :o, :ooo, 'opt o'
run do |opts, args|
$stdout.puts 'Sub-awesome!'
$stdout.puts "arguments: #{args.inspect}"
$stdout.puts "options: #{opts.inspect}"
end
end
super_cmd.add_command Cri::Command.new_basic_help
super_cmd.run(ARGV)
| ruby | MIT | 022de9676b2912b90d3b21f1727680d81ebc1e5d | 2026-01-04T17:57:35.186613Z | false |
denisdefreyne/cri | https://github.com/denisdefreyne/cri/blob/022de9676b2912b90d3b21f1727680d81ebc1e5d/samples/sample_params.rb | samples/sample_params.rb | # frozen_string_literal: true
$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
require 'cri'
command = Cri::Command.define do
name 'sync'
usage '[options] source target'
summary 'syncronises two locations'
description 'bla bla'
flag :v, :verbose, 'be verbose'
param :source
param :target
run do |opts, args|
puts 'Executing!'
p(opts: opts, args: args)
end
end
puts command.help
command.run(ARGV)
| ruby | MIT | 022de9676b2912b90d3b21f1727680d81ebc1e5d | 2026-01-04T17:57:35.186613Z | false |
denisdefreyne/cri | https://github.com/denisdefreyne/cri/blob/022de9676b2912b90d3b21f1727680d81ebc1e5d/samples/sample_basic_root.rb | samples/sample_basic_root.rb | # frozen_string_literal: true
$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
require 'cri'
cmd = Cri::Command.new_basic_root.modify do
name 'nanoc'
usage 'nanoc [options] [command] [options]'
summary 'manages and builds static web sites'
description 'nanoc is a tool for building static sites.'
end
cmd.define_command do
name 'compile'
usage 'compile [options]'
summary 'compiles a web site'
description 'This loads all data, compiles it and writes it to the disk.'
no_params
run do |_opts, _args|
puts 'Compiling…'
sleep 1
puts 'Done.'
end
end
cmd.run(ARGV)
| ruby | MIT | 022de9676b2912b90d3b21f1727680d81ebc1e5d | 2026-01-04T17:57:35.186613Z | false |
denisdefreyne/cri | https://github.com/denisdefreyne/cri/blob/022de9676b2912b90d3b21f1727680d81ebc1e5d/samples/sample_simple.rb | samples/sample_simple.rb | # frozen_string_literal: true
$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
require 'cri'
command = Cri::Command.define do
name 'moo'
usage 'usage: moo [options]'
summary 'does stuff'
description <<~DESC
This command does a lot of stuff. I really mean a lot. Well actually I am
lying. It doesn’t do that much. In fact, it barely does anything. It’s merely
a sample command to show off Cri!
DESC
option :a, :aaa, 'opt a', argument: :optional
required :b, :bbb, 'opt b'
optional :c, :ccc, 'opt c'
flag :d, :ddd, 'opt d'
forbidden :e, :eee, 'opt e'
flag :f, :fff, 'opt f', hidden: true
flag :g, :ggg, 'this is an option with a very long description that should reflow nicely'
flag :s, nil, 'option with only a short form'
flag nil, 'long', 'option with only a long form'
optional :i, :iii, 'opt i', default: 'donkey'
run do |opts, args|
puts 'Executing!'
p(opts: opts, args: args)
end
end
puts command.help
command.run(ARGV)
| ruby | MIT | 022de9676b2912b90d3b21f1727680d81ebc1e5d | 2026-01-04T17:57:35.186613Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.