plagiarism-checker 2.1.0 → 3.0.2

data/lib/copyleaks_api/access_token.rb

@@ -1,36 +0,0 @@
-require 'time'
-require 'json'
-
-module CopyleaksApi
-  class AccessToken
-    attr_reader :created_at, :expire_at
-
-    # constructor
-    def initialize(cloud, email, api_key)
-      @cloud = cloud
-      @email = email
-      @api_key = api_key
-      login
-    end
-
-    # predicate method to check if token is not expired
-    def fresh?
-      DateTime.now.new_offset(0) < @expire_at
-    end
-
-    # return token string
-    def token
-      return @token if fresh?
-      login
-    end
-
-    # get token for given email and api_key pair
-    def login
-      res = @cloud.api.post('account/login-api', { Email: @email, ApiKey: @api_key }.to_json)
-      @token = res['access_token']
-      @created_at = DateTime.parse(res['.issued'])
-      @expire_at = DateTime.parse(res['.expires'])
-      @token
-    end
-  end
-end

data/lib/copyleaks_api/api.rb

@@ -1,210 +0,0 @@
-require 'json'
-require 'net/http'
-require 'mimemagic'
-require 'mimemagic/overlay'
-require 'openssl'
-require 'securerandom'
-
-
-module CopyleaksApi
-  class Api
-    BASE_URL = 'https://api.copyleaks.com'.freeze
-    API_VERSION_V1 = 'v1'.freeze
-    API_VERSION_V2 = 'v2'.freeze
-  
-    # constructor
-    def initialize
-      uri = URI(BASE_URL)
-      @http = Net::HTTP.new(uri.host, uri.port)
-      @http.use_ssl = true
-      @http.verify_mode = ::OpenSSL::SSL::VERIFY_NONE
-    end
-
-    # make get request without any callback header
-    def get(path, options = {})
-      request = Net::HTTP::Get.new(request_uri(path))
-      make_request(request, options.merge(no_callbacks: true))
-    end
-
-    # make get request without any callback header
-    def get_with_final_path(path, options = {})
-      request = Net::HTTP::Get.new(path)
-      make_request(request, options.merge(no_callbacks: true))
-    end
-
-    # make post request with given options
-    def post(path, body = nil, options = {})
-      request = Net::HTTP::Post.new(request_uri(path))
-      request.body = body
-      make_request(request, options)
-    end
-
-    # makes delete request without callbacks
-    def delete(path, options = {})
-      request = Net::HTTP::Delete.new(request_uri(path))
-      make_request(request, options.merge(no_callbacks: true))
-    end
-
-    # makes post request with file inside
-    def post_file(path, file_path, options = {})
-      request = Net::HTTP::Post.new(request_uri(path))
-      options[:partial_scan] ||= CopyleaksApi::Config.allow_partial_scan
-      boundary = "copyleaks_sdk_#{SecureRandom.hex(4)}"
-      request.body = file_body(file_path, boundary)
-      make_request(request, options.merge(boundary: boundary))
-    end
-
-    # makes post request with file inside
-    def post_files(path, files_paths, options = {})
-      request = Net::HTTP::Post.new(request_uri(path, api_version: API_VERSION_V2))
-      options[:partial_scan] ||= CopyleaksApi::Config.allow_partial_scan
-      options[:compare_only] ||= CopyleaksApi::Config.compare_only
-      boundary = "copyleaks_sdk_#{SecureRandom.hex(4)}"
-      request.body = files_body(files_paths, boundary)
-      make_request(request, options.merge(boundary: boundary))
-    end
-    private
-
-    # extracts mime type of given file
-    def extract_mime_type(path)
-      mime = MimeMagic.by_magic(File.open(path))
-      mime ? mime.type : 'text/plain'
-    end
-
-    # prepares post body with file inside
-    def file_body(path, boundary)
-      [
-        "\r\n--#{boundary}\r\n",
-        "content-disposition: form-data; name=\"file\"",
-        "; filename=\"#{File.basename(path)}\"\r\n",
-        "Content-Type: #{extract_mime_type(path)}\r\n",
-        "Content-Transfer-Encoding: binary\r\n",
-        "\r\n",
-        File.open(path, 'rb') { |io| io.read },
-        "\r\n--#{boundary}--\r\n"
-      ].join('')
-    end
-    
-        # prepares post body with file inside
-    def files_body(paths, boundary)
-      body = "\r\n--#{boundary}\r\n"
-      counter = 1
-      paths.each do |path|
-        body += "content-disposition: form-data; name=\"file_#{counter}\"" +
-                "; filename=\"#{File.basename(path)}\"\r\n" +
-                "Content-Type: #{extract_mime_type(path)}\r\n" +
-                "Content-Transfer-Encoding: binary\r\n" +
-                "\r\n" +
-                File.open(path, 'rb') { |io| io.read } +
-                "\r\n--#{boundary}\r\n"
-        counter += 1
-      end
-      body += "\r\n--#{boundary}--\r\n"
-      body
-    end
-
-    # gather all API path
-    def request_uri(path, api_version: API_VERSION_V1)
-      "/#{api_version}/#{path}"
-    end
-
-    # gather headers, makes request and do validation
-    def make_request(request, options)
-      gather_headers(request, options)
-      response = @http.request(request)
-      Validators::ResponseValidator.validate!(response)
-      if not options.key?(:parse_json) or options[:parse_json]
-        JSON.parse(response.body)
-      else
-        response.body
-      end
-    end
-
-    # gather all headers
-    def gather_headers(request, options)
-      [
-        http_callbacks_header(options),
-        email_callback_header(options),
-        authentication_header(options),
-        sandbox_header,
-        compare_only_header,
-        in_progress_result(options),
-        content_type_header(options),
-        partial_scan_header(options),
-        'User-Agent' => "RUBYSDK/#{CopyleaksApi::VERSION}"
-      ].reduce({}, :merge).each do |header, value|
-        request[header] = value
-      end
-    end
-
-    # prepares header for sandbox mode
-    def sandbox_header
-      return {} unless Config.sandbox_mode
-      { 'copyleaks-sandbox-mode' => '' }
-    end
-    
-    # Compare your files against each other only
-    def compare_only_header
-      return {} unless Config.compare_only
-      { 'copyleaks-compare-documents-for-similarity' => '' }
-    end
-    
-    # Receive callback every time we find a new result without waiting for completion
-    def in_progress_result(options)
-      return {} if options[:no_http_callback] || options[:no_callbacks]
-      value = options[:in_progress_result] || CopyleaksApi::Config.in_progress_result
-      return {} unless value
-      Validators::UrlValidator.validate!(value)
-      { 'copyleaks-in-progress-new-result' => value }
-    end
-    # prepares header for content type
-    def content_type_header(options)
-      { 'Content-Type' => options[:boundary] ? "multipart/form-data; boundary=\"#{options[:boundary]}\"" :
-                                               'application/json' }
-    end
-
-    # prepares header for partial scan
-    def partial_scan_header(options)
-      return {} unless !options[:allow_partial_scan].nil? && options[:allow_partial_scan] || Config.allow_partial_scan
-      { 'copyleaks-allow-partial-scan' => '' }
-    end
-
-    # prepares authentication header
-    def authentication_header(options)
-      return {} unless options[:token]
-      { 'Authorization' => "Bearer #{options[:token]}" }
-    end
-
-    # prepare header for http callback
-    def http_callbacks_header(options)
-      return {} if options[:no_http_callback] || options[:no_callbacks]
-      value = options[:http_callback] || CopyleaksApi::Config.http_callback
-      return {} unless value
-      Validators::UrlValidator.validate!(value)
-      { 'copyleaks-http-completion-callback' => value }
-    end
-
-    # prepares header for email callback
-    def email_callback_header(options)
-      return {} if options[:no_email_callback] || options[:no_callbacks]
-      value = options[:email_callback] || CopyleaksApi::Config.email_callback
-      return {} unless value
-      Validators::EmailValidator.validate!(value)
-      { 'copyleaks-email-callback' => value }
-    end
-
-    
-    # prepares headers with custom fields
-    def custom_field_headers(options)
-      return {} if options[:no_custom_fields]
-      value = CopyleaksApi::Config.custom_fields.merge(options[:custom_fields] || {})
-      Validators::CustomFieldsValidator.validate!(value)
-      prepare_custom_fields(value)
-    end
-
-    # prepares custom fields before transformation into headers
-    def prepare_custom_fields(fields)
-      fields.each_with_object({}) { |e, o| o["copyleaks-client-custom-#{e[0]}"] = e[1] }
-    end
-  end
-end

