filter_rename 1.0.0

data/lib/filter_rename/cli.rb

@@ -0,0 +1,145 @@
+require 'optparse'
+require 'ostruct'
+require 'filter_rename'
+require 'filter_rename/version'
+
+module FilterRename
+
+  class OptParseMain
+
+    def self.parse(args)
+      options = OpenStruct.new
+      options.filters = []
+      options.files = []
+      options.global = {}
+      options.operation = :preview
+      options.show_macro = ''
+
+      opt_parser = OptionParser.new do |opt|
+        opt.banner = 'Usage: filter_rename [-g OPTION1[,OPTION2...]] [FILTER1[,FILTER2...]] <file1>[ <file2>...] [OPERATION]'
+
+        opt.separator ''
+        opt.separator 'Operations:'
+
+        opt.on('--apply', 'Apply the changes.') do |c|
+          options.operation = :apply
+        end
+
+        opt.on('-d', '--dry-run', 'Don\'t apply any change but check for errors') do |c|
+          options.operation = :dry_run
+        end
+
+        opt.on('-p', '--preview', 'Preview the filter chain applied [DEFAULT]') do |c|
+          options.operation = :preview
+        end
+
+        opt.on('-t', '--targets', 'List of targets for each file') do |c|
+          options.operation = :targets
+        end
+
+        opt.on('-g', '--globals', 'List of global variables') do |c|
+          options.operation = :globals
+        end
+
+        opt.on('-c', '--configs', 'List of filter variables') do |c|
+          options.operation = :configs
+        end
+
+        opt.on('-w', '--words', 'List of groups of words available for translation') do |c|
+          options.operation = :words
+        end
+
+        opt.on('-m', '--macros', 'List of available macros') do |c|
+          options.operation = :macros
+        end
+
+        opt.on('-s' , '--show-macro <MACRO>', 'List of commands used by MACRO') do |c|
+          options.operation = :show_macro
+          options.show_macro = c
+        end
+
+        opt.separator ''
+        opt.separator 'Options:'
+
+        opt.on('--global [OPTION:VALUE[,OPTION:VALUE]]', 'Override global options with: "option:value"') do |v|
+          v.parametrize.each do |i|
+            options.global.store(i.split(':')[0].to_sym, i.split(':')[1])
+          end
+        end
+
+        opt.separator ''
+        opt.separator 'Filters:'
+
+        opt.on('--macro MACRO1,[MACRO2,...]', Array, 'Apply the MACRO' ) do |v|
+          options.filters << MacroConfig.create(v) # { FilterRename::MacroConfig => v }
+#           options.filters.merge MacroConfig.expand_macros(v)
+        end
+
+        Filters.constants.sort.each do |c|
+
+          switch = c.to_s.to_switch
+          klass = Object.const_get("FilterRename::Filters::#{c}")
+
+          if klass.params.nil?
+            opt.on("--#{switch}", klass.hint) do |v|
+              options.filters << { klass => v }
+            end
+          elsif klass.params == Boolean
+            opt.on("--[no-]#{switch}", klass.hint) do |v|
+              options.filters << { klass => v }
+            end
+          else
+            opt.on("--#{switch} #{klass.params}", "#{klass.hint}") do |v|
+              options.filters << { klass => v.parametrize }
+            end
+          end
+        end
+
+        opt.separator ''
+        opt.separator 'Other:'
+
+        opt.on_tail('-h', '--help', 'Show this message') do
+          puts opt
+          exit
+        end
+        opt.on_tail('-v', '--version', 'Show version') do
+          puts VERSION
+          exit
+        end
+      end
+
+      if (!STDIN.tty? && !STDIN.closed?) || !ARGV.empty?
+
+        opt_parser.parse!(ARGV)
+
+        (ARGV.empty? ? ARGF : ARGV).each do |f|
+          f = File.expand_path(f.strip)
+
+          if File.exists?(f)
+            options.files << f
+          else
+            raise FileNotFound, f
+          end
+        end if [:apply, :preview, :dry_run, :targets].include? options.operation
+      else
+        puts opt_parser; exit
+      end
+
+      options
+    end
+
+  end
+
+  class CLI
+    def self.start
+      begin
+        options = OptParseMain.parse(ARGV)
+        Builder.new(options).send(options.operation)
+      rescue => e
+        Messages.error e
+        exit 1
+      end
+    end
+  end
+
+end

data/lib/filter_rename/config.rb

