ddr-antivirus 1.3.3 → 2.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 45edd3ab36b7e24c365064108e8f5ed6566fb458
-  data.tar.gz: b4ec40b9b605251d6a33b7e14f8b6d81c0086ae1
+  metadata.gz: e16210de6035eef0c49f80ce61c7f2dee7b3fc88
+  data.tar.gz: bb79eb5e1a8aa063773e160855589f28e54f4dfd
 SHA512:
-  metadata.gz: ed04f9f8030a1990b446a924f420084a1376448261f13c89e1bca713480cdb635865791347b0e05536589a9ba574f8eae6866909efe4c7127561a69c88da068d
-  data.tar.gz: 06fcf4d60add02d1b24fae522ffb2b5eb0d913ce8edd0dbe35ff016df0342e1fc39fbbd255466f5e6b63ff01c24c29cbb5f39c36c63661681fa4e556dbfd7da7
+  metadata.gz: 6d7e101d5f4d85ff8067c2ccc8a98e88cb763cc96df60f719ca6831048058aed7c3b36fa18a68fa4acb65099b78b393ff6fc1b09da5992bbd00e9a9c5d2ff1d5
+  data.tar.gz: 7c48dd3ef7c397e26ac8fa3a0b7860336b6af332ade18327e5be016b1b98b79136f4aa8d445edeb5cdc50a139a3185ae274d9a22e2512baecf751aa283fb0e59

data/.rspec

@@ -1,3 +1,2 @@
 --color
---warnings
 --require spec_helper

data/.travis.yml

@@ -1,15 +1,8 @@
+sudo: false
 language: ruby
-before_install:
-  - sudo apt-get update -qq
-  - sudo apt-get install -y libclamav-dev clamav clamav-daemon clamav-freshclam
-before_script:
-  - sudo freshclam
-  - sudo /etc/init.d/clamav-daemon start
 rvm:
   - 2.1
+  - 2.2
 cache: 
   - bundler
-  - apt
-notifications:
-  email:
-    - lib-drs@duke.edu
+

data/Gemfile

@@ -1,5 +1,3 @@
 source 'https://rubygems.org'
 
 gemspec
-
-gem "coveralls", require: false

data/README.md

