cleanup 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3cd8b930e88f0c816fb4d6141a8747ec1d8145a9
+  data.tar.gz: 81dc629fa598e47bece6324768a1d5af0fed6b31
+SHA512:
+  metadata.gz: e4ede30c782945b85656440f96ca20bf5da6b5bedf3c23e5e7aa52f9e062814967eee419f2e9dcafaee9af4936a694d123f9524c7434aae26eb45f7e6c4590fe
+  data.tar.gz: 993484c48f32e0ecbaed7dedc324898ff24eac062d9eb912e9ba1bcf30963c53939f38537daddf7a3eb24a1248f8e15753d3eb42b1a89412c14b46a2379d65e6

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/config/rules.rb
+rubocop.yml

data/Gemfile

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

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 nickolai-sm
+
+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,49 @@
+# CleanUp
+
+Move and copy files and directories to appointed directories according defined conditions.
+
+## Usage
+
+Define your rules in `config/rules.rb` file.
+
+Example:
+
+```` ruby
+
+CleanUp.define do
+  move do
+    source '~/Downloads'
+    target '~/'
+
+    file do
+      extension 'mp3'
+      dir 'Music'
+    end
+
+    file do
+      extension 'avi', 'mov'
+      dir 'Movies'
+    end
+
+    file do
+      pattern 'report_'
+      dir 'Documents/Reports'
+    end
+
+    file do
+      extension 'torrent'
+      dir '.Trash'
+    end
+  end
+end
+
+````
+
+and run
+
+    $ bin/cleanup
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nickolai-sm/clean_up.
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler/gem_tasks'
+task default: :spec

data/bin/cleanup

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'bundler'
+Bundler.require
+
+load 'config/rules.rb'
+
+CleanUp.check

data/bin/console

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'clean_up'
+
+# 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

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/clean_up.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'clean_up/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'cleanup'
+  spec.version       = CleanUp::VERSION
+  spec.authors       = ['Nickolai Smirnov']
+  spec.email         = ['sm-nickolai@gmail.com']
+
+  spec.license       = 'MIT'
+  spec.summary       = 'Files and Directories clean up tool'
+  spec.homepage      = 'https://github.com/nickolai-sm/clean_up'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'bin'
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'pry', '~> 0.10.3'
+end

data/lib/clean_up.rb

@@ -0,0 +1,39 @@
+require 'clean_up/version'
+
+require 'clean_up/rules'
+require 'clean_up/conditions'
+require 'clean_up/folder'
+require 'clean_up/folders_rules'
+require 'clean_up/option_values'
+
+module CleanUp
+  IGNORED_ENTRIES = %w(. .. .DS_Store .localized).freeze
+
+  class << self
+    def define(&block)
+      @folders_rules = FoldersRules.collect(&block)
+    end
+
+    def folders_rules
+      @folders_rules || []
+    end
+
+    def check
+      folders_rules.each do |folder_rules|
+        dir_entries(folder_rules.source).each do |entry|
+          if File.directory?(entry)
+            folder_rules.process_directory(entry)
+          else
+            folder_rules.process_file(entry)
+          end
+        end
+      end
+    end
+
+    def dir_entries(folder)
+      (Dir.entries(folder) - IGNORED_ENTRIES).map do |entry|
+        File.expand_path(entry, folder)
+      end
+    end
+  end
+end

data/lib/clean_up/conditions.rb

@@ -0,0 +1,42 @@
+require 'clean_up/conditions/extension'
+require 'clean_up/conditions/contains'
+require 'clean_up/conditions/pattern'
+require 'clean_up/conditions/name'
+require 'clean_up/conditions/size'
+
+module CleanUp
+  module Conditions
+    # TODO: created_at condition
+    TYPES_CONDITIONS = {
+      file: %w(name extension pattern size),
+      directory: %w(contains name pattern)
+    }.freeze
+
+    class << self
+      def build_for_file(options)
+        build_by_type(:file, options)
+      end
+
+      def build_for_directory(options)
+        build_by_type(:directory, options)
+      end
+
+      private
+
+      def build_by_type(conditions_type, options)
+        options.keys.each_with_object([]) do |type, memo|
+          memo << build(type, *options.delete(type)) if TYPES_CONDITIONS[conditions_type].include?(type)
+        end
+      end
+
+      def build(type, *args)
+        case type
+        when 'pattern', 'size', 'name', 'extension'
+          Conditions.const_get(type.capitalize).new(*args)
+        when 'contains'
+          Conditions::Contains.new(&args.first)
+        end
+      end
+    end
+  end
+end

data/lib/clean_up/conditions/contains.rb

