littleneck_clamav 0.0.1 → 0.0.2

data/README.md

@@ -16,6 +16,8 @@ Requirements
 It is currently fully tested against:
 
  - Ruby 1.9.3
+ - Ruby 2.0.0
+ - Ruby 2.1.2
 
 Usage
 =====

data/lib/littleneck_clamav.rb

@@ -1,9 +1,8 @@
-require_relative "littleneck_clamav/clam"
-require_relative "littleneck_clamav/clamd"
-require_relative "littleneck_clamav/error"
+require_relative 'littleneck_clamav/clam'
+require_relative 'littleneck_clamav/clamd'
+require_relative 'littleneck_clamav/error'
 
 class LittleneckClamAV
-
   def engine
     scanner.engine
   end
@@ -16,23 +15,19 @@ class LittleneckClamAV
     scanner.database_date
   end
 
-  def available?
-    !!scanner
-  end
-
   def scan(*args)
     scanner.scan(*args)
   end
 
   def scanner
     @scanner ||= begin
-      scanner = scanners.find{|s| s.available? }
-      raise Error, "no scanner available, is ClamAV installed?" unless scanner
+      scanner = scanners.find(&:available?)
+      fail Error, 'no scanner available, is ClamAV installed?' unless scanner
       scanner
     end
   end
 
-private
+  private
 
   def preference
     [Clamd, Clam]
@@ -41,5 +36,4 @@ private
   def scanners
     @scanners ||= preference.map(&:new)
   end
-
 end

data/lib/littleneck_clamav/clam.rb

@@ -1,13 +1,12 @@
-require "cocaine"
-require "time"
+require 'cocaine'
+require 'English'
+require 'time'
 
-require_relative "result"
-require_relative "error"
+require_relative 'result'
+require_relative 'error'
 
 class LittleneckClamAV
-
   class Clam
-
     def engine
       version[:engine] if available?
     end
@@ -26,56 +25,57 @@ class LittleneckClamAV
 
     def scan(path)
       check_scan! path
-      opts = { :swallow_stderr => true, :expected_outcodes => [0, 1] }
-      params = ["--no-summary", path].join(" ")
-      output = Cocaine::CommandLine.new( command, params, opts ).run
-      parse_result path, output, $?.exitstatus
+      opts = { swallow_stderr: true, expected_outcodes: [0, 1] }
+      params = ['--no-summary', %("#{path}")].join(' ')
+      output = Cocaine::CommandLine.new(command, params, opts).run
+      parse_result path, output, $CHILD_STATUS.exitstatus
     end
 
     def command
-      "clamscan"
+      'clamscan'
     end
 
-  private
+    private
 
     def version
       @version ||= begin
-        opts = { :swallow_stderr => true }
-        params = "--version"
-        output = Cocaine::CommandLine.new( command, params, opts ).run
-        output.strip!
-        engine, db_version, db_date = output.sub(/^ClamAV /,'').split("/",3)
-        success = !!(db_version && db_date)
-        {
-          :output           => output,
-          :engine           => engine,
-          :database_version => db_version,
-          :database_date    => db_date,
-          :success          => success
-        }
+        opts = { swallow_stderr: true }
+        params = '--version'
+        output = Cocaine::CommandLine.new(command, params, opts).run.strip
+        parse_output(output)
       rescue Cocaine::ExitStatusError, Cocaine::CommandNotFoundError => e
-        {:error => e.message, :success => false }
+        { error: e.message, success: false }
       end
     end
 
-    def parse_result(path, output, code)
-      clean = $?.exitstatus == 0
-      description = output.split(":").last.strip
-      description.sub! " FOUND", ""
-      Result.new :path => path, :clean => clean, :description => description
+    def parse_output(output)
+      engine, db_version, db_date = output.sub(/^ClamAV /, '').split('/', 3)
+      success = !(db_version && db_date).nil?
+      {
+        output: output,
+        engine: engine,
+        database_version: db_version,
+        database_date: db_date,
+        success: success
+      }
+    end
+
+    def parse_result(path, output, _code)
+      clean = $CHILD_STATUS.exitstatus == 0
+      description = output.split(':').last.strip
+      description.sub! ' FOUND', ''
+      Result.new path: path, clean: clean, description: description
     end
 
     def check_scan!(path)
