ratonvirus 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2858dfe945bf74c96269185692c5737c5469adf2404f144aeb4f04e9ae546687
-  data.tar.gz: 07262f10a07c229a92fa8e0b7f7747cff8f33d538804048706b0bd60650d8aeb
+  metadata.gz: 4b47a31e5d403f39f0b7496a292532b2dbaa5c38fe624368b09a2cb28c949623
+  data.tar.gz: 7a37d2f6d7b20e45c417b87ea22bbadbaf434714c1ce7082c1b4a4d87b646845
 SHA512:
-  metadata.gz: 0f039177a939be1eb63a0fc00c626b533dffafae9c906c607e22bf968247e602380304e6075b636d3d08daaa98815adaca5cafa8d3cf87572fd232a15cb3c1c1
-  data.tar.gz: 041f921088ba88398efddd3d437a38360435b88b4a0ab424047768c59b3ecabda69ca1597a5e0a6ac555a818946713b18492597858b29c167d755c3811ccafb4
+  metadata.gz: a52088960f46b6e4aad10616e9f2b65ad082490bd7158484178f88cc6aa68fa76397e471fa4e791e38cd51bcca799aabdbe868656c03226a9157bb2d82be4aaa
+  data.tar.gz: 62b103a30f7711cad63d9c9095eec42f98baf372b7fe2308ee03dc3ae063a74bf458afa8026e36ac10aa184df40302a9d721eafbbd93f6fc92efcc090efd9c4c

data/README.md

@@ -26,13 +26,13 @@ end
 Running manual scans:
 
 ```ruby
-puts "File contains a virus" if Ratonvirus.scanner.virus?('/path/to/file.pdf')
+puts "File contains a virus" if Ratonvirus.scanner.virus?("/path/to/file.pdf")
 ```
 
 Manual scanning works e.g. for file uploads, file object and file paths.
 
-Ratonvirus works well with Active Storage out of the box. Support for
-CarrierWave is provided through an additional gem (see details well).
+Ratonvirus works with Active Storage out of the box. Support for CarrierWave is
+also built in, assuming you already have CarrierWave as a dependency.
 
 ## When to use this?
 
@@ -53,7 +53,9 @@ as you are used to with many other gems.
 
 You will need to setup a virus scanner on your machine. If you have done that
 before, configuration should be rather simple. Instructions are provided for
