plagiarism-checker 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 62f540b75e8fce69177d645e6c1b0b0c0b081c54
+  data.tar.gz: 7cddcf56deb0f2a66bf2af731e7f72ae4c3ce906
+SHA512:
+  metadata.gz: 93cd5f553fa669824c0cda767f14536e0e78724e9e9d7eb4eb53a41b8e9091f01f9a8cb7d76ef91edf97ad7343cc03662ebee66920afb7a1aafcdc32c562ca52
+  data.tar.gz: c679d5ecf82865dd8c627e1d84bcdab6f0abca6acd7cca1910b13ccb280bd7dd03f76be04d965e3f9f246966b0cf973d7b6e0aa249f9378d152b9deab8cd4d72

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.idea
+/README.md
+/examples/test.rb

data/.rubocop.yml

@@ -0,0 +1,2 @@
+Metrics/LineLength:
+  Max: 120

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in copyleaks_api.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License(MIT)
+
+ Copyright(c) 2016 Copyleaks LTD (https://copyleaks.com)
+
+ Permission is hereby granted, free of charge, to any person obtaining a copy
+ of this software and associated documentation files (the "Software"), to deal
+ in the Software without restriction, including without limitation the rights
+ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ copies of the Software, and to permit persons to whom the Software is
+ furnished to do so, subject to the following conditions:
+
+ The above copyright notice and this permission notice shall be included in all
+ copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ SOFTWARE.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'copyleaks_api'
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/copyleaks_api.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'copyleaks_api/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "plagiarism-checker"
+  spec.version       = CopyleaksApi::VERSION
+  spec.authors       = ["Copyleaks ltd"]
+  spec.email         = ["sales@copyleaks.com"]
+
+  spec.summary       = %q{Detects plagiarism and checks content distribution online.}
+  spec.description   = %q{Copyleaks detects plagiarism and checks content distribution online. Use Copyleaks to find out if textual content is original and if it has been used before. With Copyleaks cloud publishers, academics, and more can scan files (pdf, doc, docx, ocr...), URLs and free text for plagiarism check.}
+  spec.homepage      = "https://api.copyleaks.com"
+  spec.license       = "MIT"
+  
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_runtime_dependency 'mimemagic'
+end

data/examples/main.rb

@@ -0,0 +1,60 @@
+require 'bundler/setup'
+require 'copyleaks_api'
+
+# firstly we need to create new Cloud entity
+email = '<YOUR-EMAIL>'
+api_key = '<YOUR-API-KEY>'
+cloud = CopyleaksApi::CopyleaksCloud.new(email, api_key, :publisher)
+
+# to check your balance just call balance
+
+puts "Your balance is #{cloud.balance} credits"
+
+# firstly we need to change work mode to sandbox
+
+CopyleaksApi::Config.sandbox_mode = true
+
+# now we can create new process by some url and custom callback
+process = cloud.create_by_url('http://exmaple.com', http_callback: 'http://requestb.in/')
+
+# Other scanning options
+# Text scan:
+#process = cloud.create_by_text("-Your text here-")
+
+# Textual file scan:
+#path = File.join(File.dirname(__FILE__), '..', 'spec', 'fixtures', 'files', 'lorem.txt')
+#process = cloud.create_by_file(path)
+
+# Ocr scan:
+#path = File.join(File.dirname(__FILE__), '..', 'spec', 'fixtures', 'files', 'lorem.jpg')
+#process = cloud.create_by_ocr(path, language: CopyleaksApi::Language.latin)
+
+puts "Now process has state '#{process.status}'"
+
+# to update process information we can just do this
+
+# process.reload
+
+# and it automatically call cloud.status with his id
+# it need some time to process your request so we need to wait
+
+while process.processing?
+  sleep(1)
+  process.reload
+end
+
+puts "And after sleep - #{process.status}"
+# to get our results from processing we can just call correspond method
+
+puts 'And its results are:'
+puts process.result.inspect
+
+# all results will be in array ow hashes with keys like Copyleaks API provides
+# to get list of all existing processes we can call list method
+
+processes = cloud.list
+puts "Overall you have #{processes.size} processes"
+
+# Delete finished process by PID:
+#PID = '00000000-0000-0000-0000-000000000000'
+#cloud.delete(PID)

data/lib/copyleaks_api.rb

@@ -0,0 +1,23 @@
+unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+  $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__)))
+end
+require 'copyleaks_api/version'
+
+require 'copyleaks_api/language'
+require 'copyleaks_api/errors'
+
+require 'copyleaks_api/validators/custom_fields_validator'
+require 'copyleaks_api/validators/email_validator'
+require 'copyleaks_api/validators/file_validator'
+require 'copyleaks_api/validators/response_validator'
+require 'copyleaks_api/validators/url_validator'
+require 'copyleaks_api/validators/language_validator'
+
+require 'copyleaks_api/copyleaks_cloud'
+require 'copyleaks_api/access_token'
+require 'copyleaks_api/api'
+require 'copyleaks_api/config'
+require 'copyleaks_api/copyleaks_process'
+
+module CopyleaksApi
+end