@@ -4,8 +4,6 @@ Pluggable antivirus service for Ruby applications.
 
 [![Gem Version](https://badge.fury.io/rb/ddr-antivirus.svg)](http://badge.fury.io/rb/ddr-antivirus)
 [![Build Status](https://travis-ci.org/duke-libraries/ddr-antivirus.svg?branch=develop)](https://travis-ci.org/duke-libraries/ddr-antivirus)
-[![Coverage Status](https://coveralls.io/repos/duke-libraries/ddr-antivirus/badge.png?branch=develop)](https://coveralls.io/r/duke-libraries/ddr-antivirus?branch=develop)
-[![Code Climate](https://codeclimate.com/github/duke-libraries/ddr-antivirus/badges/gpa.svg)](https://codeclimate.com/github/duke-libraries/ddr-antivirus)
 
 ## Installation
 
@@ -21,74 +19,57 @@ Or install it yourself as:
 
     $ gem install ddr-antivirus
 
-## How It Works
-
-Ddr::Antivirus does *not* provide a virus scanning engine as a runtime dependency. Instead, it will select a scanner adapter class for the software it finds in your environment following this procedure:
-
-- If the [clamav](https://github.com/eagleas/clamav) gem is available, it will select the `ClamavScannerAdapter`.
-- If the ClamAV Daemon client `clamdscan` is on the user's path, it will select the `ClamdScannerAdapter`.  Ddr::Antivirus *does not* manage clamd -- i.e., checking its status, starting or reloading the database.  These tasks must be managed externally.
-- Otherwise, it will select the [`NullScannerAdapter`](#the-nullscanneradapter).
-
-The auto-selection process may be overridden by configuration:
-
-```ruby
-Ddr::Antivirus.configure do |config|
-  config.scanner_adapter = :clamd # or :clamav, or :null
-end
-```
-
-## Usage
-
 ### Scanning ###
 
-Class: `Ddr::Antivirus::Scanner`
-
 ```ruby
 require "ddr-antivirus"
 
-# Using the class method .scan
-result = Ddr::Antivirus::Scanner.scan(path)
+result = Ddr::Antivirus.scan(path)
 
-# Using the instance method #scan with a block
-Ddr::Antivirus::Scanner.new do |scanner|
+Ddr::Antivirus.scanner do |scanner|
   result = scanner.scan(path)
 end
 ```
 
-The scanner raises a `Ddr::Antivirus::VirusFoundError` exception if a virus is found.
+### Exceptions
 
-### Results
+All exceptions under the `Ddr::Antivirus` namespace.
 
-Class: `Ddr::Antivirus::Adapters::ScanResult`
+`Error` - Parent exception class.
 
-A scanner adapter may subclass the base class to parse the raw result properly.
+`VirusFoundError` - A virus was found. The message includes the original output from the scanner.
 
-```ruby
->> require "ddr-antivirus"
-=> true
+`ScannerError` - The scanner encountered an error (e.g., error exit status).
 
->> result = Ddr::Antivirus::Scanner.scan("/path/to/blue-devil.png")
-=> #<Ddr::Antivirus::Adapters::ClamavScanResult:0x007f98fb169cc0 ...
+### Example
 
-# Was there a virus?
->> result.has_virus?
-=> false
+```
+> require 'ddr/antivirus'
+ => true
+ 
+> Ddr::Antivirus.scanner_adapter = :clamd
+ => :clamd
+
+> result = Ddr::Antivirus.scan "/path/to/image.jpg"
+ => #<Ddr::Antivirus::ScanResult:0x007f98f8b95670 @file_path="/path/to/image.jpg", @output="/path/to/image.jpg: OK\n\n----------- SCAN SUMMARY -----------\nInfected files: 0\nTime: 0.001 sec (0 m 0 s)\n", @scanned_at=2015-09-11 20:41:17 UTC, @version="ClamAV 0.98.7/20903/Fri Sep 11 08:42:07 2015">
+
+> result.version
+ => "ClamAV 0.98.7/20903/Fri Sep 11 08:42:07 2015"
 
-# Was there an error?
->> result.error?
-=> false 
+> result.scanned_at
+ => 2015-09-11 20:41:17 UTC
 
-# Success? (no virus or error)
->> result.ok?
-=> true
+> result.output
+ => "/path/to/image.jpg: OK\n\n----------- SCAN SUMMARY -----------\nInfected files: 0\nTime: 0.001 sec (0 m 0 s)\n"
 
-# What did the scanner adapter return?
->> result.raw
-=> 0 # ClamAV example
+> puts result.to_s
+/path/to/image.jpg: OK
 
-# String representation (example)
->> result.to_s
-=> "/path/to/blue-devil.png: OK (ClamAV 0.98.3/19595/Thu Nov  6 11:32:29 2014)"
+----------- SCAN SUMMARY -----------
+Infected files: 0
+Time: 0.001 sec (0 m 0 s)
+
+[ClamAV 0.98.7/20903/Fri Sep 11 08:42:07 2015]
 ```
 
 ### Logging
@@ -104,12 +85,19 @@ Ddr::Antivirus.logger = Logger.new("/path/to/custom.log")
 
 In order to avoid the overhead of ClamAV in test and/or development environments, the package provides a no-op adapter:
 
-```ruby
+```
 >> Ddr::Antivirus.scanner_adapter = :null
 => :null
 >> Ddr::Antivirus::Scanner.scan("/path/to/blue-devil.png")
-I, [2014-11-07T15:58:17.706866 #82651]  INFO -- : /path/to/blue-devil.png: NOT SCANNED - using :null scanner adapter. (ddr-antivirus 1.2.0)
-=> #<Ddr::Antivirus::Adapters::NullScanResult:0x007f9e2ba1af38 @raw="/path/to/blue-devil.png: NOT SCANNED - using :null scanner adapter.", @file_path="/path/to/blue-devil.png", @scanned_at=2014-11-07 20:58:17 UTC, @version="ddr-antivirus 1.2.0">
+=> #<Ddr::Antivirus::NullScanResult:0x007f9e2ba1af38 @output="/path/to/blue-devil.png: NOT SCANNED - using :null scanner adapter.", @file_path="/path/to/blue-devil.png", @scanned_at=2014-11-07 20:58:17 UTC, @version="ddr-antivirus 1.2.0">
+```
+
+### Test Mode
+
+To easily configure `Ddr::Antivirus` to use the `NullScannerAdapter` and log to the null device, turn on test mode:
+
+```ruby
+Ddr::Antivirus.test_mode!
 ```
 
 ## Contributing

data/ddr-antivirus.gemspec

@@ -18,9 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activesupport", "~> 4.0"
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency "rake"
-  spec.add_development_dependency "clamav"
   spec.add_development_dependency "rspec", "~> 3.0"
 end

data/lib/ddr/antivirus.rb

@@ -2,50 +2,56 @@ require "logger"
 
 require_relative "antivirus/version"
 require_relative "antivirus/scanner"
-require_relative "antivirus/adapters"
-
-require "active_support/core_ext/module/attribute_accessors"
+require_relative "antivirus/scan_result"
+require_relative "antivirus/scanner_adapter"
+require_relative "antivirus/adapters/null_scanner_adapter"
 
 module Ddr
   module Antivirus
 
-    class VirusFoundError < ::StandardError; end
+    class Error < ::StandardError; end
+    class VirusFoundError < Error; end
+    class ScannerError < Error; end
 
-    def self.configure
-      yield self
-    end
+    class << self
+      attr_accessor :logger, :scanner_adapter
 
-    #
-    # Custom logger
-    #
-    # Defaults to Rails logger if Rails is loaded; otherwise logs to STDERR.
-    #
-    mattr_accessor :logger do
-      if defined?(Rails) && Rails.logger
-        Rails.logger
-      else 
-        Logger.new(STDERR)    
+      def configure
+        yield self
+      end
+
+      def scan(path)
+        Scanner.scan(path)
       end
-    end
 
-    #
-    # Scanner adapter
-    #
-    # Defaults to:
-    # - :clamav adapter if the 'clamav' gem is installed; 
-    # - :clamd adapter if the 'clamdscan' executable is available;
-    # - otherwise, the :null adapter.
-    #
-    mattr_accessor :scanner_adapter do
-      begin
-        require "clamav"
-        :clamav
-      rescue LoadError
-        require "open3"
-        out, status = Open3.capture2e("which -a clamdscan")
-        status.success? ? :clamd : :null
+      def scanner
+        s = Scanner.new
+        block_given? ? yield(s) : s
+      end
+
+      def test_mode!
+        configure do |config|
+          config.logger = Logger.new(File::NULL)
+          config.scanner_adapter = :null
+        end
+      end
+
+      # @return [Class] the scanner adapter class
+      def get_adapter
+        if scanner_adapter.nil?
+          raise Error, "`Ddr::Antivirus.scanner_adapter` is not configured."
+        end
+        require_relative "antivirus/adapters/#{scanner_adapter}_scanner_adapter"
+        adapter_name = scanner_adapter.to_s.capitalize + "ScannerAdapter"
+        self.const_get(adapter_name, false)
       end
     end
 
+    self.logger = if defined?(Rails) && Rails.logger
+                    Rails.logger
+                  else
+                    Logger.new(STDERR)
+                  end
+
   end
 end

data/lib/ddr/antivirus/adapters/clamd_scanner_adapter.rb

@@ -1,69 +1,84 @@
+require "open3"
 require "fileutils"
-require_relative "scanner_adapter"
-require_relative "scan_result"
+require "shellwords"
 
-module Ddr
-  module Antivirus
-    module Adapters
-      #
-      # Adapter for clamd client (clamdscan)
-      #
-      class ClamdScannerAdapter < ScannerAdapter
+module Ddr::Antivirus
+  #
+  # Adapter for clamd client (clamdscan)
+  #
+  class ClamdScannerAdapter < ScannerAdapter
 
-        def scan(path)
-          raw = clamdscan(path)
-          ClamdScanResult.new(raw, path)
-        end
-
-        def clamdscan(path)
-          original_mode = File.stat(path).mode
-          FileUtils.chmod("a+r", path) unless File.world_readable?(path)
-          result = command(path)
-          FileUtils.chmod(original_mode, path) if File.stat(path).mode != original_mode
-          result
-        end
-
-        private
-
-        def command(path)
-          `clamdscan --no-summary "#{path}"`.strip
-        end
+    SCANNER = "clamdscan".freeze
 
+    def scan(path)
+      output, status = clamdscan(path)
+      result = ScanResult.new(path, output, version: version, scanned_at: Time.now.utc)
+      case status.exitstatus
+      when 0
+        result
+      when 1
+        raise VirusFoundError, result.to_s
+      when 2
+        raise ScannerError, result.to_s
       end
+    end
 
-      #
-      # Result of a scan with the ClamdScannerAdapter
-      #
-      class ClamdScanResult < ScanResult
+    def clamdscan(path)
+      make_readable(path) do
+        command(path)
+      end
+    end
 
-        def virus_found
-          if m = /: ([^\s]+) FOUND$/.match(raw)
-            m[1]
-          end
-        end
+    def version
+      out, err, status = Open3.capture3(SCANNER, "-V")
+      out.strip
+    end
 
-        def has_virus?
-          raw =~ / FOUND$/
-        end
+    private
 
-        def error?
-          raw =~ / ERROR$/
-        end
+    def command(path)
+      safe_path = Shellwords.shellescape(path)
+      Open3.capture2e(SCANNER, safe_path)
+    end
 
-        def ok?
-          raw =~ / OK$/
-        end
+    def make_readable(path)
+      changed = false
+      original = File.stat(path).mode # raises Errno::ENOENT
+      if !File.world_readable?(path)
+        changed = FileUtils.chmod("a+r", path)
+        logger.info "File #{path} made world-readable for virus scanning."
+      end
+      result = yield
+      if changed
+        FileUtils.chmod(original, path)
+        logger.info "Mode reset to original #{original} on file #{path}."
+      end
+      result
+    end
 
-        def to_s
-          "#{raw} (#{version})"
-        end
+  end
 
-        def default_version
-          `sigtool --version`.strip
-        end
+  # Result of a scan with the ClamdScannerAdapter
+  # @api private
+  class ClamdScanResult < ScanResult
 
+    def virus_found
+      if m = /: ([^\s]+) FOUND$/.match(output)
+        m[1]
       end
+    end
 
+    def ok?
+      status.exitstatus == 0
     end
+
+    def has_virus?
+      status.exitstatus == 1
+    end
+
+    def error?
+      status.exitstatus == 2
+    end
+
   end
 end

data/lib/ddr/antivirus/adapters/null_scanner_adapter.rb

@@ -1,25 +1,13 @@
-require_relative "scanner_adapter"
-require_relative "scan_result"
-
-module Ddr
-  module Antivirus
-    module Adapters
-      #
-      # A no-op adapter, primarily for testing and development.
-      #
-      class NullScannerAdapter < ScannerAdapter
-
-        def scan(path)
-          NullScanResult.new("#{path}: NOT SCANNED - using :null scanner adapter.", path)
-        end
-
-      end
-
-      #
-      # The result of the scan with the NullScannerAdapter.
-      #
-      class NullScanResult < ScanResult; end
-
+module Ddr::Antivirus
+  #
+  # A no-op adapter, primarily for testing and development.
+  #
+  class NullScannerAdapter < ScannerAdapter
+
+    def scan(path)
+      ScanResult.new(path, "#{path}: NOT SCANNED - using :null scanner adapter.")
     end
+
   end
+
 end

data/lib/ddr/antivirus/scan_result.rb

@@ -0,0 +1,35 @@
+module Ddr::Antivirus
+  #
+  # The result of a virus scan.
+  #
+  class ScanResult
+
+    attr_reader :file_path, :output, :scanned_at, :version
+
+    def initialize(file_path, output, scanned_at: nil, version: nil)
+      @file_path  = file_path
+      @output     = output
+      @scanned_at = scanned_at || default_time
+      @version    = version    || default_version
+    end
+
+    # Default time of virus scan - i.e., now.
+    # @return [Time] the time.
+    def default_time
+      Time.now.utc
+    end
+
+    # Default anti-virus software version information.
+    # @return [String] the version.
+    def default_version
+      "ddr-antivirus #{Ddr::Antivirus::VERSION}"
+    end
+
+    # String representation of the result
+    # @return [String] the representation.
+    def to_s
+      "#{output}\n[#{version}]"
+    end
+
+  end
+end

data/lib/ddr/antivirus/scanner.rb

@@ -1,36 +1,16 @@
-require "active_support/core_ext/class/attribute"
+require "delegate"
 
-module Ddr
-  module Antivirus
-    class Scanner
+module Ddr::Antivirus
+  class Scanner < SimpleDelegator
       
-      # Instance of scanner adapter
-      attr_reader :adapter
-
-      def self.scan(path)
-        new { |scanner| return scanner.scan(path) }
-      end
-
-      def initialize
-        @adapter = Ddr::Antivirus::Adapters.get_adapter
-        yield self if block_given?
-      end
-
-      def scan(path)
-        result = adapter.scan(path)
-        raise Ddr::Antivirus::VirusFoundError, result if result.has_virus?
-        logger.error("Antivirus scanner error (#{result.version})") if result.error?
-        logger.info(result.to_s)
-        result
-      end
-
-      private
-
-        def logger
-          Ddr::Antivirus.logger
-        end
+    def self.scan(path)
+      new.scan(path)
+    end
 
+    def initialize
+      super Ddr::Antivirus.get_adapter.new
     end
+
   end
 end
 

data/lib/ddr/antivirus/scanner_adapter.rb

@@ -0,0 +1,29 @@
+require_relative "scan_result"
+
+module Ddr::Antivirus
+  #
+  # @abstract Subclass and override {#scan} to implement a scanner adapter.
+  #
+  class ScannerAdapter
+
+    # Scan a file path for viruses.
+    #
+    # @param path [String] file path to scan.
+    # @return [Ddr::Antivirus::Adapters::ScanResult] the result of the scan.
+    def scan(path)
+      raise NotImplementedError, "Adapters must implement the `scan' method."
+    end
+
+    # Return the adapter configuration options
+    def config
+      Ddr::Antivirus.adapter_config
+    end
+
+    private
+
+    def logger
+      Ddr::Antivirus.logger
+    end
+
+  end
+end

data/lib/ddr/antivirus/version.rb

@@ -1,5 +1,5 @@
 module Ddr
   module Antivirus
-    VERSION = "1.3.3"
+    VERSION = "2.0.0.rc1"
   end
 end

data/spec/spec_helper.rb

@@ -1,25 +1,7 @@
-require "coveralls"
-Coveralls.wear!
-
-# This file was generated by the `rspec --init` command. Conventionally, all
-# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
-# The generated `.rspec` file contains `--require spec_helper` which will cause this
-# file to always be loaded, without a need to explicitly require it in any files.
-#
-# Given that it is always loaded, you are encouraged to keep this file as
-# light-weight as possible. Requiring heavyweight dependencies from this file
-# will add to the boot time of your test suite on EVERY test run, even for an
-# individual file that may not need all of that loaded. Instead, make a
-# separate helper file that requires this one and then use it only in the specs
-# that actually need it.
-#
-# The `.rspec` file also contains a few flags that are not defaults but that
-# users commonly want.
-#
-# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
-
 require 'ddr/antivirus'
 
+Ddr::Antivirus.test_mode!
+
 RSpec.configure do |config|
 # The settings below are suggested to provide a good initial experience
 # with RSpec, but feel free to customize to your heart's content.

data/spec/unit/clamd_scanner_adapter_spec.rb

@@ -1,66 +1,72 @@
-require "shared_examples_for_scan_results"
+require "tempfile"
 require "ddr/antivirus/adapters/clamd_scanner_adapter"
 
-module Ddr
-  module Antivirus
-    module Adapters
-      RSpec.describe ClamdScannerAdapter do
+module Ddr::Antivirus
+  RSpec.describe ClamdScannerAdapter do
 
-        let(:path) { File.expand_path(File.join("..", "..", "fixtures", "blue-devil.png"), __FILE__) }
-        let(:adapter) { described_class.new }
+    let(:path) { File.expand_path(File.join("..", "..", "fixtures", "blue-devil.png"), __FILE__) }
 
-        describe "permissions" do
-          before do
-            @file = Tempfile.new("test")
-            @file.write("Scan me!")
-            @file.close
-            allow(adapter).to receive(:command).with(@file.path) { "#{@file.path}: OK" }
-          end
-          after { @file.unlink }
-          describe "when the file is not world readable" do
-            it "should temporarily change the permissions" do
-              original_mode = File.stat(@file.path).mode
-              expect(FileUtils).to receive(:chmod).with("a+r", @file.path)
-              adapter.scan(@file.path)
-              expect(File.stat(@file.path).mode).to eq(original_mode)
-            end
-          end
-          describe "when the file is world readable" do
-            before { FileUtils.chmod("a+r", @file.path) }
-            it "should not change the permissions" do
-              original_mode = File.stat(@file.path).mode
-              expect(FileUtils).not_to receive(:chmod)
-              adapter.scan(@file.path)
-              expect(File.stat(@file.path).mode).to eq(original_mode)
-            end
-          end
-        end
+    before do
+      allow(subject).to receive(:version) { "version" }
+    end
 
-        describe "result" do
-          subject { adapter.scan(path) }
+    describe "permissions" do
+      before do
+        @file = Tempfile.new("test")
+        @file.write("Scan me!")
+        @file.close
+        allow(subject).to receive(:command).with(@file.path) { ["#{@file.path}: OK", double(exitstatus: 0)] }
+      end
+      after { @file.unlink }
+      describe "when the file is not world readable" do
+        it "should temporarily change the permissions" do
+          FileUtils.chmod("a-r", @file.path)
+          original_mode = File.stat(@file.path).mode
+          expect(FileUtils).to receive(:chmod).with("a+r", @file.path)
+          subject.scan(@file.path)
+          expect(File.stat(@file.path).mode).to eq(original_mode)
+        end
+      end
+      describe "when the file is world readable" do
+        before { FileUtils.chmod("a+r", @file.path) }
+        it "should not change the permissions" do
+          original_mode = File.stat(@file.path).mode
+          expect(FileUtils).not_to receive(:chmod)
+          subject.scan(@file.path)
+          expect(File.stat(@file.path).mode).to eq(original_mode)
+        end
+      end
+    end
 
-          it "should be a scan result" do
-            expect(subject).to be_a(ClamdScanResult)
-          end
-          it_should_behave_like "a scan result"
-          context "when a virus is found" do
-            before { allow(adapter).to receive(:clamdscan).with(path) { "#{path}: Bad-boy-35 FOUND" } }
-            it "should have a virus_found" do
-              expect(subject.virus_found).to eq "Bad-boy-35"
-            end
-            it_should_behave_like "a virus scan result"
-          end
-          context "when there is an error" do
-            before { allow(adapter).to receive(:clamdscan).with(path) { "#{path}: ERROR" } }
-            it "should not have a virus" do
-              expect(subject).not_to have_virus
-            end
-            it_should_behave_like "an error scan result"
-          end
-          context "success" do
-            before { allow(adapter).to receive(:clamdscan).with(path) { "#{path}: OK" } }
-            it_should_behave_like "a successful scan result"
-          end
+    describe "result" do
+      before do
+        allow(subject).to receive(:command).with(path) { ["output", status] }
+      end
+      describe "when a virus is found" do
+        let(:status) { double(exitstatus: 1) }
+        it "should raise a VirusFoundError" do
+          expect { subject.scan(path) }.to raise_error(VirusFoundError)
+        end
+      end
+      describe "when there is an error" do
+        let(:status) { double(exitstatus: 2) }
+        it "should raise a ScannerError" do
+          expect { subject.scan(path) }.to raise_error(ScannerError)
+        end
+      end
+      describe "success" do
+        let(:status) { double(exitstatus: 0) }
+        it "should have output" do
+          expect(subject.scan(path).output).to eq("output")
+        end
+        it "should have a scanned_at time" do
+          expect(subject.scan(path).scanned_at).to be_a(Time)
+        end
+        it "should have a version" do
+          expect(subject.scan(path).version).to eq("version")
+        end
+        it "should have the file_path" do
+          expect(subject.scan(path).file_path).to eq(path)
         end
       end
     end

metadata

@@ -1,29 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: ddr-antivirus
 version: !ruby/object:Gem::Version
-  version: 1.3.3
+  version: 2.0.0.rc1
 platform: ruby
 authors:
 - David Chandek-Stark
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-21 00:00:00.000000000 Z
+date: 2015-09-11 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: activesupport
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -52,20 +38,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: clamav
-  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
@@ -97,22 +69,15 @@ files:
 - ddr-antivirus.gemspec
 - lib/ddr-antivirus.rb
 - lib/ddr/antivirus.rb
-- lib/ddr/antivirus/adapters.rb
-- lib/ddr/antivirus/adapters/clamav_scanner_adapter.rb
 - lib/ddr/antivirus/adapters/clamd_scanner_adapter.rb
 - lib/ddr/antivirus/adapters/null_scanner_adapter.rb
-- lib/ddr/antivirus/adapters/scan_result.rb
-- lib/ddr/antivirus/adapters/scanner_adapter.rb
+- lib/ddr/antivirus/scan_result.rb
 - lib/ddr/antivirus/scanner.rb
+- lib/ddr/antivirus/scanner_adapter.rb
 - lib/ddr/antivirus/version.rb
 - spec/fixtures/blue-devil.png
-- spec/shared_examples_for_scan_results.rb
 - spec/spec_helper.rb
-- spec/unit/clamav_scanner_adapter_spec.rb
 - spec/unit/clamd_scanner_adapter_spec.rb
-- spec/unit/null_scanner_adapter_spec.rb
-- spec/unit/scan_result_spec.rb
-- spec/unit/scanner_spec.rb
 homepage: https://github.com/duke-libraries/ddr-antivirus
 licenses:
 - BSD-3-Clause
@@ -128,9 +93,9 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: 
 rubygems_version: 2.4.6
@@ -139,10 +104,5 @@ specification_version: 4
 summary: Pluggable antivirus scanning service.
 test_files:
 - spec/fixtures/blue-devil.png
-- spec/shared_examples_for_scan_results.rb
 - spec/spec_helper.rb
-- spec/unit/clamav_scanner_adapter_spec.rb
 - spec/unit/clamd_scanner_adapter_spec.rb
-- spec/unit/null_scanner_adapter_spec.rb
-- spec/unit/scan_result_spec.rb
-- spec/unit/scanner_spec.rb

data/lib/ddr/antivirus/adapters.rb

@@ -1,14 +0,0 @@
-module Ddr
-  module Antivirus
-    module Adapters
-
-      def self.get_adapter 
-        require_relative "adapters/#{Ddr::Antivirus.scanner_adapter}_scanner_adapter"
-        adapter_name = "#{Ddr::Antivirus.scanner_adapter.to_s.capitalize}ScannerAdapter"
-        klass = self.const_get(adapter_name.to_sym, false)
-        klass.new
-      end
-
-    end
-  end
-end

data/lib/ddr/antivirus/adapters/clamav_scanner_adapter.rb

@@ -1,82 +0,0 @@
-require "clamav"
-
-require_relative "scanner_adapter"
-require_relative "scan_result"
-
-module Ddr
-  module Antivirus
-    module Adapters
-      #
-      # Scanner adapter for the 'clamav' gem (Ruby libclamav bindings).
-      #
-      class ClamavScannerAdapter < ScannerAdapter
-        
-        def scan(path)
-          reload!
-          raw = engine.scanfile(path)
-          ClamavScanResult.new(raw, path)
-        end
-
-        # Load or reload the database of virus signatures.
-        def reload!
-          #
-          # ClamAV.instance.reload is supposed to reload the database if changed and return:
-          #
-          # 0 => unnecessary
-          # 1 => successful
-          # 2 => error (undocumented)
-          #
-          # However, reload raises a RuntimeError when the db needs to be reloaded, 
-          # in which case, loaddb must be called.
-          #
-          engine.loaddb unless [0, 1].include?(engine.reload)
-        rescue RuntimeError
-          engine.loaddb
-        end
-
-        def engine
-          ClamAV.instance
-        end
-
-      end
-
-      #
-      # Result of a scan with the ClamavScannerAdapter.
-      #
-      class ClamavScanResult < ScanResult
-
-        def virus_found
-          raw if has_virus?
-        end
-
-        def has_virus?
-          ![0, 1].include?(raw)
-        end
-
-        def error?
-          raw == 1
-        end
-
-        # A formatted status message (for consistency with clamdscan output).
-        # @return [String] the result status.
-        def status
-          return "FOUND #{virus_found}" if has_virus?
-          return "ERROR" if error?
-          "OK"
-        end
-
-        def to_s
-          "#{file_path}: #{status} (#{version})"
-        end
-
-        def default_version
-          # Engine and database versions
-          # E.g., ClamAV 0.98.3/19010/Tue May 20 21:46:01 2014
-          `sigtool --version`.strip
-        end
-
-      end
-
-    end
-  end
-end

data/lib/ddr/antivirus/adapters/scan_result.rb

@@ -1,61 +0,0 @@
-module Ddr
-  module Antivirus
-    module Adapters
-      #
-      # The result of a virus scan.
-      # 
-      class ScanResult
-        
-        attr_reader :raw, :file_path, :scanned_at, :version
-        
-        def initialize(raw, file_path, opts={})
-          @raw = raw
-          @file_path = file_path
-          @scanned_at = opts.fetch(:scanned_at, default_time)
-          @version = opts.fetch(:version, default_version)
-        end
-
-        # Default time of virus scan - i.e., now.
-        # @return [Time] the time.
-        def default_time
-          Time.now.utc
-        end
-
-        # Default anti-virus software version information.
-        # @return [String] the version.
-        def default_version
-          "ddr-antivirus #{Ddr::Antivirus::VERSION}"
-        end
-
-        # the name of virus found.
-        # @return [String] the virus name.
-        def virus_found; end
-
-        # Was a virus found? 
-        # @return [true, false] whether a virus was found.
-        def has_virus?
-          !virus_found.nil?
-        end
-
-        # Was there an error (reported by the scanner, not necessarily an exception)?
-        # @return [true, false] whether there was an error.
-        def error?
-          false
-        end
-
-        # Was the result OK - i.e., not an error and virus not found.
-        # @return [true, false] whether the result was OK.
-        def ok?
-          !(has_virus? || error?)
-        end
-
-        # String representation of the result
-        # @return [String] the representation.
-        def to_s
-          "#{raw} (#{version})"
-        end
-
-      end
-    end
-  end
-end

data/lib/ddr/antivirus/adapters/scanner_adapter.rb

@@ -1,25 +0,0 @@
-module Ddr
-  module Antivirus
-    module Adapters
-      #
-      # @abstract Subclass and override {#scan} to implement a scanner adapter.
-      #
-      class ScannerAdapter
-
-        # Scan a file path for viruses.
-        #
-        # @param path [String] file path to scan.
-        # @return [Ddr::Antivirus::Adapters::ScanResult] the result of the scan.
-        def scan(path)
-          raise NotImplementedError, "Adapters must implement the `scan' method."
-        end
-
-        # Return the adapter configuration options
-        def config
-          Ddr::Antivirus.adapter_config
-        end
-
-      end
-    end
-  end
-end

data/spec/shared_examples_for_scan_results.rb

@@ -1,53 +0,0 @@
-shared_examples "a scan result" do
-  it "should have a raw result" do
-    expect(subject.raw).not_to be_nil
-  end
-  it "should have a version" do
-    expect(subject.version).not_to be_nil
-  end
-  it "should have a scanned_at time" do
-    expect(subject.scanned_at).to be_a(Time)
-  end
-  it "should have a string representation" do
-    expect(subject.to_s).not_to be_nil
-  end
-end
-
-shared_examples "a successful scan result" do
-  it "should not have a virus" do
-    expect(subject.virus_found).to be_nil
-    expect(subject).not_to have_virus
-  end
-  it "should not have an error" do
-    expect(subject).not_to be_error
-  end
-  it "should be ok" do
-    expect(subject).to be_ok
-  end
-end
-
-shared_examples "an error scan result" do
-  it "should have an error" do
-    expect(subject).to be_error
-  end
-  it "shoud not have a virus" do
-    expect(subject.virus_found).to be_nil
-    expect(subject).not_to have_virus
-  end
-  it "should not be ok" do
-    expect(subject).not_to be_ok
-  end
-end
-
-shared_examples "a virus scan result" do
-  it "shoud have a virus" do
-    expect(subject.virus_found).not_to be_nil
-    expect(subject).to have_virus
-  end
-  it "should not have an error" do
-    expect(subject).not_to be_error
-  end
-  it "should not be ok" do
-    expect(subject).not_to be_ok
-  end
-end

data/spec/unit/clamav_scanner_adapter_spec.rb

@@ -1,66 +0,0 @@
-require "shared_examples_for_scan_results"
-require "ddr/antivirus/adapters/clamav_scanner_adapter"
-
-module Ddr
-  module Antivirus
-    module Adapters
-      RSpec.describe ClamavScannerAdapter do
-
-        let(:path) { File.expand_path(File.join("..", "..", "fixtures", "blue-devil.png"), __FILE__) }
-
-        describe "#scan" do
-          context "when the db is already loaded" do
-            before { subject.engine.loaddb }
-            it "should reload the db" do
-              expect(subject.engine).to receive(:reload).and_call_original
-              expect(subject.engine).not_to receive(:loaddb)
-              subject.scan(path)
-            end
-          end
-          context "when the db is not already loaded" do
-            before { allow(subject.engine).to receive(:reload).and_raise(RuntimeError) }
-            it "should load the db" do
-              expect(subject.engine).to receive(:loaddb).and_call_original
-              subject.scan(path)
-            end
-          end  
-          context "when the db is not reloaded successfully" do
-            before { allow(subject.engine).to receive(:reload) { 2 } }
-            it "should load the db" do
-              expect(subject.engine).to receive(:loaddb).and_call_original
-              subject.scan(path)
-            end
-          end
- 
-          describe "result" do
-            subject { adapter.scan(path) }
-            let(:adapter) { described_class.new }
-            it "should be a ClamavScanResult" do
-              expect(subject).to be_a(ClamavScanResult)
-            end
-            it_should_behave_like "a scan result"
-            context "when a virus is found" do
-              before { allow(adapter.engine).to receive(:scanfile).with(path) { "Bad boy 35" } }
-              it "the raw result should be the virus description" do
-                expect(subject.raw).to eq "Bad boy 35"
-                expect(subject.virus_found).to eq "Bad boy 35"
-              end
-              it_should_behave_like "a virus scan result"
-            end
-            context "when there is an error" do
-              before { allow(adapter.engine).to receive(:scanfile).with(path) { 1 } }
-              it "should not have a virus" do
-                expect(subject).not_to have_virus
-              end
-              it_should_behave_like "an error scan result"
-            end
-            context "success" do
-              before { allow(adapter.engine).to receive(:scanfile).with(path) { 0 } }
-              it_should_behave_like "a successful scan result"
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/spec/unit/null_scanner_adapter_spec.rb

@@ -1,24 +0,0 @@
-require "shared_examples_for_scan_results"
-require "ddr/antivirus/adapters/null_scanner_adapter"
-
-module Ddr
-  module Antivirus
-    module Adapters
-      RSpec.describe NullScannerAdapter do
-
-        let(:path) { File.expand_path(File.join("..", "..", "fixtures", "blue-devil.png"), __FILE__) }
-
-        describe "result" do
-          subject { adapter.scan(path) }
-          let(:adapter) { described_class.new }
-          it "should be a NullScanResult" do
-            expect(subject).to be_a(NullScanResult)
-          end
-          it_should_behave_like "a scan result"
-          it_should_behave_like "a successful scan result"
-        end
-
-      end
-    end
-  end
-end

data/spec/unit/scan_result_spec.rb

@@ -1,27 +0,0 @@
-require 'shared_examples_for_scan_results'
-
-module Ddr
-  module Antivirus
-    module Adapters
-      RSpec.describe ScanResult do
-        subject { described_class.new("Raw result", "/tmp/foo") }
-
-        it_should_behave_like "a scan result"
-
-        describe "success" do
-          it_should_behave_like "a successful scan result"        
-        end
-
-        describe "error" do
-          before { allow(subject).to receive(:error?) { true } }
-          it_should_behave_like "an error scan result"
-        end
-
-        describe "virus found" do
-          before { allow(subject).to receive(:virus_found) { "Bad boy 35" } }
-          it_should_behave_like "a virus scan result"
-        end
-      end
-    end
-  end
-end

data/spec/unit/scanner_spec.rb

@@ -1,57 +0,0 @@
-require "ddr/antivirus/adapters/scan_result"
-
-module Ddr
-  module Antivirus
-    RSpec.describe Scanner do
-
-      shared_examples "a scanner" do
-        let(:path) { "/tmp/foo" }
-        describe "logging" do
-          it "should log the result" do
-            expect(Ddr::Antivirus.logger).to receive(:info)
-            subject.scan(path)
-          end
-        end
-        describe "when a virus is found" do
-          before { allow_any_instance_of(Ddr::Antivirus::Adapters::ScanResult).to receive(:has_virus?) { true } }
-          it "should raise an execption" do
-            expect { subject.scan(path) }.to raise_error
-          end
-        end
-        describe "when a virus is not found" do
-          before { allow_any_instance_of(Ddr::Antivirus::Adapters::ScanResult).to receive(:has_virus?) { false } }
-          it "should return the scan result" do
-            expect(subject.scan(path)).to be_a(Ddr::Antivirus::Adapters::ScanResult)
-          end
-        end
-        describe "when an error occurs in the scanner" do
-          before { allow_any_instance_of(Ddr::Antivirus::Adapters::ScanResult).to receive(:error?) { true } }
-          it "should log an error" do
-            expect(Ddr::Antivirus.logger).to receive(:error)
-            subject.scan(path)
-          end
-        end
-      end
-
-      before do
-        @original_adapter = Ddr::Antivirus.scanner_adapter
-        Ddr::Antivirus.scanner_adapter = :null
-      end
-
-      after do
-        Ddr::Antivirus.scanner_adapter = @original_adapter
-      end
-
-      describe ".scan" do
-        subject { described_class }
-        it_behaves_like "a scanner"
-      end
-
-      describe "#scan" do
-        subject { described_class.new }
-        it_behaves_like "a scanner"
-      end
-
-    end
-  end
-end