plagiarism-checker 2.1.2 → 3.0.0

data/lib/copyleaks_api/Models/ResultRecord.rb

@@ -1,58 +0,0 @@
-module CopyleaksApi
-	class ResultRecord
-	  def initialize(response)
-		@URL = response['URL']
-		@Percents = response['Percents']
-		@NumberOfCopiedWords = response['NumberOfCopiedWords']
-		@CachedVersion = response['CachedVersion']
-		@Title = response['Title']
-		@Introduction = response['Introduction']
-		@ComparisonReport = response['ComparisonReport']
-		@EmbededComparison = response['EmbededComparison']
-	  end
-	  
-	  def get_url
-		@URL
-	  end
-	  
-	  def get_percents
-		@Percents
-	  end
-	  
-	  def get_number_of_copied_words
-		@NumberOfCopiedWords
-	  end
-	  
-	  def get_cached_version
-		@CachedVersion
-	  end
-
-	  def get_title
-		@Title
-	  end
-
-	  def get_introduction
-		@Introduction
-	  end
-	  
-	  def get_comparison_report
-		@ComparisonReport
-	  end
-	  
-	  def get_embeded_comparison
-		@EmbededComparison
-	  end
-	  
-	  def to_s
-		puts "----------------------------------------------------------------"
-		puts "Title: #{@Title}"
-		puts "Introduction: #{@Introduction}"
-		puts "Url: #{@URL}"
-		puts "Percents: #{@Percents}%"
-		puts "NumberOfCopiedWords: #{@NumberOfCopiedWords}"
-		puts "CachedVersion: #{@CachedVersion}"
-		puts "ComparisonReport: #{@ComparisonReport}"
-		puts "EmbededComparison: #{@EmbededComparison}"
-	  end
-	end
-end

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,216 +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,
-        import_to_database_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
-    
-    def import_to_database_only_header
-      return {} unless Config.import_to_database_only
-      { 'copyleaks-index-only' => '' }
-    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,37 +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,
-      import_to_database_only: false,
-      in_progress_result: nil,
-    }.freeze
-
-    class << self
-      attr_writer :sandbox_mode, :compare_only, :http_callback, :email_callback, :custom_fields, :allow_partial_scan, :import_to_database_only, :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