-      exists = File.exists? path
+      exists = File.exist? path
       if !exists
-        raise Error, "the path #{path} does not exist"
+        fail Error, "the path #{path} does not exist"
       elsif !available?
         message = "#{self.class} is not available"
         message << "because #{version[:message]}" if version[:message]
-        raise Error, message
+        fail Error, message
       end
     end
-
   end
-
 end

data/lib/littleneck_clamav/clamd.rb

@@ -1,13 +1,19 @@
-require_relative "clam"
+require 'English'
 
-class LittleneckClamAV
+require_relative 'clam'
 
+class LittleneckClamAV
   class Clamd < Clam
-
     def command
-      "clamdscan"
+      'clamdscan'
     end
 
+    def scan(path)
+      check_scan! path
+      opts = { swallow_stderr: true, expected_outcodes: [0, 1] }
+      params = %(--no-summary -<"#{path}")
+      output = Cocaine::CommandLine.new(command, params, opts).run
+      parse_result path, output, $CHILD_STATUS.exitstatus
+    end
   end
-
 end

data/lib/littleneck_clamav/error.rb

@@ -1,5 +1,3 @@
 class LittleneckClamAV
-
   class Error < StandardError; end
-
 end

data/lib/littleneck_clamav/result.rb

@@ -1,29 +1,21 @@
 class LittleneckClamAV
-
   class Result
-
     def initialize(opts)
       @path        = opts[:path]
       @clean       = opts[:clean]
       @description = opts[:description]
     end
 
-    def path
-      @path
-    end
+    attr_reader :path
 
     def clean?
       @clean
     end
 
     def infected?
-      !@clean
-    end
-
-    def description
-      @description
+      !clean?
     end
 
+    attr_reader :description
   end
-
 end

data/spec/clam_spec.rb

@@ -1,15 +1,35 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe LittleneckClamAV::Clam do
+RSpec.describe LittleneckClamAV::Clam do
 
-  it_behaves_like "a scanner"
+  it_behaves_like 'a scanner'
 
-  describe "instance method" do
+  describe 'instance method' do
 
-    describe "command" do
+    describe 'command' do
 
-      it "should return clamdscan" do
-        subject.command.should == "clamscan"
+      it 'should return clamdscan' do
+        expect(subject.command).to eql('clamscan')
+      end
+
+    end
+
+    describe 'scan' do
+
+      it 'should call Cocaine' do
+        file = __FILE__
+
+        allow(subject).to receive(:available?).and_return(true)
+
+        mock_cocaine cmd: subject.command,
+                     opts: %(--no-summary "#{file}"),
+                     params: {
+                       swallow_stderr: true,
+                       expected_outcodes: [0, 1]
+                     },
+                     output: "#{file}: OK"
+
+        subject.scan file
       end
 
     end

data/spec/clamd_spec.rb

@@ -1,13 +1,35 @@
-describe LittleneckClamAV::Clamd do
+require 'spec_helper'
 
-  it_behaves_like "a scanner"
+RSpec.describe LittleneckClamAV::Clamd do
 
-  describe "instance method" do
+  it_behaves_like 'a scanner'
 
-    describe "command" do
+  describe 'instance method' do
 
-      it "should return clamdscan" do
-        subject.command.should == "clamdscan"
+    describe 'command' do
+
+      it 'should return clamdscan' do
+        expect(subject.command).to eql('clamdscan')
+      end
+
+    end
+
+    describe 'scan' do
+
+      it 'should call Cocaine' do
+        file = __FILE__
+
+        allow(subject).to receive(:available?).and_return(true)
+
+        mock_cocaine cmd: subject.command,
+                     opts: %(--no-summary -<"#{file}"),
+                     params: {
+                       swallow_stderr: true,
+                       expected_outcodes: [0, 1]
+                     },
+                     output: "#{file}: OK"
+
+        subject.scan file
       end
 
     end