-the open source ClamAV scanner.
+the open source ClamAV scanner in the
+[`ratonvirus-clamby`](https://github.com/mainio/ratonvirus-clamby)
+documentation.
 
 This gem ships with an example
 [EICAR file](https://en.wikipedia.org/wiki/EICAR_test_file) scanner to test out
@@ -66,7 +68,7 @@ environments.
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'ratonvirus'
+gem "ratonvirus"
 ```
 
 And then execute:
@@ -102,7 +104,7 @@ Ratonvirus correctly configured.
 
 By default Ratonvirus is set to remove all infected files that it detects after
 scanning them. If you want to remove this functionality, please refer to the
-[Scanner addons](doc/index.md#scanner-addons) section of the developer
+[Scanner addons](docs/index.md#scanner-addons) section of the developer
 documentation.
 
 ## Usage
@@ -153,7 +155,7 @@ end
 
 # When scanning files, file paths or active storage resources
 Ratonvirus.configure do |config|
-  config.storage = :multi, [:filepath, :active_storage]
+  config.storage = :multi, {storages: [:filepath, :active_storage]}
 end
 ```
 
@@ -164,7 +166,7 @@ examples:
 # It is a good idea to check first that the scanner is available.
 if Ratonvirus.scanner.available?
   # Scanning a file path
-  path = '/path/to/file.pdf'
+  path = "/path/to/file.pdf"
   if Ratonvirus.scanner.virus?(path)
     puts "There is a virus at #{path}"
   end
@@ -186,8 +188,8 @@ Here are few sample configurations to speed up the configuration process.
 Gemfile:
 
 ```ruby
-gem 'ratonvirus'
-gem 'ratonvirus-clamby'
+gem "ratonvirus"
+gem "ratonvirus-clamby"
 ```
 
 Initializer:
@@ -209,13 +211,16 @@ class YourModel < ApplicationRecord
 end
 ```
 
+For installing ClamAV, refer to
+[`ratonvirus-clamby`](https://github.com/mainio/ratonvirus-clamby)
+
 #### CarrierWave and ClamAV
 
 Gemfile:
 
 ```ruby
-gem 'ratonvirus'
-gem 'ratonvirus-clamby'
+gem "ratonvirus"
+gem "ratonvirus-clamby"
 ```
 
 Initializer:
@@ -237,10 +242,13 @@ class YourModel < ApplicationRecord
 end
 ```
 
+For installing ClamAV, refer to
+[`ratonvirus-clamby`](https://github.com/mainio/ratonvirus-clamby)
+
 ## Further configuration and development
 
 For further information about the configurations and how to create custom
-scanners, please refer to the [documentation](doc/index.md).
+scanners, please refer to the [documentation](docs/index.md).
 
 ## License
 

data/app/validators/antivirus_validator.rb

@@ -13,14 +13,14 @@ class AntivirusValidator < ActiveModel::EachValidator
     scanner = Ratonvirus.scanner
     return unless scanner.available?
 
-    if scanner.virus?(value)
-      if scanner.errors.any?
-        scanner.errors.each do |err|
-          record.errors.add attribute, err
-        end
-      else
-        record.errors.add attribute, :antivirus_virus_detected
+    return unless scanner.virus?(value)
+
+    if scanner.errors.any?
+      scanner.errors.each do |err|
+        record.errors.add attribute, err
       end
+    else
+      record.errors.add attribute, :antivirus_virus_detected
     end
   end
 end

data/lib/ratonvirus/engine.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Binding it to rails to make the app and config folders available in the Rails
 # load paths.
 module Ratonvirus

data/lib/ratonvirus/error.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ratonvirus
   class Error < StandardError; end
 

data/lib/ratonvirus/processable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ratonvirus
   class Processable
     def initialize(storage, asset)
@@ -7,6 +9,7 @@ module Ratonvirus
 
     def path(&block)
       return unless block_given?
+
       @storage.asset_path(@asset, &block)
     end
 

data/lib/ratonvirus/scanner/addon/remove_infected.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ratonvirus
   module Scanner
     module Addon
@@ -7,11 +9,12 @@ module Ratonvirus
         end
 
         private
-          def remove_infected_file(processable)
-            return unless errors.include?(:antivirus_virus_detected)
 
-            processable.remove
-          end
+        def remove_infected_file(processable)
+          return unless errors.include?(:antivirus_virus_detected)
+
+          processable.remove
+        end
       end
     end
   end

data/lib/ratonvirus/scanner/base.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ratonvirus
   module Scanner
     class Base
@@ -12,7 +14,7 @@ module Ratonvirus
       attr_reader :config
       attr_reader :errors # Only available after `virus?` has been called.
 
-      def initialize(configuration={})
+      def initialize(configuration = {})
         @config = default_config.merge!(configuration)
 
         # Make the following callbacks available:
@@ -113,42 +115,40 @@ module Ratonvirus
       end
 
       protected
-        def default_config
-          {
-            force_availability: false,
-          }
-        end
 
-        def storage
-          Ratonvirus.storage
-        end
+      def default_config
+        { force_availability: false }
+      end
 
-        def scan(processable)
-          processable.path do |path|
-            run_callbacks :scan, processable do
-              run_scan(path)
-            end
+      def storage
+        Ratonvirus.storage
+      end
+
+      def scan(processable)
+        processable.path do |path|
+          run_callbacks :scan, processable do
+            run_scan(path)
           end
         end
+      end
 
-        def run_scan(path)
-          raise NotImplementedError.new(
-            "Implement run_scan on #{self.class.name}"
-          )
-        end
+      def run_scan(_path)
+        raise NotImplementedError, "Implement run_scan on #{self.class.name}"
+      end
 
       private
-        # Prepare is called each time before scanning is run. During the first
-        # call to this method, the addons are applied to the scanner instance.
-        def prepare
-          return if @ready
 
-          Ratonvirus.addons.each do |addon_cls|
-            extend addon_cls
-          end
+      # Prepare is called each time before scanning is run. During the first
+      # call to this method, the addons are applied to the scanner instance.
+      def prepare
+        return if @ready
 
-          @ready = true
+        Ratonvirus.addons.each do |addon_cls|
+          extend addon_cls
         end
+
+        @ready = true
+      end
     end
   end
 end

data/lib/ratonvirus/scanner/eicar.rb

@@ -8,7 +8,7 @@ module Ratonvirus
     class Eicar < Base
       # SHA256 digest of the EICAR test file for virus testing
       # See: https://en.wikipedia.org/wiki/EICAR_test_file
-      EICAR_SHA256 = '131f95c51cc819465fa1797f6ccacf9d494aaaff46fa3eac73ae63ffbdfd8267'
+      EICAR_SHA256 = "131f95c51cc819465fa1797f6ccacf9d494aaaff46fa3eac73ae63ffbdfd8267"
 
       class << self
         def executable?
@@ -17,18 +17,17 @@ module Ratonvirus
       end
 
       protected
-        def run_scan(path)
-          if !File.file?(path)
-            errors << :antivirus_file_not_found
-          else
-            sha256 = Digest::SHA256.file path
-            if sha256 == EICAR_SHA256
-              errors << :antivirus_virus_detected
-            end
-          end
-        rescue
-          errors << :antivirus_client_error
+
+      def run_scan(path)
+        if !File.file?(path)
+          errors << :antivirus_file_not_found
+        else
+          sha256 = Digest::SHA256.file path
+          errors << :antivirus_virus_detected if sha256 == EICAR_SHA256
         end
+      rescue StandardError
+        errors << :antivirus_client_error
+      end
     end
   end
 end

data/lib/ratonvirus/scanner/support/callbacks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ratonvirus
   module Scanner
     module Support
@@ -44,40 +46,37 @@ module Ratonvirus
       #   end
       module Callbacks
         private
-          def run_callbacks(type, *args, &block)
-            if @_callbacks.nil?
-              raise NotDefinedError.new("No callbacks defined")
-            end
-            if @_callbacks[type].nil?
-              raise NotDefinedError.new("Callbacks for #{type} not defined")
-            end
 
-            run_callback_callables @_callbacks[type][:before], *args
-            result = yield *args
-            run_callback_callables @_callbacks[type][:after], *args
+        def run_callbacks(type, *args, &_block)
+          raise NotDefinedError, "No callbacks defined" if @_callbacks.nil?
+          raise NotDefinedError, "Callbacks for #{type} not defined" if @_callbacks[type].nil?
 
-            result
-          end
+          run_callback_callables @_callbacks[type][:before], *args
+          result = yield(*args)
+          run_callback_callables @_callbacks[type][:after], *args
 
-          def run_callback_callables(callables, *args)
-            callables.each do |callable|
-              send(callable, *args)
-            end
+          result
+        end
+
+        def run_callback_callables(callables, *args)
+          callables.each do |callable|
+            send(callable, *args)
           end
+        end
 
-          def define_callbacks(type)
-            @_callbacks ||= {}
-            @_callbacks[type] ||= {}
-            @_callbacks[type][:before] = []
-            @_callbacks[type][:after] = []
+        def define_callbacks(type)
+          @_callbacks ||= {}
+          @_callbacks[type] ||= {}
+          @_callbacks[type][:before] = []
+          @_callbacks[type][:after] = []
 
-            define_singleton_method "before_#{type}" do |callable|
-              @_callbacks[type][:before] << callable
-            end
-            define_singleton_method "after_#{type}" do |callable|
-              @_callbacks[type][:after] << callable
-            end
+          define_singleton_method "before_#{type}" do |callable|
+            @_callbacks[type][:before] << callable
+          end
+          define_singleton_method "after_#{type}" do |callable|
+            @_callbacks[type][:after] << callable
           end
+        end
       end
     end
   end

data/lib/ratonvirus/storage/active_storage.rb

@@ -3,7 +3,7 @@
 module Ratonvirus
   module Storage
     class ActiveStorage < Base
-      def changed?(record, attribute)
+      def changed?(_record, _attribute)
         # With Active Storage we assume the record is always changed because
         # there is currently no way to know if the attribute has actually
         # changed.
@@ -22,22 +22,20 @@ module Ratonvirus
 
       def accept?(resource)
         resource.is_a?(::ActiveStorage::Attached::One) ||
-        resource.is_a?(::ActiveStorage::Attached::Many)
+          resource.is_a?(::ActiveStorage::Attached::Many)
       end
 
-      def process(resource, &block)
+      def process(resource, &_block)
         return unless block_given?
         return if resource.nil?
 
-        if resource.attached?
-          if resource.is_a?(::ActiveStorage::Attached::One)
-            if resource.attachment
-              yield processable(resource.attachment)
-            end
-          elsif resource.is_a?(::ActiveStorage::Attached::Many)
-            resource.attachments.each do |attachment|
-              yield processable(attachment)
-            end
+        return unless resource.attached?
+
+        if resource.is_a?(::ActiveStorage::Attached::One)
+          yield processable(resource.attachment) if resource.attachment
+        elsif resource.is_a?(::ActiveStorage::Attached::Many)
+          resource.attachments.each do |attachment|
+            yield processable(attachment)
           end
         end
       end
@@ -55,42 +53,45 @@ module Ratonvirus
       end
 
       private
-        # This creates a local copy of the blob for the scanning process. A
-        # local copy is needed for processing because the actual blob may be
-        # stored at a remote storage service (such as Amazon S3), meaning it
-        # cannot be otherwise processed locally.
-        #
-        # NOTE:
-        # Later implementations of Active Storage have the blob.open method that
-        # provides similar functionality. However, Rails 5.2.x still does not
-        # include this functionality, so we need to take care of it ourselves.
-        #
-        # This was introduced in the following commit:
-        # https://github.com/rails/rails/commit/ee21b7c2eb64def8f00887a9fafbd77b85f464f1
-        #
-        # SEE:
-        # https://edgeguides.rubyonrails.org/active_storage_overview.html#downloading-files
-        def blob_path(blob)
-          tempfile = Tempfile.open(
-            ["Ratonvirus", blob.filename.extension_with_delimiter ],
-            tempdir
-          )
 
-          begin
-            tempfile.binmode
-            blob.download { |chunk| tempfile.write(chunk) }
-            tempfile.flush
-            tempfile.rewind
+      # This creates a local copy of the blob for the scanning process. A
+      # local copy is needed for processing because the actual blob may be
+      # stored at a remote storage service (such as Amazon S3), meaning it
+      # cannot be otherwise processed locally.
+      #
+      # NOTE:
+      # Later implementations of Active Storage have the blob.open method that
+      # provides similar functionality. However, Rails 5.2.x still does not
+      # include this functionality, so we need to take care of it ourselves.
+      #
+      # This was introduced in the following commit:
+      # https://github.com/rails/rails/commit/ee21b7c2eb64def8f00887a9fafbd77b85f464f1
+      #
+      # SEE:
+      # https://edgeguides.rubyonrails.org/active_storage_overview.html#downloading-files
+      def blob_path(blob)
+        tempfile = Tempfile.open(
+          ["Ratonvirus", blob.filename.extension_with_delimiter],
+          tempdir
+        )
 
-            yield tempfile.path
-          ensure
-            tempfile.close!
-          end
-        end
+        begin
+          tempfile.binmode
+          blob.download { |chunk| tempfile.write(chunk) }
+          tempfile.flush
+          tempfile.rewind
 
-        def tempdir
-          Dir.tmpdir
+          yield tempfile.path
+        rescue StandardError
+            return
+        ensure
+          tempfile.close!
         end
+      end
+
+      def tempdir
+        Dir.tmpdir
+      end
     end
   end
 end

data/lib/ratonvirus/storage/base.rb

@@ -1,14 +1,14 @@
+# frozen_string_literal: true
+
 module Ratonvirus
   module Storage
     class Base
       attr_reader :config
 
-      def initialize(configuration={})
+      def initialize(configuration = {})
         @config = configuration.dup
 
-        if respond_to?(:setup)
-          setup
-        end
+        setup if respond_to?(:setup)
       end
 
       # Default process implementation.
@@ -23,34 +23,27 @@ module Ratonvirus
         end
       end
 
-      def changed?(record, attribute)
-        raise NotImplementedError.new(
-          "Implement changed? on #{self.class.name}"
-        )
+      def changed?(_record, _attribute)
+        raise NotImplementedError, "Implement changed? on #{self.class.name}"
       end
 
-      def accept?(resource)
-        raise NotImplementedError.new(
-          "Implement accept? on #{self.class.name}"
-        )
+      def accept?(_resource)
+        raise NotImplementedError, "Implement accept? on #{self.class.name}"
       end
 
-      def asset_path(asset)
-        raise NotImplementedError.new(
-          "Implement path on #{self.class.name}"
-        )
+      def asset_path(_asset)
+        raise NotImplementedError, "Implement path on #{self.class.name}"
       end
 
-      def asset_remove(asset)
-        raise NotImplementedError.new(
-          "Implement remove on #{self.class.name}"
-        )
+      def asset_remove(_asset)
+        raise NotImplementedError, "Implement remove on #{self.class.name}"
       end
 
       protected
-        def processable(asset)
-          Processable.new(self, asset)
-        end
+
+      def processable(asset)
+        Processable.new(self, asset)
+      end
     end
   end
 end

data/lib/ratonvirus/storage/carrierwave.rb

@@ -25,7 +25,7 @@ module Ratonvirus
 
       def asset_remove(asset)
         path = asset.file.path
-        result = asset.remove!
+        asset.remove!
 
         # Remove the temp cache dir if it exists
         dir = File.dirname(path)

data/lib/ratonvirus/storage/filepath.rb

@@ -1,10 +1,10 @@
+# frozen_string_literal: true
+
 module Ratonvirus
   module Storage
     class Filepath < Base
       def changed?(record, attribute)
-        if record.respond_to? :"#{attribute}_changed?"
-          return record.public_send :"#{attribute}_changed?"
-        end
+        return record.public_send :"#{attribute}_changed?" if record.respond_to? :"#{attribute}_changed?"
 
         # Some backends do not implement the `attribute_changed?` methods for
         # the file resources. In that case our best guess is to check whether

data/lib/ratonvirus/storage/multi.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ratonvirus
   module Storage
     # Multi storage allows the developers to configure multiple storage backends
@@ -12,18 +14,18 @@ module Ratonvirus
       def setup
         @storages = []
 
-        if config[:storages].is_a?(Array)
-          config[:storages].each do |storage|
-            if storage.is_a?(Array)
-              type = storage[0]
-              storage_config = storage[1]
-            else
-              type = storage
-            end
+        return unless config[:storages].is_a?(Array)
 
-            cls = Ratonvirus.backend_class('Storage', type)
-            @storages << cls.new(storage_config || {})
+        config[:storages].each do |storage|
+          if storage.is_a?(Array)
+            type = storage[0]
+            storage_config = storage[1]
+          else
+            type = storage
           end
+
+          cls = Ratonvirus.backend_class("Storage", type)
+          @storages << cls.new(storage_config || {})
         end
       end
 
@@ -55,7 +57,7 @@ module Ratonvirus
 
       # Check if any of the storages accept the resource.
       def accept?(resource)
-        storage_for(resource) do |storage|
+        storage_for(resource) do |_storage|
           return true
         end
 
@@ -63,16 +65,17 @@ module Ratonvirus
       end
 
       private
-        # Iterates through the @storages array and returns the first storage
-        # that accepts the resource.
-        def storage_for(resource)
-          @storages.each do |storage|
-            if storage.accept?(resource)
-              yield storage
-              return
-            end
+
+      # Iterates through the @storages array and yields the first storage
+      # that accepts the resource.
+      def storage_for(resource)
+        @storages.each do |storage|
+          if storage.accept?(resource)
+            yield storage
+            break
           end
         end
+      end
     end
   end
 end

data/lib/ratonvirus/support/backend.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ratonvirus
   module Support
     # The backend implementation allows us to set different backends on the main
@@ -30,152 +32,150 @@ module Ratonvirus
 
         subclass = ActiveSupport::Inflector.camelize(backend_type.to_s)
         ActiveSupport::Inflector.constantize(
-          "#{self.name}::#{backend_cls}::#{subclass}"
+          "#{name}::#{backend_cls}::#{subclass}"
         )
       end
 
       private
-        # Defines the "backend" methods.
-        #
-        # For example, this:
-        #   define_backend :foo, 'Foo'
-        #
-        # Would define the following methods:
-        #   # Getter for foo
-        #   def self.foo
-        #     @foo ||= create_foo
-        #   end
-        #
-        #   # Setter for foo
-        #   def self.foo=(foo_type)
-        #     set_backend(
-        #       :foo,
-        #       'Foo',
-        #       foo_type
-        #     )
-        #   end
-        #
-        #   # Destroys the currently active foo.
-        #   # The foo is re-initialized when the getter is called.
-        #   def self.destroy_foo
-        #     @foo = nil
-        #   end
-        #
-        #   private
-        #     def self.create_foo
-        #       if @foo_defs.nil?
-        #         raise NotDefinedError.new("Foo not defined!")
-        #       end
-        #
-        #       @foo_defs[:klass].new(@foo_defs[:config])
-        #     end
-        #
-        # Usage (getter):
-        #   Ratonvirus.foo
-        #
-        # Usage (setter):
-        #   Ratonvirus.foo = :bar
-        #   Ratonvirus.foo = :bar, {option: 'value'}
-        #   Ratonvirus.foo = Ratonvirus::Foo::Bar.new
-        #   Ratonvirus.foo = Ratonvirus::Foo::Bar.new({option: 'value'})
-        #
-        # Usage (destroyer):
-        #   Ratonvirus.destroy_foo
-        #
-        def define_backend(backend_type, backend_subclass)
-          self.class_eval <<-CODE, __FILE__, __LINE__ + 1
-            # Getter for #{backend_type}
-            def self.#{backend_type}
-              @#{backend_type} ||= create_#{backend_type}
-            end
 
-            # Setter for #{backend_type}
-            def self.#{backend_type}=(#{backend_type}_value)
-              set_backend(
-                :#{backend_type},
-                "#{backend_subclass}",
-                #{backend_type}_value
-              )
-            end
+      # Defines the "backend" methods.
+      #
+      # For example, this:
+      #   define_backend :foo, 'Foo'
+      #
+      # Would define the following methods:
+      #   # Getter for foo
+      #   def self.foo
+      #     @foo ||= create_foo
+      #   end
+      #
+      #   # Setter for foo
+      #   def self.foo=(foo_type)
+      #     set_backend(
+      #       :foo,
+      #       'Foo',
+      #       foo_type
+      #     )
+      #   end
+      #
+      #   # Destroys the currently active foo.
+      #   # The foo is re-initialized when the getter is called.
+      #   def self.destroy_foo
+      #     @foo = nil
+      #   end
+      #
+      #   private
+      #     def self.create_foo
+      #       if @foo_defs.nil?
+      #         raise NotDefinedError.new("Foo not defined!")
+      #       end
+      #
+      #       @foo_defs[:klass].new(@foo_defs[:config])
+      #     end
+      #
+      # Usage (getter):
+      #   Ratonvirus.foo
+      #
+      # Usage (setter):
+      #   Ratonvirus.foo = :bar
+      #   Ratonvirus.foo = :bar, {option: 'value'}
+      #   Ratonvirus.foo = Ratonvirus::Foo::Bar.new
+      #   Ratonvirus.foo = Ratonvirus::Foo::Bar.new({option: 'value'})
+      #
+      # Usage (destroyer):
+      #   Ratonvirus.destroy_foo
+      #
+      def define_backend(backend_type, backend_subclass)
+        class_eval <<-CODE, __FILE__, __LINE__ + 1
+          # Getter for #{backend_type}
+          def self.#{backend_type}
+            @#{backend_type} ||= create_#{backend_type}
+          end
 
-            # Destroys the currently active #{backend_type}.
-            # The #{backend_type} is re-initialized when the getter is called.
-            def self.destroy_#{backend_type}
-              @#{backend_type} = nil
-            end
+          # Setter for #{backend_type}
+          def self.#{backend_type}=(#{backend_type}_value)
+            set_backend(
+              :#{backend_type},
+              "#{backend_subclass}",
+              #{backend_type}_value
+            )
+          end
 
-            # Creates a new backend instance
-            # private
-            def self.create_#{backend_type}
-              if @#{backend_type}_defs.nil?
-                raise NotDefinedError.new("#{backend_subclass} not defined!")
-              end
+          # Destroys the currently active #{backend_type}.
+          # The #{backend_type} is re-initialized when the getter is called.
+          def self.destroy_#{backend_type}
+            @#{backend_type} = nil
+          end
 
-              @#{backend_type}_defs[:klass].new(
-                @#{backend_type}_defs[:config]
-              )
+          # Creates a new backend instance
+          # private
+          def self.create_#{backend_type}
+            if @#{backend_type}_defs.nil?
+              raise NotDefinedError.new("#{backend_subclass} not defined!")
             end
-            private_class_method :create_#{backend_type}
-          CODE
-        end
 
-        # Sets the backend to local variables for the backend initialization.
-        # The goal of this method is to get the following configuration set to
-        # local `@x_defs` variable, where 'x' is the type of backend.
-        #
-        # For example, for a backend with type "scanner", this would be
-        # @scanner_defs.
-        #
-        # The first argument, "backend_type" is the type of backend we are
-        # configuring, e.g. `:scanner`.
-        #
-        # The second argument "backend_cls" is the backend subclass that is
-        # used in the module's namespace, e.g. "Scanner". This would refer to
-        # subclasses `Ratonvirus::Scanner::...`.
-        #
-        # The third argument "backend_value" is the actual value the user
-        # provided for the setter method, e.g. `:eicar` or
-        # `Ratonvirus::Scanner::Eicar.new`. The user may also provide a second
-        # argument to the setter method e.g. like
-        # `Ratonvirus.scanner = :eicar, {conf: 'option'}`, in which case these
-        # both arguments are provided in this argument as an array.
-        def set_backend(backend_type, backend_cls, backend_value)
-          base_class = backend_class(backend_cls, "Base")
+            @#{backend_type}_defs[:klass].new(
+              @#{backend_type}_defs[:config]
+            )
+          end
+          private_class_method :create_#{backend_type}
+        CODE
+      end
 
-          if backend_value.is_a?(base_class)
-            # Set the instance
-            instance_variable_set(:"@#{backend_type}", backend_value)
+      # Sets the backend to local variables for the backend initialization.
+      # The goal of this method is to get the following configuration set to
+      # local `@x_defs` variable, where 'x' is the type of backend.
+      #
+      # For example, for a backend with type "scanner", this would be
+      # @scanner_defs.
+      #
+      # The first argument, "backend_type" is the type of backend we are
+      # configuring, e.g. `:scanner`.
+      #
+      # The second argument "backend_cls" is the backend subclass that is
+      # used in the module's namespace, e.g. "Scanner". This would refer to
+      # subclasses `Ratonvirus::Scanner::...`.
+      #
+      # The third argument "backend_value" is the actual value the user
+      # provided for the setter method, e.g. `:eicar` or
+      # `Ratonvirus::Scanner::Eicar.new`. The user may also provide a second
+      # argument to the setter method e.g. like
+      # `Ratonvirus.scanner = :eicar, {conf: 'option'}`, in which case these
+      # both arguments are provided in this argument as an array.
+      def set_backend(backend_type, backend_cls, backend_value)
+        base_class = backend_class(backend_cls, "Base")
 
-            # Store the class (type) and config for storing them below to local
-            # variable in case it needs to be re-initialized at some point.
-            subtype = backend_value.class
-            config = backend_value.config
-          else
-            if backend_value.is_a?(Array)
-              subtype = backend_value.shift
-              config = backend_value.shift || {}
+        if backend_value.is_a?(base_class)
+          # Set the instance
+          instance_variable_set(:"@#{backend_type}", backend_value)
 
-              unless subtype.is_a?(Symbol)
-                raise InvalidError.new(
-                  "Invalid #{backend_type} type: #{subtype}"
-                )
-              end
-            elsif backend_value.is_a?(Symbol)
-              subtype = backend_value
-              config = {}
-            else
-              raise InvalidError.new("Invalid #{backend_type} provided!")
-            end
+          # Store the class (type) and config for storing them below to local
+          # variable in case it needs to be re-initialized at some point.
+          subtype = backend_value.class
+          config = backend_value.config
+        else
+          if backend_value.is_a?(Array)
+            subtype = backend_value.shift
+            config = backend_value.shift || {}
 
-            # Destroy the current one
-            send(:"destroy_#{backend_type}")
+            raise InvalidError, "Invalid #{backend_type} type: #{subtype}" unless subtype.is_a?(Symbol)
+          elsif backend_value.is_a?(Symbol)
+            subtype = backend_value
+            config = {}
+          else
+            raise InvalidError, "Invalid #{backend_type} provided!"
           end
 
-          instance_variable_set(:"@#{backend_type}_defs", {
-            klass: backend_class(backend_cls, subtype),
-            config: config,
-          })
+          # Destroy the current one
+          send(:"destroy_#{backend_type}")
         end
+
+        instance_variable_set(
+          :"@#{backend_type}_defs",
+          klass: backend_class(backend_cls, subtype),
+          config: config
+        )
+      end
     end
   end
 end

data/lib/ratonvirus/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ratonvirus
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/ratonvirus.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "fileutils"
 require "active_support"
 require "digest"
@@ -42,7 +44,7 @@ module Ratonvirus
   #
   # Usage (destroy):
   #   Ratonvirus.destroy_scanner
-  define_backend :scanner, 'Scanner'
+  define_backend :scanner, "Scanner"
 
   # Usage (set):
   #   Ratonvirus.storage = :active_storage
@@ -55,19 +57,19 @@ module Ratonvirus
   #
   # Usage (destroy):
   #   Ratonvirus.destroy_storage
-  define_backend :storage, 'Storage'
+  define_backend :storage, "Storage"
 
   # Resets Ratonvirus to its initial state and configuration
   def self.reset
     # Default addons
     @addons = [
       ActiveSupport::Inflector.constantize(
-        "#{self.name}::Scanner::Addon::RemoveInfected"
-      ),
+        "#{name}::Scanner::Addon::RemoveInfected"
+      )
     ]
 
