clam_scan 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea305456c7f41d11c6dc629ccf15ad6807ebc127
+  data.tar.gz: d6e2cb317c9e6d053f5ec1e60d7fd55414f3abea
+SHA512:
+  metadata.gz: b6db45f5403778c1209dac018f95d073aaa6cddc8bbcc2589dbdb1179b71f802761f16388972ab92f4cf5c8d0f0ccbf6be86f8fe25810d380573d4c8ec6ea73e
+  data.tar.gz: ffeab6f0d74d3d5c7439cfbbf12330c0ce271d17b001aa4a4382749be31a20e00856d6e01aba2cec6791c29dbe2dc8a863d44f940a012e391a5e6d4baa9f7b61

data/.gitignore

@@ -0,0 +1,23 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+spec/data/

data/.rspec

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

data/Gemfile

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

data/LICENSE.txt

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

data/README.md

@@ -0,0 +1,154 @@
+# ClamScan
+
+Ruby wrapper for ClamAV's clamscan/clamdscan.
+
+## Features
+
+* Lightweight pure-ruby wrapper
+* System call arguments always properly escaped with `IO.popen`
+* Scan a data stream before writing to disk
+* Supports and validates all arguments supported by clamscan/clamdscan
+
+## Installation
+
+### Gem
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'clam_scan'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install clam_scan
+
+### ClamAV
+
+You will also need ClamAV (and optionally the ClamAV daemon) installed.  On Ubuntu:
+
+`$ sudo apt-get install clamav` will install ClamAV and the `clamscan` cli client.
+
+`$ sudo apt-get install clamav-daemon` will install the ClamAV daemon and the 'clamdscan' cli client.
+
+Other *nix systems can do the equivalent from their respective package manager or install from source.  Mac users should be able to something equivalent with homebrew.  Windows... good luck.
+
+If you _really_ have an aversion to installing the daemon on your development machine, that's OK, but be aware that using the daemon can be literally thousands of orders of magnitude faster for scanning small files because it doesn't have to load the virus database every time a scan is initiated.  You'll also need to set `client_location` to point to clamscan (see below).
+
+## Usage
+
+### Configuration
+
+```ruby
+ClamScan.configure do |config|
+  # provide default options to be passed to ClamScan::Client.scan
+  # options passed directly to a call to ClamScan::Client.scan will override these
+  # by merging the default options with the passed options
+  config.default_scan_options       = {stdout: true} # default (request all output to be sent to STDOUT so it can be captured)
+
+  # path to clamscan/clamdscan client
+  # try `which clamdscan` or `which clamscan` in your shell to see where you should point this to
+  # recommended to set to an absolute path to clamdscan
+  config.client_location            = '/usr/bin/clamdscan' # default
+
+  # if set to true, ClamScan will raise an exception
+  # unless a scan is successful and no viruses were found
+  config.raise_unless_safe          = false # default
+end
+```
+
+### Example Code
+
+```ruby
+# scan file on disk
+options = {location: '/path/to/file'}
+
+# scan data stream
+options = {stream: some_binary_data}
+
+# initiate scan - returns ClamScan::Response object
+respone = ClamScan::Client.scan(options)
+
+# check output from clamscan
+puts response.body
+
+# check response status
+response.safe?    # true if scan was successful and no virus was found
+response.virus?   # true if scan was successful an virus was found
+response.error?   # true if scan returned with a known error status
+response.unknown? # true if scan returned with an unknown status
+response.status   # one of [:error, :safe, :unknown, :virus]
+
+# short snippet appropriate for most situations
+unless ClamScan::Client.scan(location: '/path/to/file').safe?
+  # do something
+end
+```
+
+### Advanced Usage
+
+ClamScan supports and validates any options supported by the clamscan cli client.  The convention when passing options to ClamScan is to remove the first two leading hyphens and chang the remaining hyphens to underscores.
+
+```ruby
+# equivalent to `clamscan --recursive --max-recursion=5 /path/to/dir`
+ClamScan::Client.scan(location: '/path/to/dir', recursive: true, max_recursion: 5)
+```
+
+You can also pass an array of custom options that will not be validated.
+
+```ruby
+# equivalent to `clamscan --recursive --max-recursion=5 /path/to/dir`
+args = ['--recursive', '--max-recursion=5', '/path/to'dir']
+ClamScan::Client.scan(custom_args: args)
+```
+
+ClamScan _should_ support and validate any arguments supported by ClamAV 0.98.  See lib/request.rb and ClamAV's man page.
+
+### Deleting infected files
+
+ClamScan does _not_ delete infected files by default, conforming with the defaults of clamscan/clamdscan.  If you want that behaviour, you can do something like:
+
+```ruby
+ClamScan.configure do |config|
+  # merge instead of re-assign so as to not blow away {stdout: true} default
+  config.default_scan_options.merge {remove: 'yes'}
+end
+```
+
+Or you could arrange to have them moved or copied somewhere.  See `man clamscan`.
+
+### Exceptions
+
+Any exception raised by ClamScan _should_ be a subclass of `ClamScan::Error`.
+
+If an unrecognized option is passed to `ClamScan::Client::scan` or an error occurs while making attempting to make the system call, a `ClamScan::RequestError` is raised.
+
+If `config.raise_unless_safe` is true, a `ClamScan::VirusDetected`, `ClamScan::UnknownError` or `ClamScan::ResponseError` could be raised.  The first two are subclasses of the last and all have a `response` attribute that contains a `ClamScan::Response` object that can be further inspected.
+
+### Rails
+
+ClamScan is a pure ruby wrapper and thus can be used in any ruby project, including one using rails.
+
+```ruby
+# add virus-free validation with carrierwave
+validate :virus_free
+
+def virus_free
+  if self.file.present? && !ClamScan::Client.scan(location: self.file.url).safe?
+    File.delete(self.file.url)
+    errors.add(:file, 'That file can not be accepted')
+  end
+end
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/jschroeder9000/clam_scan/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/clam_scan.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'clam_scan/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "clam_scan"
+  spec.version       = ClamScan::VERSION
+  spec.authors       = ["John Schroeder"]
+  spec.email         = ["jschroeder@multiadsolutions.com"]
+  spec.summary       = %q{Ruby wrapper for ClamAV's clamscan/clamdscan.}
+  spec.description   = %q{Ruby wrapper for ClamAV's clamscan/clamdscan.}
+  spec.homepage      = "https://github.com/jschroeder9000/clam_scan"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/clam_scan.rb

@@ -0,0 +1,20 @@
+require "clam_scan/client"
+require "clam_scan/configuration"
+require "clam_scan/exceptions"
+require "clam_scan/request"
+require "clam_scan/response"
+require "clam_scan/version"
+
+module ClamScan
+  @@configuration = Configuration.new
+
+  def self.configure
+    yield @@configuration if block_given?
+  end
+
+  def self.configuration
+    @@configuration
+  end
+
+  configure
+end

data/lib/clam_scan/client.rb

@@ -0,0 +1,21 @@
+module ClamScan
+  class Client
+    class << self
+      def scan (opts={})
+        response = Request.send(opts)
+
+        if ::ClamScan.configuration.raise_unless_safe
+          if response.virus?
+            raise VirusDetected.new(response)
+          elsif response.unknown?
+            raise UnknownError.new(response)
+          elsif !response.safe?
+            raise ResponseError.new(response)
+          end
+        end
+
+        response
+      end
+    end
+  end
+end

data/lib/clam_scan/configuration.rb

@@ -0,0 +1,17 @@
+module ClamScan
+  class Configuration
+    attr_accessor :default_scan_options
+    attr_accessor :client_location
+    attr_accessor :raise_unless_safe
+
+    def initialize
+      @default_scan_options       = {stdout: true}
+      @client_location            = '/usr/bin/clamdscan'
+      @raise_unless_safe          = false
+    end
+
+    def reset!
+      initialize
+    end
+  end
+end

data/lib/clam_scan/exceptions.rb

@@ -0,0 +1,28 @@
+module ClamScan
+  class Error < StandardError
+  end
+
+  class RequestError < Error
+  end
+
+  class ResponseError < Error
+    attr_reader :response
+
+    def initialize (response, message=nil)
+      @response = response
+      message ||= response.body
+      super(message)
+    end
+  end
+
+  class UnknownError < ResponseError
+    def initialize (response, message=nil)
+      message ||= response.body
+      message = "An unknown error caused #{::ClamScan.configuration.client_location} to exit with status #{response.process_status.exitstatus.to_s}\n#{message}"
+      super(response, message)
+    end
+  end
+
+  class VirusDetected < ResponseError
+  end
+end

data/lib/clam_scan/request.rb

@@ -0,0 +1,128 @@
+module ClamScan
+  class Request
+    class << self
+      def send (opts={})
+        output_lines = []
+
+        begin
+          IO.popen(popen_args(opts), 'r+') do |f|
+            if opts[:stream]
+              f.write opts[:stream]
+              f.close_write
+            end
+            while line = f.gets
+              output_lines << line
+            end
+          end
+        rescue SystemCallError => e
+          raise RequestError, "An error occured while making system call to #{::ClamScan.configuration.client_location}: #{e.to_s}"
+        end
+
+        output_string = output_lines.join("\n")
+        Response.new($?, output_string)
+      end
+
+    private
+
+      BOOLEAN_ARGS = %w(
+        allmatch
+        bell
+        infected
+        leave_temps
+        no_summary
+        quiet
+        recursive
+        stdout
+        verbose
+      )
+
+      IGNORE_ARGS = %w(
+        custom_args
+        location
+        stream
+      )
+
+      VALUE_ARGS = %w(
+        algorithmic_detection
+        block_encrypted
+        bytecode
+        bytecode_statistics
+        bytecode_timeout
+        bytecode_unsigned
+        copy
+        cross_fs
+        database
+        detect_broken
+        detect_pua
+        detect_structured
+        exclude
+        exclude_dir
+        exclude_pua
+        file_list
+        follow_dir_symlinks
+        follow_file_symlinks
+        heuristic_scan_precedence
+        include
+        include_dir
+        include_pua
+        log
+        max_dir_recursion
+        max_files
+        max_filesize
+        max_recursion
+        max_scansize
+        move
+        official_db_only
+        phishing_cloak
+        phishing_scan_urls
+        phishing_sigs
+        phishing_ssl
+        remove
+        scan_archive
+        scan_elf
+        scan_html
+        scan_mail
+        scan_ole2
+        scan_pdf
+        scan_pe
+        structured_cc_count
+        structured_ssn_count
+        structured_ssn_format
+        tempdir
+      )
+
+      def argify (key, value=nil)
+        "--#{key.gsub('_', '-')}" + (value ? "=#{value}" : '')
+      end
+
+      def popen_args (opts={})
+        args = [::ClamScan.configuration.client_location]
+
+        if opts[:custom_args]
+          args += opts[:custom_args]
+        else
+          opts = ::ClamScan.configuration.default_scan_options.merge(opts)
+
+          opts.each do |key, value|
+            key_string = key.to_s
+
+            if BOOLEAN_ARGS.include? key_string
+              args << argify(key_string) if value
+            elsif VALUE_ARGS.include? key_string
+              args << argify(key_string, value) if value
+            elsif IGNORE_ARGS.include? key_string
+              # do nothing
+            else
+              raise RequestError, "Invalid option: #{key}"
+            end
+          end
+
+          args << opts[:location] if opts[:location]
+          args << '-' if opts[:stream]
+        end
+
+        args
+      end
+    end
+  end
+end

data/lib/clam_scan/response.rb

@@ -0,0 +1,44 @@
+module ClamScan
+  class Response
+    attr_accessor :output
+    attr_accessor :process_status
+
+    def initialize (process_status, output)
+      @output = output
+      @process_status = process_status
+    end
+
+    def body
+      @output
+    end
+
+    def error?
+      status == :error
+    end
+
+    def safe?
+      status == :safe
+    end
+
+    def status
+      case @process_status.exitstatus
+        when 0
+          :safe
+        when 1
+          :virus
+        when 2
+          :error
+        else
+          :unknown
+      end
+    end
+
+    def unknown?
+      status == :unknown
+    end
+
+    def virus?
+      status == :virus
+    end
+  end
+end

data/lib/clam_scan/version.rb

@@ -0,0 +1,3 @@
+module ClamScan
+  VERSION = "0.0.1"
+end

data/spec/clam_scan_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe ClamScan do
+  context :error do
+    it 'raises ClamScan::RequestError if failure to make system call to client_location' do
+      ClamScan.configure do |config|
+        config.client_location = '/asdf/zxcv'
+      end
+        expect{scan_eicar}.to raise_error(ClamScan::RequestError)
+    end
+
+    it 'raises ClamScan::RequestError when scanning a non-existant path and raise_unless_safe is true' do
+      ClamScan.configure do |config|
+        config.raise_unless_safe = true
+      end
+      expect{scan(location: '/asdf/zxcv')}.to raise_error(ClamScan::ResponseError)
+    end
+
+    it 'raises ClamScan::RequestError if an unrecognized option is passed' do
+      expect{ClamScan::Client.scan(loaction: eicar_path)}.to raise_error(ClamScan::RequestError)
+    end
+
+    it 'raises ClamScan::VirusDetected if virus is detected when raise_unless_safe is true' do
+      ClamScan.configure do |config|
+        config.raise_unless_safe = true
+      end
+      expect{scan_eicar}.to raise_error(ClamScan::VirusDetected)
+    end
+
+    it 'returns true for error? when scanning a non-existant path' do
+      expect(scan(location: '/asdf/zxcv').error?).to be_truthy
+    end
+
+    it 'has status of :error when scanning a non-existant path' do
+      expect(scan(location: '/asdf/zxcv').status).to eq(:error)
+    end
+  end
+
+  context :safe do
+    before :each do
+      @response = scan_safe
+    end
+
+    it 'returns false for error?' do
+      expect(@response.error?).to be_falsey
+    end
+
+    it 'returns true for safe?' do
+      expect(@response.safe?).to be_truthy
+    end
+
+    it 'returns false for unknown?' do
+      expect(@response.unknown?).to be_falsey
+    end
+
+    it 'returns false for virus?' do
+      expect(@response.virus?).to be_falsey
+    end
+
+    it 'has status of :safe' do
+      expect(@response.status).to eq(:safe)
+    end
+  end
+
+  context :streaming do
+    it 'detects safety from streamed data' do
+      expect(scan(stream: File.read(safe_path)).safe?).to be_truthy
+    end
+
+    it 'detects a virus from streamed data' do
+      expect(scan(stream: File.read(eicar_path)).virus?).to be_truthy
+    end
+  end
+
+  context :virus do
+    before :each do
+      @response = scan_eicar
+    end
+
+    it 'returns false for error?' do
+      expect(@response.error?).to be_falsey
+    end
+
+    it 'returns false for safe?' do
+      expect(@response.safe?).to be_falsey
+    end
+
+    it 'returns false for unknown?' do
+      expect(@response.unknown?).to be_falsey
+    end
+
+    it 'returns true for virus?' do
+      expect(@response.virus?).to be_truthy
+    end
+
+    it 'has status of :virus' do
+      expect(@response.status).to eq(:virus)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,120 @@
+# 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
+
+# end intro stuff
+
+require 'clam_scan'
+
+Dir[File.expand_path(File.join('..', 'support', '**', '*.rb'), __FILE__)].each { |f| require f }
+
+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.
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+
+  # end default init stuff
+
+  config.before(:suite) do
+    # make data dir if it doesn't exist
+    unless File.directory? data_path
+      require 'fileutils'
+      FileUtils.mkdir_p data_path
+    end
+
+    # get eicar sample file if we don't have it
+    unless File.exist? eicar_path
+      require 'net/http'
+      Net::HTTP.start('www.eicar.org') do |http|
+        resp = http.get('/download/eicar.com')
+        File.open(eicar_path, 'wb') do |file|
+          file.write(resp.body)
+        end
+      end
+    end
+
+    # make a safe file if we don't have it
+    unless File.exist? safe_path
+      File.open(safe_path, 'w') do |file|
+        file.write 'bar'
+      end
+    end
+  end
+
+  config.before(:each) do
+    # reset to sane defaults, maybe override from ENV
+    ClamScan.configure do |clam_config|
+      clam_config.reset!
+      clam_config.client_location = 'clamdscan'
+    end
+  end
+end

data/spec/support/data.rb

@@ -0,0 +1,11 @@
+def data_path
+  File.expand_path(File.join('..', '..', 'data'), __FILE__)
+end
+
+def eicar_path
+  File.join(data_path, 'eicar.com')
+end
+
+def safe_path
+  File.join(data_path, 'foo.txt')
+end

data/spec/support/scan.rb

@@ -0,0 +1,11 @@
+def scan (opts={})
+  ClamScan::Client.scan(opts)
+end
+
+def scan_eicar
+  scan(location: eicar_path)
+end
+
+def scan_safe
+  scan(location: safe_path)
+end

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: clam_scan
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- John Schroeder
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby wrapper for ClamAV's clamscan/clamdscan.
+email:
+- jschroeder@multiadsolutions.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- clam_scan.gemspec
+- lib/clam_scan.rb
+- lib/clam_scan/client.rb
+- lib/clam_scan/configuration.rb
+- lib/clam_scan/exceptions.rb
+- lib/clam_scan/request.rb
+- lib/clam_scan/response.rb
+- lib/clam_scan/version.rb
+- spec/clam_scan_spec.rb
+- spec/spec_helper.rb
+- spec/support/data.rb
+- spec/support/scan.rb
+homepage: https://github.com/jschroeder9000/clam_scan
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Ruby wrapper for ClamAV's clamscan/clamdscan.
+test_files:
+- spec/clam_scan_spec.rb
+- spec/spec_helper.rb
+- spec/support/data.rb
+- spec/support/scan.rb