data/spec/littleneck_clamav_spec.rb

@@ -1,93 +1,80 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe LittleneckClamAV do
+RSpec.describe LittleneckClamAV do
 
-  describe "instance method" do
+  describe 'instance method' do
 
-    describe "engine" do
+    let(:scanner) { double('scanner') }
 
-      it "should call `engine` on the scanner" do
-        scanner = mock("scanner")
-        scanner.should_receive :engine
-        subject.stub( :scanner => scanner )
+    describe 'engine' do
+
+      it 'should call `engine` on the scanner' do
+        expect(scanner).to receive(:engine)
+        allow(subject).to receive(:scanner).and_return(scanner)
 
         subject.engine
       end
 
     end
 
-    describe "database_version" do
+    describe 'database_version' do
 
-      it "should call `database_version` on the scanner" do
-        scanner = mock("scanner")
-        scanner.should_receive :database_version
-        subject.stub( :scanner => scanner )
+      it 'should call `database_version` on the scanner' do
+        expect(scanner).to receive(:database_version)
+        allow(subject).to receive(:scanner).and_return(scanner)
 
         subject.database_version
       end
 
     end
 
-    describe "database_date" do
+    describe 'database_date' do
 
-      it "should call `database_date` on the scanner" do
-        scanner = mock("scanner")
-        scanner.should_receive :database_date
-        subject.stub( :scanner => scanner )
+      it 'should call `database_date` on the scanner' do
+        expect(scanner).to receive(:database_date)
+        allow(subject).to receive(:scanner).and_return(scanner)
 
         subject.database_date
       end
 
     end
 
-    describe "available?" do
-
-      it "should return true if a scanner is available" do
-        subject.stub( :scanner => Object.new )
-
-        subject.available?.should == true
-      end
-
-      it "should return false if a scanner is not available" do
-        subject.stub( :scanner => nil )
-
-        subject.available?.should == false
-      end
-
-    end
-
-    describe "scan" do
+    describe 'scan' do
 
-      it "should call `scan` on the scanner" do
-        scanner = mock("scanner")
-        scanner.should_receive :scan
-        subject.stub( :scanner => scanner )
+      it 'should call `scan` on the scanner' do
+        expect(scanner).to receive(:scan)
+        allow(subject).to receive(:scanner).and_return(scanner)
 
         subject.scan
       end
 
     end
 
-    describe "scanner" do
+    describe 'scanner' do
 
-      it "should return Clamd if available" do
-        LittleneckClamAV::Clamd.any_instance.stub(:available? => true)
+      it 'should return Clamd if available' do
+        allow_any_instance_of(LittleneckClamAV::Clamd).to(
+          receive(:available?).and_return(true))
 
-        subject.scanner.should be_a LittleneckClamAV::Clamd
+        expect(subject.scanner).to be_a(LittleneckClamAV::Clamd)
       end
 
-      it "should return Clam if Clamd is not available" do
-        LittleneckClamAV::Clamd.any_instance.stub(:available? => false)
-        LittleneckClamAV::Clam.any_instance.stub(:available? => true)
+      it 'should return Clam if Clamd is not available' do
+        allow_any_instance_of(LittleneckClamAV::Clamd).to(
+          receive(:available?).and_return(false))
+        allow_any_instance_of(LittleneckClamAV::Clam).to(
+          receive(:available?).and_return(true))
 
-        subject.scanner.should be_a LittleneckClamAV::Clam
+        expect(subject.scanner).to be_a(LittleneckClamAV::Clam)
       end
 
