plagiarism-checker 1.0.0 → 3.0.0

data/lib/copyleaks_api/config.rb

@@ -1,34 +0,0 @@
-module CopyleaksApi
-  class Config
-    DEFAULTS = {
-      sandbox_mode: false,
-      allow_partial_scan: false,
-      http_callback: nil,
-      email_callback: nil,
-      custom_fields: {},
-    }.freeze
-
-    class << self
-      attr_writer :sandbox_mode, :http_callback, :email_callback, :custom_fields, :allow_partial_scan
-
-      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,92 +0,0 @@
-require 'copyleaks_api/errors'
-require 'copyleaks_api/api'
-
-module CopyleaksApi
-  class CopyleaksCloud
-    ALLOWED_ENDPOINTS = [:publisher, :academic]
-    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 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, 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, response)
-    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, 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, response)
-    end
-
-    # deletes process by given id
-    def delete(id)
-      api.delete(url(:delete, id), token: @access_token.token)
-      true
-    end
-
-    # retries all processes
-    def list
-      response = api.get(url(:list), token: @access_token.token)
-      response.map { |hash| CopyleaksProcess.create_from_list(self, hash) }
-    end
-
-    # retries status information of process with given id
-    def status(id, options = {})
-      response = api.get(url(:status, id), no_callbacks: true, token: @access_token.token)
-      return response if options[:raw]
-      CopyleaksApi::CopyleaksProcess.create_from_status(self, id, response)
-    end
-
-    # retries result information of process with given id
-    def result(id, options = {})
-      response = api.get(url(:result, id), no_callbacks: true, token: @access_token.token)
-      return response if options[:raw]
-      CopyleaksApi::CopyleaksProcess.create_from_result(self, id, response)
-    end
-
-    private
-
-    # 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
-  end
-end

data/lib/copyleaks_api/copyleaks_process.rb

@@ -1,82 +0,0 @@
-require 'time'
-
-module CopyleaksApi
-  class CopyleaksProcess
-    STATUSES = ['processing', 'ready', 'allocated', 'finished', 'error', 'deleted'].freeze
-
-    attr_accessor :status, :process_id, :status, :progress, :custom_fields, :created_at
-
-    # constructor
-    def initialize(options)
-      @cloud = options[:cloud]
-      [:cloud, :process_id, :custom_fields, :result, :status, :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]
-      @status = STATUSES[options[:status_code].to_i + 1] if options[:status_code]
-    end
-
-    STATUSES[1..-1].each do |status|
-      # predicate methods for all statuses
-      define_method("#{status}?") do
-        reload if @status.nil?
-        @status == status
-      end
-    end
-
-    # returns true if process status means processing data on server side
-    def processing?
-      ['ready', 'allocated', 'processing'].include?(@status)
-    end
-
-    # return result data or retrieves from result endpoint if nothing specified
-    def result
-      @result ||= @cloud.result(process_id, raw: true)
-    end
-
-    # returns status information or reload if no data is specified
-    def status
-      reload if @status.nil?
-      @status
-    end
-
-    # deletes process from API
-    def delete
-      @cloud.delete(process_id)
-      @status = 'deleted'
-    end
-
-    # reload object attributes using status endpoint
-    def reload
-      response = @cloud.status(process_id, raw: true)
-      @status = response['Status'].downcase
-      @progress = response['ProgressPercents'].to_i
-      @result = nil
-      self
-    end
-
-    class << self
-      # create CopyleaksProcess based on data got from any create endpoint
-      def create(cloud, hash)
-        new(cloud: cloud, process_id: hash['ProcessId'], created_at: hash['CreationTimeUTC'])
-      end
-
-      # create CopyleaksProcess based on data got from status endpoint
-      def create_from_status(cloud, id, hash)
-        new(cloud: cloud, process_id: id, status: hash['Status'].downcase, progress: hash['ProgressPercents'])
-      end
-
-      # creates CopyleaksProcess based on data got from result endpoint
-      def create_from_result(cloud, id, result)
-        new(cloud: cloud, process_id: id, result: result)
-      end
-
-      # creates CopyleaksProcess based on data got from list endpoint
-      def create_from_list(cloud, hash)
-        new(cloud: cloud, process_id: hash['ProcessId'], created_at: hash['CreationTimeUTC'],
-            status: hash['Status'].downcase, custom_fields: hash['CustomFields'])
-      end
-    end
-  end
-end

data/lib/copyleaks_api/errors.rb

@@ -1,29 +0,0 @@
-module CopyleaksApi
-  BasicError = Class.new(StandardError)
-  BadCustomFieldError = Class.new(BasicError)
-  BadFileError = Class.new(BasicError)
-  BadEmailError = Class.new(BasicError)
-  BadUrlError = Class.new(BasicError)
-  UnknownLanguageError = Class.new(BasicError)
-
-  class BadResponseError < BasicError
-    attr_accessor :code
-
-    # constructor
-    def initialize(code, message)
-      @code = code.to_i
-      @message = message
-    end
-
-    def to_s
-      "Error code: #{code}. #{@message}"
-    end
-  end
-
-  class ManagedError < BadResponseError
-    # returns true if this error is internal server error
-    def internal_error?
-      code == 16
-    end
-  end
-end

data/lib/copyleaks_api/language.rb