data/lib/copyleaks_api/access_token.rb

@@ -0,0 +1,36 @@
+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

@@ -0,0 +1,153 @@
+require 'json'
+require 'net/http'
+require 'mimemagic'
+require 'mimemagic/overlay'
+require 'openssl'
+
+module CopyleaksApi
+  class Api
+    BASE_URL = 'https://api.copyleaks.com'.freeze
+    API_VERSION = 'v1'.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 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
+
+    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
+
+    # gather all API path
+    def request_uri(path)
+      "/#{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)
+      JSON.parse(response.body)
+    end
+
+    # gather all headers
+    def gather_headers(request, options)
+      [
+        http_callbacks_header(options),
+        email_callback_header(options),
+        authentication_header(options),
+        sandbox_header,
+        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
+
+    # 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-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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,92 @@
+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

@@ -0,0 +1,82 @@
+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

@@ -0,0 +1,29 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,35 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,12 @@
+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

@@ -0,0 +1,27 @@
+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

data/lib/copyleaks_api/validators/url_validator.rb

@@ -0,0 +1,12 @@
+module CopyleaksApi
+  module Validators
+    class UrlValidator
+      class << self
+        # raises error if given url for callback is invalid
+        def validate!(url)
+          raise BadUrlError.new(url) unless url =~ %r(^(https?://)?([\da-z\.-]+)\.([a-z\.]{2,6})([/\w \.-]*)*/?$)
+        end
+      end
+    end
+  end
+end

data/lib/copyleaks_api/version.rb

@@ -0,0 +1,3 @@
+module CopyleaksApi
+  VERSION = '1.0.0'.freeze
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: plagiarism-checker
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Copyleaks ltd
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-06-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: mimemagic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Copyleaks detects plagiarism and checks content distribution online.
+  Use Copyleaks to find out if textual content is original and if it has been used
+  before. With Copyleaks cloud publishers, academics, and more can scan files (pdf,
+  doc, docx, ocr...), URLs and free text for plagiarism check.
+email:
+- sales@copyleaks.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- copyleaks_api.gemspec
+- examples/main.rb
+- lib/copyleaks_api.rb
+- lib/copyleaks_api/access_token.rb
+- lib/copyleaks_api/api.rb
+- lib/copyleaks_api/config.rb
+- lib/copyleaks_api/copyleaks_cloud.rb
+- lib/copyleaks_api/copyleaks_process.rb
+- lib/copyleaks_api/errors.rb
+- lib/copyleaks_api/language.rb
+- lib/copyleaks_api/validators/custom_fields_validator.rb
+- lib/copyleaks_api/validators/email_validator.rb
+- lib/copyleaks_api/validators/file_validator.rb
+- lib/copyleaks_api/validators/language_validator.rb
+- lib/copyleaks_api/validators/response_validator.rb
+- lib/copyleaks_api/validators/url_validator.rb
+- lib/copyleaks_api/version.rb
+homepage: https://api.copyleaks.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.4
+signing_key: 
+specification_version: 4
+summary: Detects plagiarism and checks content distribution online.
+test_files: []