-      it "should raise an error if neither are available" do
-        LittleneckClamAV::Clamd.any_instance.stub(:available? => false)
-        LittleneckClamAV::Clam.any_instance.stub(:available? => false)
+      it 'should raise an error if neither are available' do
+        allow_any_instance_of(LittleneckClamAV::Clamd).to(
+          receive(:available?).and_return(false))
+        allow_any_instance_of(LittleneckClamAV::Clam).to(
+          receive(:available?).and_return(false))
 
-        lambda { subject.scanner }.should raise_error( LittleneckClamAV::Error )
+        expect { subject.scanner }.to raise_error(LittleneckClamAV::Error)
       end
 
     end

data/spec/result_spec.rb

@@ -1,51 +1,51 @@
-require "spec_helper"
+require 'spec_helper'
 
-describe LittleneckClamAV::Result do
+RSpec.describe LittleneckClamAV::Result do
 
-  describe "instance method" do
+  describe 'instance method' do
 
-    describe "infected?" do
+    describe 'infected?' do
 
-      it "should return true when infected" do
-        result = result_factory :clean => false
-        result.infected?.should be_true
+      it 'should return true when infected' do
+        result = result_factory clean: false
+        expect(result.infected?).to be(true)
       end
 
-      it "should return false when clean" do
-        result = result_factory :clean => true
-        result.infected?.should be_false
+      it 'should return false when clean' do
+        result = result_factory clean: true
+        expect(result.infected?).to be(false)
       end
 
     end
 
-    describe "clean?" do
+    describe 'clean?' do
 
-      it "should return true when clean" do
-        result = result_factory :clean => true
-        result.clean?.should be_true
+      it 'should return true when clean' do
+        result = result_factory clean: true
+        expect(result.clean?).to be(true)
       end
 
-      it "should return false when infected" do
-        result = result_factory :clean => false
-        result.clean?.should be_false
+      it 'should return false when infected' do
+        result = result_factory clean: false
+        expect(result.clean?).to be(false)
       end
 
     end
 
-    describe "description" do
+    describe 'description' do
 
-      it "should return the description passed in" do
-        result = result_factory :description => "Hello"
-        result.description.should == "Hello"
+      it 'should return the description passed in' do
+        result = result_factory description: 'Hello'
+        expect(result.description).to eql('Hello')
       end
 
     end
 
-    describe "path" do
+    describe 'path' do
 
-      it "should return the path passed in" do
-        result = result_factory :path => "foo/bar"
-        result.path.should == "foo/bar"
+      it 'should return the path passed in' do
+        result = result_factory path: 'foo/bar'
+        expect(result.path).to eql('foo/bar')
       end
 
     end

data/spec/spec_helper.rb

@@ -1,11 +1,12 @@
-$:.unshift File.join(File.dirname(File.dirname(__FILE__)),'lib')
+$LOAD_PATH.unshift File.join(File.dirname(File.dirname(__FILE__)), 'lib')
 
-require "littleneck_clamav"
-require "rspec/mocks/any_instance"
+require 'littleneck_clamav'
 
-Dir[File.join(File.dirname(__FILE__),'support','*.rb')].each{|f| require f }
+Dir[File.join(File.dirname(__FILE__), 'support', '*.rb')].each { |f| require f }
 
 RSpec.configure do |config|
   config.expect_with :rspec
-  config.mock_with   :rspec
+  config.mock_with :rspec
+
+  config.disable_monkey_patching!
 end

data/spec/support/factories.rb

@@ -1,9 +1,57 @@
 def result_factory(override = {})
   options = {
-    :success     => true,
-    :path        => "foo.txt",
-    :description => "OK"
-  }.merge( override )
+    success: true,
+    path: 'foo.txt',
+    description: 'OK'
+  }.merge(override)
 
   LittleneckClamAV::Result.new options
 end