-    self.destroy_scanner
-    self.destroy_storage
+    destroy_scanner
+    destroy_storage
   end
 
   def self.addons
@@ -77,15 +79,13 @@ module Ratonvirus
   def self.addons=(addons)
     @addons = []
     addons.each do |addon|
-      self.add_addon addon
+      add_addon addon
     end
   end
 
   def self.add_addon(addon)
     addon_cls = addon_class(addon)
-    unless @addons.include?(addon_cls)
-      @addons << addon_cls
-    end
+    @addons << addon_cls unless @addons.include?(addon_cls)
   end
 
   def self.remove_addon(addon)
@@ -99,7 +99,7 @@ module Ratonvirus
 
     subclass = ActiveSupport::Inflector.camelize(type.to_s)
     ActiveSupport::Inflector.constantize(
-      "#{self.name}::Scanner::Addon::#{subclass}"
+      "#{name}::Scanner::Addon::#{subclass}"
     )
   end
   private_class_method :addon_class

data/lib/tasks/ratonvirus.rake

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 namespace :ratonvirus do
   desc "Tests if the antivirus scanner is available and properly configured"
   task test: :environment do
@@ -9,7 +11,7 @@ namespace :ratonvirus do
         puts ""
         puts "Please refer to Ratonvirus documentation for proper configuration."
       end
-    rescue
+    rescue StandardError
       puts "Ratonvirus scanner is not configured."
       puts ""
       puts "Please refer to Ratonvirus documentation for proper configuration."
@@ -18,7 +20,7 @@ namespace :ratonvirus do
 
   desc "Scans the given file through the antivirus scanner"
   task scan: :environment do |t, args|
-    if args.extras.length < 1
+    if args.extras.empty?
       puts "No files given."
       puts "Usage:"
       puts "  #{t.name}[/path/to/first/file.pdf,/path/to/second/file.pdf]"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ratonvirus
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Antti Hukkanen
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-12-10 00:00:00.000000000 Z
+date: 2019-11-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -122,6 +122,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.64.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.64.0
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.32'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.32'
 description: Adds antivirus check capability for Rails applications.
 email:
 - antti.hukkanen@mainiotech.fi
@@ -171,8 +199,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Provides antivirus checks for Rails.