@@ -0,0 +1,120 @@
+require 'yaml'
+
+module FilterRename
+
+  class MacroConfig
+
+    def initialize(cfg)
+      cfg.each do |key, value|
+        instance_variable_set('@' + key.to_s, value)
+      end
+    end
+
+    def get_macro(name)
+      macro = instance_variable_get('@' + name.to_s.gsub(/[^a-zA-Z0-9,-_]/,''))
+      raise InvalidMacro, name if macro.nil? || macro.to_s.empty?
+      macro
+    end
+
+    def get_macros
+      instance_variables.map { |m| m.to_s.gsub(/^@/, '') }
+    end
+
+    def self.create(name)
+      { FilterRename::MacroConfig => name }
+    end
+
+  end
+
+
+  class WordsConfig
+
+    def initialize(cfg)
+      cfg.each do |key, value|
+        instance_variable_set('@' + key.to_s, value)
+      end
+    end
+
+    def get_words(name, section, idx = nil)
+      w = instance_variable_get('@' + name.to_s)
+      raise InvalidWordsGroup, name if w.nil? || name.to_s.empty?
+      raise InvalidWordsSection.new(name, section) unless w.has_key? section.to_sym
+
+      if idx.nil?
+        return w[section]
+      elsif w[section].class == Array
+        raise InvalidWordsIndex.new(name, section, idx) unless idx < w[section].length
+        return w[section][idx].to_s
+      else
+        return w[section].to_s
+      end
+    end
+  end
+
+
+  class GlobalConfig
+    attr_reader :date_format, :hash_type, :counter_length, :counter_start, :targets,
+                :pdf_metadata, :image_metadata, :mp3_metadata
+
+    def initialize(cfg)
+      @date_format = cfg[:date_format] || '%Y-%m-%d'
+      @hash_type =  cfg[:hash_type].to_sym || :none
+      @counter_length = cfg[:counter_length] || 4
+      @counter_start = cfg[:counter_start] || 0
+      @targets = cfg[:targets].to_sym || :short
+      @pdf_metadata = cfg[:pdf_metadata].nil? ? true : cfg[:pdf_metadata].to_boolean
+      @image_metadata = cfg[:image_metadata].nil? ? true : cfg[:image_metadata].to_boolean
+      @mp3_metadata = cfg[:mp3_metadata].nil? ? true : cfg[:mp3_metadata].to_boolean
+    end
+  end
+
+
+  class FilterConfig
+    attr_accessor  :word_separator, :target, :ignore_case, :lang, :grep, :grep_on, :grep_exclude, :grep_target
+
+    def initialize(cfg)
+      @word_separator = cfg[:word_separator] || ' '
+      @target = cfg[:target].to_sym || :name
+      @ignore_case = cfg[:ignore_case].nil? ? true : cfg[:ignore_case].to_boolean
+      @lang = (cfg[:lang] || :en).to_sym
+      @macro = cfg[:macro] || {}
+      @grep = cfg[:grep] || '.*'
+      @grep_on = cfg[:grep_on].to_sym || :source
+      @grep_exclude = cfg[:grep_exclude].to_boolean || false
+      @grep_target = cfg[:grep_target].to_sym || :full_filename
+    end
+  end
+
+
+  class Config
+    attr_reader :filter, :global, :macro, :words
+
+    def initialize(global = {})
+      cfg = {filter: {}, global: {}, macro: {}, words: {}}
+
+      load_file(File.expand_path(File.join(File.dirname(__FILE__), '..', 'filter_rename.yaml')), cfg)
+      load_file(File.join(ENV['HOME'], '.filter_rename.yaml'), cfg)
+      load_file(File.join(ENV['HOME'], '.filter_rename', 'config.yaml'), cfg)
+
+      @filter = FilterConfig.new(cfg[:filter])
+      @global = GlobalConfig.new(cfg[:global].merge(global))
+      @macro  = MacroConfig.new(cfg[:macro].sort)
+      @words  = WordsConfig.new(cfg[:words].sort)
+    end
+
+    private
+
+    def load_file(filename, cfg = nil)
+
+      if File.exists?(filename)
+        @filename = filename
+        yaml = YAML.load_file(filename)
+        [:filter, :global, :macro, :words].each do |s|
+          cfg[s].merge!(yaml[s]) if yaml.has_key?(s)
+        end
+      end
+
+    end
+  end
+
+end

data/lib/filter_rename/filename.rb