+
+def mock_cocaine(cocaine_options = {})
+  MockCocaine.new(cocaine_options).mock
+end
+
+class MockCocaine
+  include RSpec::Mocks::ExampleMethods
+
+  def initialize(options)
+    @options = defaults.merge(options)
+  end
+
+  def mock
+    build_mock
+    setup_exit_value
+  end
+
+  private
+
+  attr_reader :options
+
+  def defaults
+    { output: '', exitvalue: 0 }
+  end
+
+  def build_mock
+    basic_mock = expect(Cocaine::CommandLine).to(receive(:new))
+    basic_mock.with(*cocaine_arguments) if any_argument_options?
+    basic_mock.and_return(cocaine_command_double)
+    basic_mock.and_raise(options[:raise]) if options.key?(:raise)
+  end
+
+  def cocaine_command_double
+    double('cocaine command', run: options[:output])
+  end
+
+  def cocaine_arguments
+    [options[:cmd], options[:opts], options[:params]]
+  end
+
+  def any_argument_options?
+    options[:cmd] || options[:opts] || options[:params]
+  end
+
+  def setup_exit_value
+    options[:exitvalue] == 0 ? `true` : `false`
+  end
+end

data/spec/support/shared_examples.rb

@@ -1,127 +1,102 @@
-shared_examples_for "a scanner" do
-
-  def mock_cocaine(cocaine_options={})
-    options = { :output => "", :exitvalue => 0 }.merge( cocaine_options )
-    mock = Cocaine::CommandLine.should_receive( :new )
-    mock = mock.with(
-      options[:cmd], options[:opts], options[:params]
-    ) if options[:cmd] || options[:opts] || options[:params]
-
-    if cocaine_options[:raise]
-      mock.and_raise cocaine_options[:raise]
-    else
-      mock.and_return(
-        double "cocaine command", :run => options[:output]
-      )
-    end
-
-    `true`  if options[:exitvalue] == 0
-    `false` if options[:exitvalue] == 1
-  end
+shared_examples_for 'a scanner' do
 
- describe "instance method" do
+  describe 'instance method' do
 
-    describe "engine" do
+    describe 'engine' do
 
-      it "should call Cocaine with correct parameters" do
-        mock_cocaine :cmd => subject.command, :opts => "--version", :params => { :swallow_stderr => true }
+      it 'should call Cocaine with correct parameters' do
+        mock_cocaine cmd: subject.command,
+                     opts: '--version',
+                     params: { swallow_stderr: true }
         subject.engine
       end
 
-      it "should interpret the return value correctly" do
-        mock_cocaine :output => "ClamAV 0.97.5/15306/Tue Aug 28 20:18:12 2012\n"
-        subject.engine.should == "0.97.5"
+      it 'should interpret the return value correctly' do
+        mock_cocaine output: "ClamAV 0.97.5/15306/Tue Aug 28 20:18:12 2012\n"
+        expect(subject.engine).to eql('0.97.5')
       end
 
     end
 
-    describe "database_version" do
+    describe 'database_version' do
 
-      it "should call Cocaine with correct parameters" do
-        mock_cocaine :cmd => subject.command, :opts => "--version", :params => { :swallow_stderr => true }
+      it 'should call Cocaine with correct parameters' do
+        mock_cocaine cmd: subject.command,
+                     opts: '--version',
+                     params: { swallow_stderr: true }
         subject.database_version
       end
 
-      it "should interpret the return value correctly" do
-        mock_cocaine :output => "ClamAV 0.97.5/15306/Tue Aug 28 20:18:12 2012\n"
-        subject.database_version.should == 15306
+      it 'should interpret the return value correctly' do
+        mock_cocaine output: "ClamAV 0.97.5/15306/Tue Aug 28 20:18:12 2012\n"
+        expect(subject.database_version).to eql(15_306)
       end
 
     end
 
-    describe "database_version" do
+    describe 'database_version' do
 
-      it "should call Cocaine with correct parameters" do
-        mock_cocaine :cmd => subject.command, :opts => "--version", :params => { :swallow_stderr => true }
+      it 'should call Cocaine with correct parameters' do
+        mock_cocaine cmd: subject.command,
+                     opts: '--version',
+                     params: { swallow_stderr: true }
         subject.database_date
       end
 