data/lib/copyleaks_api/config.rb

@@ -1,36 +0,0 @@
-module CopyleaksApi
-  class Config
-    DEFAULTS = {
-      sandbox_mode: false,
-      allow_partial_scan: false,
-      http_callback: nil,
-      email_callback: nil,
-      custom_fields: {},
-      compare_only: false,
-      in_progress_result: nil,
-    }.freeze
-
-    class << self
-      attr_writer :sandbox_mode, :compare_only, :http_callback, :email_callback, :custom_fields, :allow_partial_scan, :in_progress_result
-
-      DEFAULTS.each do |attr, value|
-        # getters for all options
-        define_method(attr) do
-          var = instance_variable_get("@#{attr}")
-          return var if var
-          instance_variable_set("@#{attr}", value)
-        end
-      end
-
-      # provide block syntax possibility for setting options
-      def config
-        yield(self)
-      end
-
-      # reset all options to default
-      def reset
-        DEFAULTS.each { |attr, value| instance_variable_set("@#{attr}", value) }
-      end
-    end
-  end
-end

data/lib/copyleaks_api/copyleaks_cloud.rb

@@ -1,116 +0,0 @@
-require 'copyleaks_api/errors'
-require 'copyleaks_api/api'
-
-
-module CopyleaksApi
-  class CopyleaksCloud
-    ALLOWED_ENDPOINTS = [:businesses, :education, :websites]
-    attr_accessor :access_token
-    attr_reader :endpoint_type
-    
-    # constructor
-    def initialize(email, api_key, type)
-      raise ArgumentError, "Endpoint type '#{type}' is invalid" unless ALLOWED_ENDPOINTS.include?(type.to_sym)
-      @access_token = AccessToken.new(self, email, api_key)
-      @endpoint_type = type
-    end
-
-    def api
-      @api ||= CopyleaksApi::Api.new
-    end
-
-    # returns account balance from endpoint
-    def get_credits_balance
-	    api.get(url('count-credits'), token: @access_token.token)['Amount'].to_i
-    end
-
-    # uses create-by-url endpoint to create process
-    def create_by_url(url, options = {})
-      response = api.post(url('create-by-url'), { 'Url' => url }.to_json, options.merge(token: @access_token.token))
-      CopyleaksProcess.create(self, api, response)
-    end
-
-    # uses create-by-file endpoint to create process
-    def create_by_file(file_path, options = {})
-      response = api.post_file(url('create-by-file'), file_path, options.merge(token: @access_token.token))
-      CopyleaksProcess.create(self, api, response)
-    end
-
-    # uses create-by-file endpoint to create process
-    def create_by_files(files_paths, options = {})
-      response = api.post_files(url('create-by-file'), files_paths, options.merge(token: @access_token.token))
-      success_uploads = response['Success']
-      processes = []
-      success_uploads.each do |upload|
-        processes.push(CopyleaksProcess.create(self, api, upload))
-      end
-      processes
-    end
-
-    # uses create-by-file-ocr endpoint to create process
-    def create_by_ocr(ocr_file_path, options = {})
-      response = api.post_file(url_with_language('create-by-file-ocr', options), ocr_file_path,
-                               options.merge(token: @access_token.token))
-      CopyleaksProcess.create(self, api, response)
-    end
-
-    # uses create-by-text endpoint to create process
-    def create_by_text(text, options = {})
-      response = api.post(url('create-by-text'), text, options.merge(token: @access_token.token))
-      CopyleaksProcess.create(self, api, response)
-    end
-
-    # Returns a list of your past processes
-    def get_processes
-      response = api.get(url(:list), token: @access_token.token)
-      response.map { |hash| CopyleaksProcess.create_from_list(self, @api, hash) }
-    end
-    
-    # Returns the raw text of a given result
-    def get_raw_text(result)
-      response = api.get_with_final_path(result.get_cached_version, parse_json: false, token: @access_token.token)
-      response
-    end
-
-    # Returns the raw text of a given result
-    def get_comparison_report(result)
-      response = api.get_with_final_path(result.get_comparison_report, token: @access_token.token)
-      response
-    end
-    
-    # Returns a list of currently supported languages for ocr 
-    def get_ocr_languages
-      response = api.get(url_misc('ocr-languages-list'))
-      response
-    end
-    
-    # Returns a list of currently supported file types
-    def get_supported_file_types
-      response = api.get(url_misc('supported-file-types'))
-      response
-    end
-    
-    # gather url for endpoints which need language in get parameters
-    def url_with_language(action, options)
-      language = options[:language] || Language.english
-      Validators::LanguageValidator.validate!(language)
-      url("#{action}?language=#{language}")
-    end
-
-    # gather path for endpoints
-    def url(action, id = nil)
-      return "#{@endpoint_type}/#{action}" if id.nil?
-      "#{@endpoint_type}/#{id}/#{action}"
-    end
-    
-    # gather path for download endpoint
-    def url_downloads(action, id = nil)
-      return "downloads/#{action}"
-    end
-    
-    # gather path for download endpoint
-    def url_misc(action, id = nil)
-      return "miscellaneous/#{action}"
-    end
-  end
-end