@@ -0,0 +1,142 @@
+module FilterRename
+
+  class Filename
+
+    def self.has_writable_tags
+      false
+    end
+
+    def initialize(fname, cfg)
+      @@count ||= cfg.counter_start
+      @@count += 1
+      @cfg = cfg
+
+      load_filename_data(fname)
+    end
+
+    def ==(dest)
+      full_filename == dest.full_filename
+    end
+
+    def !=(dest)
+      full_filename != dest.full_filename
+    end
+
+    def filename
+      @name + @ext
+    end
+
+    def full_path
+      if @folder.to_s.empty?
+        @path
+      else
+        File.join [@path, @folder]
+      end
+    end
+
+    def full_filename
+      File.join [full_path, filename]
+    end
+
+    def set_string(target, str)
+      instance_variable_set ('@' + target.to_s), str
+    end
+
+    def get_string(target)
+      instance_variable_get '@' + target.to_s
+    end
+
+    def has_target?(target)
+      instance_variables.include?(('@' + target.to_s).to_sym)
+    end
+
+    def exists?
+      File.exists?(full_filename)
+    end
+
+    def rename!(dest)
+      old_data = {}
+
+      if full_filename != dest.full_filename
+        if full_path != dest.full_path
+          FileUtils.mkdir_p(dest.full_path) unless Dir.exists? dest.full_path
+        end
+        unless File.exists?(dest.full_filename)
+          FileUtils.mv full_filename, dest.full_filename
+          old_data = { full_filename: full_filename, full_path: full_path, filename: filename }
+          load_filename_data(dest.full_filename)
+        end
+      end
+
+      old_data
+    end
+
+    def calculate_hash(hash_type = :md5)
+      raise UnknownHashCode, hash_type unless [:sha1, :sha2, :md5].include?(hash_type.to_sym)
+      klass = Object.const_get("Digest::#{hash_type.to_s.upcase}")
+      klass.file(full_filename).to_s
+    end
+
+    def diff(dest)
+      Differ.diff_by_word(dest.full_filename, full_filename).to_s
+    end
+
+    def pretty_size(size)
+      i = 0; size = size.to_i
+      while ((size >= 1024) && (i < FILE_SIZES.length))
+        size = size.to_f / 1024
+        i += 1
+      end
+      size.round(2).to_s.gsub(/.0$/, '') + FILE_SIZES[i]
+    end
+
+    def targets
+      res = {:readonly => [], :writable => []}
+      instance_variables.each do |v|
+        next if v == :@cfg
+        res[instance_variable_get(v).writable? ? :writable : :readonly] << v
+      end
+
+      res
+    end
+
+    def values
+      res = {}
+      instance_variables.each do |v|
+        next if v == :@cfg
+        res[v.to_s.delete('@').to_sym] = instance_variable_get(v)
+      end
+      res
+    end
+
+    protected
+
+    def metatag_to_var!(key, value, readonly = true)
+      var_name = key.downcase.gsub(/[^a-z]/, '_').gsub(/_+/, '_')
+      instance_variable_set('@' + var_name, value.to_s.gsub('/', '_'))
+      instance_variable_get('@' + var_name).readonly! if readonly
+    end
+
+    private
+
+    def load_filename_data(fname)
+      @ext = File.extname(fname)
+      @name = File.basename(fname, @ext)
+      @path= File.dirname(File.expand_path(fname))
+      @folder = File.basename(@path)
+      @path = File.dirname(@path)
+
+      # read only stuff
+      @count = @@count.to_s.rjust(@cfg.counter_length.to_i, '0')
+      @ctime = File.ctime(fname).strftime(@cfg.date_format)
+      @mtime = File.mtime(fname).strftime(@cfg.date_format)
+      @size = File.size(fname).to_s
+      @pretty_size = pretty_size(@size)
+
+      [@count, @ctime, @mtime, @size, @pretty_size].map(&:readonly!)
+
+      metatag_to_var!('hash', calculate_hash(@cfg.hash_type), true) unless @cfg.hash_type == :none
+    end
+  end
+
+end

data/lib/filter_rename/filename_factory.rb

@@ -0,0 +1,36 @@
+require 'mimemagic'
+require 'fileutils'
+require 'differ'
+require 'digest'
+
+module FilterRename
+
+  class FilenameFactory
+
+    def self.create(fname, cfg)
+
+      return Filename.new(fname, cfg) if File.directory?(fname)
+
+      magic = MimeMagic.by_magic(File.open(fname))
+      mediatype, type = magic.nil? ? ['unknown', 'unknown'] : [magic.mediatype, magic.type]
+
+      if (IO.read(fname, 3) == 'ID3') && (mediatype == 'audio')
+        require 'filter_rename/filetype/mp3_filename'
+        res = Mp3Filename.new(fname, cfg)
+      elsif ((mediatype == 'image') && (! ['vnd.djvu+multipage'].include? type.split('/')[1]))
+        # supported types: jpeg, png
+        require 'filter_rename/filetype/image_filename'
+        res = ImageFilename.new(fname, cfg)
+      elsif (type == 'application/pdf')
+        require 'filter_rename/filetype/pdf_filename'
+        res = PdfFilename.new(fname, cfg)
+      else
+        res = Filename.new(fname, cfg)
+      end
+
+      res
+    end
+
+  end
+
+end

data/lib/filter_rename/filetype/image_filename.rb

@@ -0,0 +1,28 @@
+require 'fastimage'
+require 'exiv2'
+
+module FilterRename
+
+  class ImageFilename < Filename
+
+    def initialize(fname, cfg)
+      super fname, cfg
+
+      image = FastImage.new(fname)
+      @width = image.size[0].to_s
+      @height = image.size[1].to_s
+
+      [@width, @height].map(&:readonly!)
+
+      if cfg.image_metadata
+        image = Exiv2::ImageFactory.open(fname)
+        image.read_metadata
+
+        image.exif_data.each do |key, value|
+          metadata_to_var!(key, value, true)
+        end unless image.exif_data.nil?
+      end
+    end
+  end
+
+end