-      it "should interpret the return value correctly" do
-        mock_cocaine :output => "ClamAV 0.97.5/15306/Tue Aug 28 20:18:12 2012\n"
-        subject.database_date.should == Time.parse("Tue Aug 28 20:18:12 2012")
+      it 'should interpret the return value correctly' do
+        mock_cocaine output: "ClamAV 0.97.5/15306/Tue Aug 28 20:18:12 2012\n"
+        expect(subject.database_date).to eql(
+          Time.parse('Tue Aug 28 20:18:12 2012')
+        )
       end
 
     end
 
-    describe "available?" do
+    describe 'available?' do
 
-      it "should return true when Cocaine returns okay" do
-        mock_cocaine :output => "ClamAV 0.97.5/15306/Tue Aug 28 20:18:12 2012\n"
+      it 'should return true when Cocaine returns okay' do
+        mock_cocaine output: "ClamAV 0.97.5/15306/Tue Aug 28 20:18:12 2012\n"
 
-        subject.available?.should == true
+        expect(subject.available?).to be(true)
       end
 
-      it "should return false when command errors" do
-        mock_cocaine :raise => Cocaine::ExitStatusError.new( "oh noes" )
+      it 'should return false when command errors' do
+        mock_cocaine raise: Cocaine::ExitStatusError.new('oh noes')
 
-        subject.available?.should == false
+        expect(subject.available?).to be(false)
       end
 
-      it "should return false when command is not found" do
-        mock_cocaine :raise => Cocaine::CommandNotFoundError
+      it 'should return false when command is not found' do
+        mock_cocaine raise: Cocaine::CommandNotFoundError
 
-        subject.available?.should == false
+        expect(subject.available?).to be(false)
       end
 
     end
 
-    describe "scan" do
-
-      it "should call Cocaine" do
-        file = __FILE__
-
-        subject.stub(:available?).and_return(true)
+    describe 'scan' do
 
-        mock_cocaine :cmd => subject.command,
-                     :opts => "--no-summary #{file}",
-                     :params => { :swallow_stderr => true, :expected_outcodes => [0, 1] },
-                     :output => "#{file}: OK"
-
-        subject.scan file
-      end
-
-      it "should create a Result" do
+      it 'should create a Result' do
         file = __FILE__
 
-        subject.stub(:available?).and_return(true)
+        allow(subject).to receive(:available?).and_return(true)
 
-        mock_cocaine :output => "#{file}: OK\n"
+        mock_cocaine output: "#{file}: OK\n"
 
-        LittleneckClamAV::Result.should_receive(:new).with(:path => file, :clean => true, :description => "OK")
+        expect(LittleneckClamAV::Result).to receive(:new)
+          .with(path: file, clean: true, description: 'OK')
 
         subject.scan file
       end
 
-      it "should raise an error if the path does not exist" do
-        lambda { subject.scan "foo" }.should raise_error( LittleneckClamAV::Error )
+      it 'should raise an error if the path does not exist' do
+        expect { subject.scan 'foo' }.to raise_error(LittleneckClamAV::Error)
       end
 
-      it "should raise an error if it is not available" do
-        file = __FILE__
-
-        subject.stub(:available?).and_return(false)
+      it 'should raise an error if it is not available' do
+        allow(subject).to receive(:available?).and_return(false)
 
-        lambda { subject.scan "foo" }.should raise_error( LittleneckClamAV::Error )
+        expect { subject.scan 'foo' }.to raise_error(LittleneckClamAV::Error)
       end
 
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: littleneck_clamav
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-11 00:00:00.000000000 Z
+date: 2014-12-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cocaine
@@ -50,7 +50,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.11'
+        version: '3.1'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -58,7 +58,23 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.11'
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email: theo.c@zepler.net
 executables: []
@@ -95,7 +111,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4199699967230361114
+      hash: 2481354664776410882
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -104,7 +120,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23.2
 signing_key: 
 specification_version: 3
 summary: A thin wrapper to make it quick and easy to use ClamAV (daemonised or not)