data/lib/copyleaks_api/copyleaks_process.rb

@@ -1,78 +0,0 @@
-require 'time'
-require 'copyleaks_api/Models/ResultRecord'
-
-
-module CopyleaksApi
-  class CopyleaksProcess
-    attr_accessor :process_id, :progress, :custom_fields, :created_at
-
-    # constructor
-    def initialize(options)
-      @cloud = options[:cloud]
-      [:cloud, :api, :process_id, :custom_fields, :result, :progress].each do |attr|
-        instance_variable_set("@#{attr}", options[attr]) if options[attr]
-      end
-      @created_at = DateTime.parse(options[:created_at]) if options[:created_at]
-    end
-    
-    def to_s
-      return "Created at: #{@created_at}"
-    end
-
-    # returns true if still processing data on server side
-    def processing?
-      if @progress == 100
-        false
-      else
-        true
-      end
-    end
-
-    # return result data or retrieves from result endpoint if nothing specified
-    # retries result information of process with given id
-    def get_results
-      response = @api.get(@cloud.url(:result, @process_id), no_callbacks: true, token: @cloud.access_token.token)
-      @results = []
-      response.each do |res|
-        @results.push(CopyleaksApi::ResultRecord.new(res))
-      end
-      @results
-    end
-    
-    # retries status information of process with given id
-    def update_status
-      response = @api.get(@cloud.url(:status, @process_id), no_callbacks: true, token: @cloud.access_token.token)
-      @progress = response['ProgressPercents'].to_i
-      @progress
-    end
-
-    # Returns the source text of this process
-    def get_source_text
-      response = @api.get(@cloud.url_downloads("source-text?pid=#{@process_id}"), parse_json: false, no_callbacks: true, token: @cloud.access_token.token)
-      response
-    end
-
-    # deletes process from API
-    def delete
-      response = @api.delete(@cloud.url(:delete, @process_id), token: @cloud.access_token.token)
-      if response['StatusCode'] == 200
-        true
-      else
-        false
-      end
-    end
-
-    class << self
-      # create CopyleaksProcess based on data got from any create endpoint
-      def create(cloud, api, hash)
-        new(cloud: cloud, api: api, process_id: hash['ProcessId'], created_at: hash['CreationTimeUTC'])
-      end
-    
-      # creates CopyleaksProcess based on data got from list endpoint
-      def create_from_list(cloud, api, hash)
-        new(cloud: cloud, api: api, process_id: hash['ProcessId'], created_at: hash['CreationTimeUTC'],
-            status_code: hash['Status'].downcase, custom_fields: hash['CustomFields'])
-      end
-    end
-  end
-end