@@ -1,61 +0,0 @@
-module CopyleaksApi
-  module Language
-    ALLOWED = ['Afrikaans',
-               'Albanian',
-               'Basque',
-               'Brazilian',
-               'Bulgarian',
-               'Byelorussian',
-               'Catalan',
-               'Chinese_Simplified',
-               'Chinese_Traditional',
-               'Croatian',
-               'Czech',
-               'Danish',
-               'Dutch',
-               'English',
-               'Esperanto',
-               'Estonian',
-               'Finnish',
-               'French',
-               'Galician',
-               'German',
-               'Greek',
-               'Hungarian',
-               'Icelandic',
-               'Indonesian',
-               'Italian',
-               'Japanese',
-               'Korean',
-               'Latin',
-               'Latvian',
-               'Lithuanian',
-               'Macedonian',
-               'Malay',
-               'Moldavian',
-               'Norwegian',
-               'Polish',
-               'Portuguese',
-               'Romanian',
-               'Russian',
-               'Serbian',
-               'Slovak',
-               'Slovenian',
-               'Spanish',
-               'Swedish',
-               'Tagalog',
-               'Turkish',
-               'Ukrainian'].freeze
-
-    ALLOWED.each_with_index do |lang, index|
-      method = lang.downcase
-
-      # returns appropriate language name based on method name
-      define_method(method) do
-        ALLOWED[index]
-      end
-
-      module_function method
-    end
-  end
-end

data/lib/copyleaks_api/validators/custom_fields_validator.rb

@@ -1,35 +0,0 @@
-module CopyleaksApi
-  module Validators
-    class CustomFieldsValidator
-      KEY_MAX_LENGTH = 128
-      VALUE_MAX_LENGTH = 512
-      OVERALL_MAX_LENGTH = 8192
-
-      class << self
-        # raises appropriate error if any length is too large
-        def validate!(fields)
-          raise BadCustomFieldError.new('Key is too long') unless keys_valid?(fields)
-          raise BadCustomFieldError.new('Value is too long') unless values_valid?(fields)
-          raise BadCustomFieldError.new('Overall size is too large') unless overall_valid?(fields)
-        end
-
-        private
-
-        # checks custom keys for length
-        def keys_valid?(hash)
-          hash.keys.map(&:to_s).all? { |s| s.size <= KEY_MAX_LENGTH }
-        end
-
-        # checks values for length
-        def values_valid?(hash)
-          hash.values.map(&:to_s).all? { |s| s.size <= VALUE_MAX_LENGTH }
-        end
-
-        # checks overall length
-        def overall_valid?(hash)
-          hash.reduce(0) { |a, e| a + e[0].to_s.size + e[1].to_s.size } <= OVERALL_MAX_LENGTH
-        end
-      end
-    end
-  end
-end

data/lib/copyleaks_api/validators/email_validator.rb

@@ -1,13 +0,0 @@
-module CopyleaksApi
-  module Validators
-    class EmailValidator
-      class << self
-        # raises error if given email is invalid
-        def validate!(email)
-          return if email =~ /^([a-z0-9_\.-]+)@([\da-z\.-]+)\.([a-z\.]{2,6})$/
-          raise BadEmailError.new(email), "Email #{email} is invalid"
-        end
-      end
-    end
-  end
-end

data/lib/copyleaks_api/validators/file_validator.rb

@@ -1,56 +0,0 @@
-module CopyleaksApi
-  module Validators
-    class FileValidator
-      SUPPORTED_FILE_TYPES = [:html, :htm, :txt, :pdf, :doc, :docx, :rtf].freeze
-      SUPPORTED_IMAGE_TYPES = [:gif, :png, :bmp, :jpg, :jpeg].freeze
-      BYTES_IN_MB = 1_024_000.0
-
-      class << self
-        # check file for ocr for correctness
-        def validate_ocr!(path)
-          validate_file(path, SUPPORTED_IMAGE_TYPES)
-        end
-
-        # check text file for correctness
-        def validate_text_file!(path)
-          validate_file(path, SUPPORTED_FILE_TYPES)
-        end
-
-        private
-
-        # check given file for correctness to given type
-        def validate_file(path, types)
-          ext = file_extension(path)
-          return if types.include?(ext) && file_size(path) <= allowed_file_size(ext)
-          raise BadFileError, "#{path} file has unsupported extension or to large"
-        end
-
-        # returns good file size in MB for given type
-        def allowed_file_size(type)
-          case type.to_sym
-          when :html, :htm
-            5
-          when :txt
-            3
-          when :pdf, :doc, :docx
-            25
-          when *SUPPORTED_IMAGE_TYPES
-            25
-          else
-            0
-          end
-        end
-
-        # extract file extension
-        def file_extension(path)
-          path.split('.').last.downcase.to_sym
-        end
-
-        # extract file size in MB
-        def file_size(path)
-          File.size(path) / BYTES_IN_MB
-        end
-      end
-    end
-  end
-end

data/lib/copyleaks_api/validators/language_validator.rb

@@ -1,12 +0,0 @@
-module CopyleaksApi
-  module Validators
-    class LanguageValidator
-      class << self
-        # raise error if given language is not allowed
-        def validate!(language)
-          raise UnknownLanguageError, "#{language} is unknown" unless Language::ALLOWED.include?(language)
-        end
-      end
-    end
-  end
-end

data/lib/copyleaks_api/validators/response_validator.rb

@@ -1,27 +0,0 @@
-require 'json'
-
-module CopyleaksApi
-  module Validators
-    class ResponseValidator
-      ERROR_HEADER = 'Copyleaks-Error-Code'.freeze
-      GOOD_STATUS_CODE = 200
-
-      class << self
-        # raises error if response has APi error code or bad status code
-        def validate!(response)
-          raise ManagedError.new(response[ERROR_HEADER], extract_message(response.body)) if response[ERROR_HEADER]
-          raise BadResponseError.new(response.code, response.body) if response.code.to_i != GOOD_STATUS_CODE
-        end
-
-        private
-
-        # extract message from body
-        def extract_message(string)
-          JSON.parse(string)['Message']
-        rescue JSON::ParserError
-          string
-        end
-      end
-    end
-  end
-end