cloudscrape-client 0.1.3

data/cloudscrape-client-ruby.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "cloud_scrape/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "cloudscrape-client"
+  spec.version       = CloudScrape::VERSION
+  spec.authors       = ["Charles J Hardy"]
+  spec.email         = ["support@cloudscrape.com"]
+
+  spec.summary       = "Wrapper for CloudScrape API"
+  spec.description   = "Wrapper for CloudScrape API"
+  spec.homepage      = "http://cloudscrape.com"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "faraday", "~> 0.9"
+  spec.add_runtime_dependency "faraday_middleware", "~> 0.10"
+  spec.add_runtime_dependency "faraday-conductivity", "~> 0.3"
+  spec.add_runtime_dependency "faraday_middleware-multi_json", "~> 0.0"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rubocop"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "vcr"
+  spec.add_development_dependency "webmock"
+end

data/lib/cloud_scrape.rb

@@ -0,0 +1,27 @@
+require "logger"
+
+require "cloud_scrape/version"
+require "cloud_scrape/configuration"
+require "cloud_scrape/dto"
+require "cloud_scrape/runs"
+require "cloud_scrape/executions"
+
+class CloudScrape
+  extend Configure
+
+  NotFound = Class.new(StandardError)
+  InternalServerError = Class.new(StandardError)
+
+  def initialize(api_key: nil, account_id: nil)
+    CloudScrape.configuration.api_key = api_key if api_key
+    CloudScrape.configuration.account_id = account_id if account_id
+  end
+
+  def runs(id)
+    Runs.new(id: id)
+  end
+
+  def executions(id)
+    Executions.new(id: id)
+  end
+end

data/lib/cloud_scrape/api.rb

@@ -0,0 +1,87 @@
+require "digest"
+require "faraday"
+require "faraday_middleware"
+require "faraday/conductivity"
+require "faraday_middleware/multi_json"
+
+class CloudScrape
+  class API
+    InvalidApiKey = Class.new(StandardError)
+    InvalidAccountId = Class.new(StandardError)
+
+    def self.get(*args)
+      new.get(*args)
+    end
+
+    def self.post(*args)
+      new.post(*args)
+    end
+
+    def self.delete(*args)
+      new.delete(*args)
+    end
+
+    def get(domain:, url:, options: {})
+      connection(domain).get(URI.escape(url), options)
+    end
+
+    def post(domain:, url:, options: {})
+      connection(domain).post do |req|
+        req.url URI.escape(url)
+        req.headers["Content-Type"] = "application/json"
+        req.body = options.to_json
+      end
+    end
+
+    def delete(domain:, url:, options: {})
+      connection(domain).delete(URI.escape(url), options)
+    end
+
+    private
+
+    def access_key
+      fail InvalidAccountId, account_id unless account_id
+      fail InvalidApiKey, api_key unless api_key
+
+      Digest::MD5.hexdigest(account_id + api_key)
+    end
+
+    def account_id
+      CloudScrape.configuration.account_id
+    end
+
+    def api_key
+      CloudScrape.configuration.api_key
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    # rubocop:disable Metrics/MethodLength
+    def connection(domain)
+      Faraday.new(url: domain) do |faraday|
+        faraday.request :url_encoded
+
+        faraday.request :user_agent,
+                        app: CloudScrape.configuration.user_agent_app,
+                        version: CloudScrape.configuration.user_agent_version
+
+        faraday.request :request_headers,
+                        accept: "application/json",
+                        "X-CloudScrape-Access" => access_key,
+                        "X-CloudScrape-Account" => account_id,
+                        content_type: "application/json"
+
+        if CloudScrape.configuration.verbose
+          faraday.response :logger, CloudScrape.configuration.logger
+        end
+
+        faraday.response :multi_json,
+                         content_type: /\bjson$/,
+                         symbolize_keys: true
+
+        faraday.adapter Faraday.default_adapter
+      end
+    end
+    # rubocop:enable Metrics/AbcSize
+    # rubocop:enable Metrics/MethodLength
+  end
+end

data/lib/cloud_scrape/configuration.rb

@@ -0,0 +1,57 @@
+class CloudScrape
+  module Configure
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+      configuration
+    end
+
+    private
+
+    class Configuration
+      attr_accessor :base_url,
+                    :api_key,
+                    :account_id,
+                    :user_agent_app,
+                    :user_agent_version,
+                    :timeout,
+                    :verbose,
+                    :logger
+
+      def initialize # rubocop:disable Metrics/AbcSize
+        self.base_url = base_url_default
+        self.user_agent_app = user_agent_app_default
+        self.user_agent_version = user_agent_version_default
+        self.timeout = timeout_default
+
+        self.api_key = ENV["CLOUD_SCRAPE_CLIENT_API_KEY"]
+        self.account_id = ENV["CLOUD_SCRAPE_CLIENT_ACCOUNT_ID"]
+        self.verbose = ENV["CLOUD_SCRAPE_CLIENT_VERBOSE"] || false
+
+        self.logger = Logger.new(STDOUT)
+      end
+
+      private
+
+      def base_url_default
+        ENV["CLOUD_SCRAPE_CLIENT_BASE_URL"] ||
+          "https://app.cloudscrape.com/api/"
+      end
+
+      def user_agent_app_default
+        ENV["CLOUD_SCRAPE_CLIENT_USER_AGENT_APP"] || "CS-RUBY-CLIENT"
+      end
+
+      def user_agent_version_default
+        ENV["CLOUD_SCRAPE_CLIENT_USER_AGENT_VERSION"] || "1.0"
+      end
+
+      def timeout_default
+        ENV["CLOUD_SCRAPE_CLIENT_TIMEOUT"] || 3600
+      end
+    end
+  end
+end