@@ -0,0 +1,35 @@
+module CleanUp
+  module Conditions
+    class Contains
+      def initialize(&block)
+        @file_conditions = []
+        instance_eval(&block)
+      end
+
+      def at_least(number, &block)
+        number.times { instance_eval(&block) }
+      end
+
+      def file(&block)
+        @file_conditions << Conditions.build_for_file(OptionValues.parse(&block))
+      end
+
+      def match?(folder)
+        files = CleanUp.dir_entries(folder).reject { |entry| File.directory?(entry) }
+
+        match_file_conditions?(files)
+      end
+
+      private
+
+      def match_file_conditions?(files)
+        @file_conditions.all? do |conditions|
+          file = files.detect do |f|
+            conditions.all? { |c| c.match?(f) }
+          end
+          file && files.delete(file)
+        end
+      end
+    end
+  end
+end

data/lib/clean_up/conditions/extension.rb

@@ -0,0 +1,15 @@
+module CleanUp
+  module Conditions
+    class Extension
+      def initialize(*value)
+        @pattern = *value
+      end
+
+      def match?(file)
+        extension = File.extname(file)[1..-1]
+
+        extension && @pattern.include?(extension)
+      end
+    end
+  end
+end

data/lib/clean_up/conditions/name.rb

@@ -0,0 +1,15 @@
+module CleanUp
+  module Conditions
+    class Name
+      def initialize(value)
+        @pattern = Array(value)
+      end
+
+      def match?(file)
+        @pattern.any? do |filename|
+          filename == File.basename(file, '.*')
+        end
+      end
+    end
+  end
+end

data/lib/clean_up/conditions/pattern.rb

@@ -0,0 +1,13 @@
+module CleanUp
+  module Conditions
+    class Pattern
+      def initialize(*value)
+        @pattern = value.map { |regexp| Regexp.new(regexp) }
+      end
+
+      def match?(file)
+        @pattern.any? { |regexp| regexp.match(File.basename(file, '.*')) }
+      end
+    end
+  end
+end

data/lib/clean_up/conditions/size.rb

@@ -0,0 +1,20 @@
+module CleanUp
+  module Conditions
+    # TODO: size conditions format
+    class Size
+      def initialize(*value)
+        @pattern = parse(value.first)
+      end
+
+      def match?(file)
+        @pattern.cover?(File.size(file))
+      end
+
+      protected
+
+      def parse(value)
+        Range.new(value[:min] || 0, value[:max] || Float::INFINITY)
+      end
+    end
+  end
+end

data/lib/clean_up/folder.rb

@@ -0,0 +1,66 @@
+module CleanUp
+  class Folder
+    attr_reader :options, :strategy, :files_rules, :directory_rules
+
+    def self.collect(strategy, &block)
+      new(strategy, &block)
+    end
+
+    def initialize(strategy, &block)
+      @strategy, @files_rules, @directory_rules = strategy, [], []
+      instance_eval(&block)
+    end
+
+    # Implement setter & getter for source folder.
+    def source(folder = nil)
+      @source ||= File.expand_path(folder)
+    end
+
+    # Implement setter & getter for target folder.
+    def target(folder = nil)
+      @target ||= File.expand_path(folder)
+    end
+
+    def file(&block)
+      with_options(block) do
+        @files_rules << file_rule_class.new(options)
+      end
+    end
+
+    def directory(&block)
+      with_options(block) do
+        @directory_rules << directory_rule_class.new(options)
+      end
+    end
+
+    def process_directory(directory)
+      directory_rules.detect do |rule|
+        rule.call(directory, target)
+      end
+    end
+
+    def process_file(file)
+      files_rules.detect do |rule|
+        rule.call(file, target)
+      end
+    end
+
+    private
+
+    def file_rule_class
+      strategy == :move ? Rules::MoveFile : Rules::CopyFile
+    end
+
+    def directory_rule_class
+      strategy == :move ? Rules::MoveDirectory : Rules::CopyDirectory
+    end
+
+    def with_options(options_block)
+      @options = OptionValues.parse(&options_block)
+
+      yield if block_given?
+    ensure
+      @options = nil
+    end
+  end
+end

data/lib/clean_up/folders_rules.rb

@@ -0,0 +1,22 @@
+module CleanUp
+  class FoldersRules
+    attr_reader :rules_set
+
+    def self.collect(&block)
+      new(&block).rules_set
+    end
+
+    def initialize(&block)
+      @rules_set = []
+      instance_eval(&block)
+    end
+
+    def move(&block)
+      @rules_set << CleanUp::Folder.collect(:move, &block)
+    end
+
+    def copy(&block)
+      @rules_set << CleanUp::Folder.collect(:copy, &block)
+    end
+  end
+end

data/lib/clean_up/option_values.rb

