file_scanner 1.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6fb33515de67d99ac734334fb573a11424861444
+  data.tar.gz: 7e6742c59f1f0939114ee6ba81d49be590a74447
+SHA512:
+  metadata.gz: 639bfe4e4078486bd18fb49762154e8465766187b5be9038e61494c10fa9ff7273f68d1c48abffd89884d81918d0590ebebf43c1c1921d8e59ce5369e6cf3801
+  data.tar.gz: c7256af0baef400aaed7b302728cb5f1ccd2df9cb203a02a02a4491bb7d14ca4a4ecd936cbb1f89ccaa77f832b5cf6364c7c4658d4249212e2dc814691d03883

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,8 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.1.2
+  - 2.2.2
+  - 2.3.0
+  - 2.4.0
+before_install: gem install bundler -v 1.15.2

data/Gemfile

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

data/README.md

@@ -0,0 +1,112 @@
+## Table of Contents
+
+* [Scope](#scope)
+* [Motivation](#motivation)
+* [Installation](#installation)
+* [Usage](#usage)
+  * [Loader](#loader)
+  * [Filters](#filters)
+  * [Policies](#policies)
+  * [Worker](#worker)
+
+## Scope
+This gem is aimed to collect a set of file paths starting by a wildcard rule, filter them by default/custom filters (access time, size range) and apply a set of custom policies to them.
+
+## Motivation
+This gem is helpful to purge obsolete files or to promote relevant ones, by calling external services (CDN APIs) and/or local file system actions (copy, move, delete, etc).
+
+## Installation
+Add this line to your application's Gemfile:
+```ruby
+gem "file_scanner"
+```
+
+And then execute:
+```shell
+bundle
+```
+
+Or install it yourself as:
+```shell
+gem install file_scanner
+```
+
+## Usage
+
+### Loader
+The first step is to create a `Loader` instance by specifying the path where the files need to be scanned with optional extensions list:
+```ruby
+require "file_scanner"
+
+loader = FileScanner::Loader.new(path: ENV["HOME"], extensions: %w[html txt])
+```
+
+### Filters
+The second step is to provide the filters list to select files for which the `call` method is truthy.  
+
+#### Default
+You can rely on existing filters that select files by:
+* checking if file is older than *30 days* 
+* checking if file size is *smaller than 100 bytes*
+
+You can configure default behaviour by passing different arguments:
+```ruby
+accessed_a_week_ago = FileScanner::Filters::LastAccess.new(Time.now-7*24*3600)
+one_to_two_mega = FileScanner::Filters::SizeRange.new(min: 1024**2, max: 2*1024**2)
+
+filters = []
+filters << accessed_a_week_ago
+filters << one_to_two_mega
+```
+
+#### Custom
+It is convenient to create custom filters by just relying on `Proc` instances that satisfy the `callable` protocol:
+```ruby
+filters << ->(file) { File.directory?(file) }
+```
+
+### Policies
+The third step is creating custom policies objects (no default exist) to be applied to the list of filtered paths.  
+Again, it suffice the policy responds to the `call` method and accept an array of paths as an argument:
+```ruby
+require "fileutils"
+
+remove_from_disk = ->(paths) do
+  FileUtils.rm_rf(paths)
+end
+
+policies = []
+policies << remove_from_disk
+```
+
+### Worker
+Now that you have all of the collaborators in place, you can create the `Worker` instance:
+```ruby
+worker = FileScanner::Worker.new(loader: loader, filters: filters, policies: policies)
+worker.call # apply all the specified policies to the filtered file paths
+```
+
+#### Slice of files
+In case you are going to scan a large number of files, is better to work in batches.  
+This is exactly why the `Worker` class accept a `slice` attribute to distribute the work and avoid saturating the resources used by the specified policies:
+```ruby
+worker = FileScanner::Worker.new(loader: loader, filter: filter, policies: policies, slice: 1000)
+worker.call # call policies by slice of 1000 files
+```
+
+#### Policies by block
+In case you prefer to specify the policies as a block yielding the files slice, you can omit the `policies` argument at all:
+```ruby
+worker = FileScanner::Worker.new(loader: loader, filter: filter)
+worker.call do |slice|
+  ->(slice) { FileUtils.chmod_R(0700, slice) }.call
+end
+```
+
+#### Use a logger
+If you dare to trace what the worker is doing (including errors), you can specify a logger to the worker class:
+```ruby
+my_logger = Logger.new("my_file.log")
+worker = FileScanner::Worker.new(loader: loader, filter: filter, logger: my_logger)
+worker.call # will log worker actions to my_file.log
+```

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:spec) do |t|
+  t.libs << "spec"
+  t.libs << "lib"
+  t.test_files = FileList["spec/**/*_spec.rb"]
+end
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "file_scanner"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

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

data/file_scanner.gemspec

@@ -0,0 +1,20 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "file_scanner/version"
+
+Gem::Specification.new do |s|
+  s.name = "file_scanner"
+  s.version = FileScanner::VERSION
+  s.authors = ["costajob"]
+  s.email = ["costajob@gmail.com"]
+  s.summary = "A scanner routine that collect file paths basing on specified filters and apply to them a set of custom policies"
+  s.files = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(spec|test|s|features)/}) }
+  s.require_paths = ["lib"]
+  s.license = "MIT"
+  s.required_ruby_version = ">= 2.1.2"
+
+  s.add_development_dependency "bundler", "~> 1.15"
+  s.add_development_dependency "rake", "~> 10.0"
+  s.add_development_dependency "minitest", "~> 5.0"
+end

data/lib/file_scanner/filters.rb

@@ -0,0 +1,31 @@
+module FileScanner
+  module Filters
+    def self.defaults
+      constants.map do |name|
+        self.const_get(name).new
+      end
+    end
+
+    class LastAccess
+      DAY = 3600*24
+
+      def initialize(atime = Time.now-30*DAY)
+        @atime = atime
+      end
+
+      def call(file)
+        @atime >= File.atime(file)
+      end
+    end
+
+    class SizeRange
+      def initialize(min: 100, max: Float::INFINITY)
+        @range = min..max
+      end
+
+      def call(file)
+        @range === File.size(file)
+      end
+    end
+  end
+end

data/lib/file_scanner/loader.rb

@@ -0,0 +1,21 @@
+module FileScanner
+  class Loader
+    def initialize(path:, extensions: [])
+      @path = path
+      @extensions = extensions
+    end
+
+    def call
+      Dir.glob(files_path)
+    end
+
+    private def files_path
+      File.join(@path, "**", extensions_path)
+    end
+
+    private def extensions_path
+      return "*" if @extensions.empty?
+      "*.{#{@extensions.join(",")}}"
+    end
+  end
+end

data/lib/file_scanner/version.rb

@@ -0,0 +1,3 @@
+module FileScanner
+  VERSION = "1.0.3"
+end

data/lib/file_scanner/worker.rb

@@ -0,0 +1,42 @@
+require "logger"
+
+module FileScanner
+  class Worker
+    attr_reader :filters, :policies
+
+    def initialize(loader:, filters: Filters::defaults, policies: [], logger: Logger.new(nil), slice: nil)
+      @loader = loader
+      @filters = filters
+      @policies = policies
+      @slice = slice.to_i
+      @logger = logger
+    end
+
+    def call
+      slices.each do |slice|
+        yield(slice) if block_given? && policies.empty?
+        policies.each do |policy|
+          @logger.info { "applying \e[1m#{policy}\e[0m to \e[1m#{slice.size}\e[0m files" }
+          policy.call(slice)
+        end
+      end
+    rescue StandardError => e
+      @logger.error { e.message }
+      raise e
+    end
+
+    private def files
+      @files ||= Array(@loader.call).select do |f|
+        @filters.all? do |filter|
+          @logger.info { "applying \e[1m#{filter.class}\w[0m to \e[1m#{File.basename(f)}\e[0m" }
+          filter.call(f)
+        end
+      end
+    end
+
+    private def slices
+      return [files] if @slice.zero?
+      files.each_slice(@slice)
+    end
+  end
+end

data/lib/file_scanner.rb

@@ -0,0 +1,4 @@
+require "file_scanner/filters"
+require "file_scanner/loader"
+require "file_scanner/version"
+require "file_scanner/worker"

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: file_scanner
+version: !ruby/object:Gem::Version
+  version: 1.0.3
+platform: ruby
+authors:
+- costajob
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.15'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: 
+email:
+- costajob@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- file_scanner.gemspec
+- lib/file_scanner.rb
+- lib/file_scanner/filters.rb
+- lib/file_scanner/loader.rb
+- lib/file_scanner/version.rb
+- lib/file_scanner/worker.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: A scanner routine that collect file paths basing on specified filters and
+  apply to them a set of custom policies
+test_files: []