data/lib/cloud_scrape/dto.rb

@@ -0,0 +1,58 @@
+require "cloud_scrape/api"
+require "cloud_scrape/validate"
+
+class CloudScrape
+  class DTO
+    attr_reader :options
+
+    def initialize(options:)
+      @options = options
+    end
+
+    def self.for(options)
+      new(options: options).response(options.fetch(:method))
+    end
+
+    def self.get(options = {})
+      new(options: options).response(:get)
+    end
+
+    def self.post(options = {})
+      new(options: options).response(:post)
+    end
+
+    def self.delete(options = {})
+      new(options: options).response(:delete)
+    end
+
+    def response(method)
+      API.public_send(
+        method,
+        domain: domain,
+        url: endpoint,
+        options: {
+          api_key: api_key,
+          format: "json"
+        }.merge(params)
+      ).tap(&CloudScrape::Validate).body
+    end
+
+    def params
+      {}
+    end
+
+    def endpoint
+      fail NotImplementedError, "Inheriting class must implement"
+    end
+
+    private
+
+    def domain
+      CloudScrape.configuration.base_url
+    end
+
+    def api_key
+      CloudScrape.configuration.api_key
+    end
+  end
+end

data/lib/cloud_scrape/execution_dto.rb

@@ -0,0 +1,17 @@
+class CloudScrape
+  class ExecutionDTO < DTO
+    def endpoint
+      "executions/#{id}/#{url}"
+    end
+
+    private
+
+    def id
+      options.fetch(:id)
+    end
+
+    def url
+      options.fetch(:url)
+    end
+  end
+end

data/lib/cloud_scrape/executions.rb

@@ -0,0 +1,37 @@
+require "cloud_scrape/execution_dto"
+require "cloud_scrape/executions/get"
+require "cloud_scrape/executions/result"
+
+class CloudScrape
+  class Executions
+    def initialize(id:)
+      @id = id
+    end
+
+    def get
+      Get.new(response: dto("", :get))
+    end
+
+    def result
+      Result.new(response: dto("result", :get))
+    end
+
+    def remove
+      dto("", :delete)
+    end
+
+    def stop
+      dto("stop", :post)
+    end
+
+    def continue
+      dto("continue", :post)
+    end
+
+    private
+
+    def dto(url, method)
+      ExecutionDTO.for(id: @id, url: url, method: method)
+    end
+  end
+end

data/lib/cloud_scrape/executions/get.rb

@@ -0,0 +1,41 @@
+class CloudScrape
+  class Executions
+    class Get
+      def initialize(response:)
+        @response = response
+      end
+
+      def queued?
+        %w(QUEUED).include?(state)
+      end
+
+      def pending?
+        %w(PENDING).include?(state)
+      end
+
+      def running?
+        %w(RUNNING).include?(state)
+      end
+
+      def failed?
+        %w(FAILED).include?(state)
+      end
+
+      def stopped?
+        %w(STOPPED).include?(state)
+      end
+
+      def ok?
+        %w(OK).include?(state)
+      end
+
+      private
+
+      attr_reader :response
+
+      def state
+        response.fetch(:state)
+      end
+    end
+  end
+end

data/lib/cloud_scrape/executions/result.rb

@@ -0,0 +1,34 @@
+class CloudScrape
+  class Executions
+    class Result
+      attr_reader :response
+
+      def initialize(response:)
+        @response = response
+        build
+      end
+
+      def build
+        as_hash.each(&define_method_for_header)
+      end
+
+      def as_hash
+        @as_hash ||= Hash[headers.zip(rows)]
+      end
+
+      private
+
+      def headers
+        response.fetch(:headers, [])
+      end
+
+      def rows
+        response.fetch(:rows, [[]]).flatten
+      end
+
+      def define_method_for_header
+        ->(key, value) { self.class.send(:define_method, key) { value } }
+      end
+    end
+  end
+end

data/lib/cloud_scrape/run_dto.rb

@@ -0,0 +1,25 @@
+class CloudScrape
+  class RunDTO < DTO
+    def endpoint
+      "runs/#{id}/#{url}?connect=#{connect}"
+    end
+
+    private
+
+    def id
+      options.fetch(:id)
+    end
+
+    def url
+      options.fetch(:url)
+    end
+
+    def connect
+      options.fetch(:connect)
+    end
+
+    def params
+      options.fetch(:input)
+    end
+  end
+end

data/lib/cloud_scrape/runs.rb

@@ -0,0 +1,19 @@
+require "cloud_scrape/run_dto"
+
+class CloudScrape
+  class Runs
+    def initialize(id:)
+      @id = id
+    end
+
+    def execute(input: {}, connect: false)
+      RunDTO.for(
+        id: @id,
+        url: (input.empty? ? "execute" : "execute/inputs"),
+        input: input,
+        connect: connect,
+        method: :post
+      ).fetch(:_id)
+    end
+  end
+end