@@ -0,0 +1,29 @@
+module CleanUp
+  class OptionValues
+    SUPPORTED_OPTIONS = %w(dir extension pattern files_amount size).freeze
+    SUPPORTED_BLOCK_OPTIONS = %w(contains).freeze
+
+    attr_reader :options
+
+    def self.parse(&block)
+      new(&block).options
+    end
+
+    def initialize(&block)
+      @options = {}
+      instance_eval(&block)
+    end
+
+    def respond_to_missing?(method, *)
+      SUPPORTED_OPTIONS.include?(method.to_s) || super
+    end
+
+    def method_missing(method, *args, &block)
+      if SUPPORTED_BLOCK_OPTIONS.include?(method.to_s)
+        @options[method.to_s] = block
+      elsif SUPPORTED_OPTIONS.include?(method.to_s)
+        @options[method.to_s] = args
+      end
+    end
+  end
+end

data/lib/clean_up/rules.rb

@@ -0,0 +1,10 @@
+require 'clean_up/rules/base'
+require 'clean_up/rules/copy_directory'
+require 'clean_up/rules/copy_file'
+require 'clean_up/rules/move_file'
+require 'clean_up/rules/move_directory'
+
+module CleanUp
+  module Rules
+  end
+end

data/lib/clean_up/rules/base.rb

@@ -0,0 +1,30 @@
+module CleanUp
+  module Rules
+    class Base
+      attr_reader :options
+
+      def initialize(options)
+        @conditions = build_conditions(options)
+        @options = options
+      end
+
+      def call(_entry, _source, _target)
+        raise NotImplementedError
+      end
+
+      private
+
+      def build_conditions(_options)
+        raise NotImplementedError
+      end
+
+      def match_conditions?(entry)
+        @conditions.all? { |c| c.match?(entry) }
+      end
+
+      def full_target_folder(target)
+        File.join(File.expand_path(target), options['dir'])
+      end
+    end
+  end
+end

data/lib/clean_up/rules/copy_directory.rb

@@ -0,0 +1,15 @@
+module CleanUp
+  module Rules
+    class CopyDirectory < Base
+      def build_conditions(options)
+        Conditions.build_for_directory(options)
+      end
+
+      def call(entry, target)
+        if match_conditions?(entry)
+          FileUtils.cp_r(entry, full_target_folder(target), verbose: true)
+        end
+      end
+    end
+  end
+end

data/lib/clean_up/rules/copy_file.rb

@@ -0,0 +1,15 @@
+module CleanUp
+  module Rules
+    class CopyFile < Base
+      def build_conditions(options)
+        Conditions.build_for_file(options)
+      end
+
+      def call(entry, target)
+        if match_conditions?(entry)
+          FileUtils.cp(entry, full_target_folder(target), verbose: true)
+        end
+      end
+    end
+  end
+end

data/lib/clean_up/rules/move_directory.rb

@@ -0,0 +1,15 @@
+module CleanUp
+  module Rules
+    class MoveDirectory < Base
+      def build_conditions(options)
+        Conditions.build_for_directory(options)
+      end
+
+      def call(entry, target)
+        if match_conditions?(entry)
+          FileUtils.mv(entry, full_target_folder(target), verbose: true)
+        end
+      end
+    end
+  end
+end

data/lib/clean_up/rules/move_file.rb

@@ -0,0 +1,15 @@
+module CleanUp
+  module Rules
+    class MoveFile < Base
+      def build_conditions(options)
+        Conditions.build_for_file(options)
+      end
+
+      def call(entry, target)
+        if match_conditions?(entry)
+          FileUtils.mv(entry, full_target_folder(target), verbose: true)
+        end
+      end
+    end
+  end
+end

data/lib/clean_up/version.rb

@@ -0,0 +1,3 @@
+module CleanUp
+  VERSION = '0.1.0'.freeze
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: cleanup
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Nickolai Smirnov
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-06-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !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: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.3
+description: 
+email:
+- sm-nickolai@gmail.com
+executables:
+- cleanup
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- bin/cleanup
+- bin/console
+- bin/setup
+- clean_up.gemspec
+- lib/clean_up.rb
+- lib/clean_up/conditions.rb
+- lib/clean_up/conditions/contains.rb
+- lib/clean_up/conditions/extension.rb
+- lib/clean_up/conditions/name.rb
+- lib/clean_up/conditions/pattern.rb
+- lib/clean_up/conditions/size.rb
+- lib/clean_up/folder.rb
+- lib/clean_up/folders_rules.rb
+- lib/clean_up/option_values.rb
+- lib/clean_up/rules.rb
+- lib/clean_up/rules/base.rb
+- lib/clean_up/rules/copy_directory.rb
+- lib/clean_up/rules/copy_file.rb
+- lib/clean_up/rules/move_directory.rb
+- lib/clean_up/rules/move_file.rb
+- lib/clean_up/version.rb
+homepage: https://github.com/nickolai-sm/clean_up
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Files and Directories clean up tool
+test_files: []