regren 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a26b9baec5b659d3278b45d2acc2caecbc8bda43
+  data.tar.gz: 64cd2f64e3de3f2713af1e5775353611a9ce2ecf
+SHA512:
+  metadata.gz: 18639dd14b1249adaa9cdb54c584f18e2afd1f2f722092211016626c9cf5e3b062cfc86f51d7e5c93467d43423c4c86eb6194fb4d239d2eb7fcf85d597bfee0d
+  data.tar.gz: 11be53f33fd9e4d99af1a2df2f9b036787a1c0a3a319466232718f02866d52dd683364901368a29c28766ae4b78655eede050faa7378cce8949abba60a4f39e2

data/bin/regren

@@ -0,0 +1,94 @@
+#!/bin/env ruby
+
+$:.unshift(File.expand_path('../../lib', __FILE__))
+
+require 'optparse'
+require 'folder_contents_history'
+require 'filename_history'
+
+def string_prompt(prompt = '>')
+  begin
+  print("#{prompt} ")
+  gets.chomp
+rescue Interrupt
+  exit 130
+end
+end
+
+def prompt?(text, options = {})
+  begin
+    default = options[:yes]
+    return default if options[:quiet]
+    opts = default ? "[Y/n]" : "[y/N]"
+    while true
+      print "#{text} #{opts} "
+      c = STDIN.gets.chomp!
+      if c.downcase == 'y' or (default and c =='')
+        return true
+      elsif c.downcase == 'n' or (not default and c =='')
+        return false
+      end
+    end
+  rescue Interrupt
+    exit 130
+  end
+end
+
+options = { mode: :rename }
+optparse = OptionParser.new do |opts|
+  opts.on('-b','--backup','Make backup') { options[:backup] = true }
+  opts.on('-B','--new-backup','Start backups anew, implies --backup') do
+    options[:new_backup] = true
+    options[:backup] = true
+  end
+  opts.on('-n','--dry-run','Simulate') { options[:dry_run] = true }
+  opts.on('-y','--yes','Assume yes as default') { options[:yes] = true }
+  opts.on('-q','--quiet','Do not print anything') { options[:quiet] = true }
+  opts.on('-r','--restore','Restore backup') { options[:mode] = :restore }
+  opts.on('-R','--reapply','Reapply history') { options[:mode] = :reapply }
+  opts.on('-f','--file FILE', "File for backup/restore") { |file| options[:history_file] = file }
+  opts.on('-H','--history', "Show history for file") { options[:mode] = :history }
+  opts.on('-h','--help', "Print help") do
+    puts opts
+    exit
+  end
+end
+optparse.parse!
+options[:history_file] ||= '.backup'
+
+if options[:mode] == :rename
+  if ARGV.length != 2
+    options[:regexp] = Regexp.compile(string_prompt)
+    options[:replacement] = string_prompt
+  else
+    options[:regexp] = Regexp.compile(ARGV[0])
+    options[:replacement] = ARGV[1]
+  end
+end
+
+if File.exists?(options[:history_file]) && !options[:new_backup]
+  history = FolderContentsHistory.new_from_history(options[:history_file])
+else
+  history = FolderContentsHistory.new
+end
+  
+history.load_entries
+
+case options[:mode]
+when :history
+  history.show_history(ARGV.empty? ? Dir["*"] : ARGV)
+when :restore
+  history.plan_rollbacks
+when :rename
+  history.plan_renames(options[:regexp], options[:replacement])
+  require 'pry'; binding.pry
+when :reapply
+  history.plan_reapplication('.')
+end
+history.log unless options[:quiet]
+unless options[:dry_run] || options[:mode] == :history  
+  if !history.changed.empty? && prompt?("Execute the rename?", options)
+    history.log_backup(options[:history_file]) if options[:backup]
+    history.execute
+  end
+end

data/lib/filename_history.rb

@@ -0,0 +1,75 @@
+class FileNameHistory
+  def initialize(name, history = [])
+    @history = history.empty? ? [name] : history
+    @current = name
+  end
+
+  def to_hash
+    {
+      @history.last => @history
+    }
+  end
+
+  def self.new_from_history(history)
+    return FileNameHistory.new(history.last,
+                               history)
+  end
+
+  def present?
+    File.exists?(@current)
+  end
+
+  def original
+    @history.first
+  end
+
+  def history
+    @history
+  end
+
+  def last_name
+    @history.last
+  end
+
+  def plan_rename(regexp, replacement)
+    new_name = @current.gsub(regexp, replacement)
+    @history << new_name if new_name != current
+  end
+
+  def plan_rollback
+    @history << original
+  end
+
+  def was_named?(name)
+    @history.include? name
+  end
+
+  def plan_reapplication(name)
+    @current = name
+  end
+
+  def changed?
+    @history.last != @current
+  end
+
+  def rename
+    File.rename("#{@current}", "#{@history.last}")
+    @current = @history.last
+  end
+
+  def print_history(where = $stdout)
+    where.puts(@current)
+    where.print "-> #{@history.join("\n-> ")}\n\n"
+  end
+
+  def log(where = $stdout)
+    return unless changed?
+    where.puts(@current)
+    where.puts("-> #{@history.last}")
+  end
+
+  def current
+    @current
+  end
+
+end

data/lib/folder_contents_history.rb

@@ -0,0 +1,100 @@
+class FolderContentsHistory
+
+  require 'json'
+
+  def initialize(entries = {})
+    @entries = entries
+  end
+
+  def load_entries(path = '.')
+    entries = Dir["#{path}/*"].inject({}) do |hash, item|
+      pathless = item.gsub(/#{path}\//,'')
+      hash.update(pathless => FileNameHistory.new(pathless))
+    end
+    @entries.merge!(entries) do |key, old_hash, new_hash|
+      old_hash.history.length > new_hash.history.length ? old_hash : new_hash
+    end
+  end
+
+  def plan_renames(regexp, replacement)
+    @entries.select { |key, value| key[regexp] }.each_pair do |key, value|
+      value.plan_rename(regexp, replacement)
+    end
+  end
+
+  def plan_rollbacks
+    @entries.each_value do |file_history|
+      file_history.plan_rollback
+    end
+  end
+
+  def plan_reapplication(path)
+    entries = Dir["#{path}/*"].map { |file| file.gsub(/#{path}\//,'') }
+    histories = @entries.values
+    @entries = entries.inject({}) do |hash, item|
+      hash.tap do |obj|
+        new_history = histories.select { |history| history.was_named? item }.first
+        obj.update(item => new_history.clone) unless new_history.nil?
+      end
+    end
+    @entries.select! { |name, history| history }
+    @entries.each { |name, history| history.plan_reapplication(name) }
+  end
+
+  def execute
+    changed.each_pair do |key, value|
+      value.rename
+      @entries[value.current] = @entries.delete(key)
+    end
+  end
+
+  def log
+    if conflicts?
+      puts <<-NOTE.gsub(/^.*\|/, '')
+      |==================================================
+      |!!! Some files would be lost by this operation !!!
+      |==================================================
+      NOTE
+    end
+    changed.each_value do |file_history|
+      file_history.log
+    end
+  end
+
+  def log_backup(where)
+    with_history = @entries.select { |name, history| history.history.length > 1 }
+    backup = with_history.inject({}) do |hash, item|
+      hash.update(item.last.to_hash)
+    end
+    File.write(where, JSON.pretty_generate(backup))
+  end
+
+  def to_hash(input_hash = @entries)
+    input_hash.inject({}) do |hash, entry|
+      hash.update(entry[0] => entry[1].to_hash)
+    end
+  end
+
+  def changed
+    @entries.select { |_key, value| value.changed? && value.present? }
+  end
+
+  def show_history(files)
+    files.each do |file|
+      @entries[file] = FileNameHistory.new(file) unless @entries[file]
+      @entries[file].print_history
+    end
+  end
+
+  def conflicts?
+    #changed.map { |entry| entry.last }.compact.uniq.length < changed.length
+    @entries.map { |entry| entry.last.last_name }.compact.uniq.length < @entries.length
+  end
+
+  def self.new_from_history(history_file)
+    entries = JSON.parse(File.read(history_file)).inject({}) do |hash, item|
+      hash.update(item.first => FileNameHistory.new_from_history(item.last))
+    end
+    FolderContentsHistory.new(entries)
+  end
+end

data/test/filename_history_test.rb

@@ -0,0 +1,41 @@
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'filename_history'
+
+describe 'FileNameHistory test' do
+  before do
+    @filename_history = FileNameHistory.new 'test'
+  end
+
+  it 'has the same current and original name' do
+    @filename_history.current.must_equal @filename_history.original
+  end
+
+  it 'has history of length 1' do
+    @filename_history.history.must_be_instance_of Array
+    @filename_history.history.length.must_equal 1
+  end
+
+  it 'must return a hash' do
+    @filename_history.to_hash.must_be_instance_of Hash
+  end
+
+  it 'must not be changed' do
+    @filename_history.changed?.must_equal false
+  end
+
+  it 'plans renames correctly' do
+    @filename_history.plan_rename(/test/, 'tset')
+    @filename_history.history.length.must_equal 2
+    @filename_history.changed?.must_equal true
+    @filename_history.was_named?('test').must_equal true
+  end
+
+  it 'plans rollbacks correctly' do
+    @filename_history.plan_rename(/test/, 'tset')
+    @filename_history.changed?.must_equal true
+    @filename_history.plan_rollback
+    @filename_history.changed?.must_equal false
+    @filename_history.was_named?('tset').must_equal true
+  end
+end

data/test/folder_contents_history_test.rb

@@ -0,0 +1,126 @@
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'folder_contents_history'
+require 'tmpdir'
+require 'fileutils'
+
+describe 'FolderContentsHistory test' do
+
+  describe 'when no data is loaded' do
+    before do
+      @fch = FolderContentsHistory.new      
+    end
+
+    it 'is not changed' do
+      @fch.changed.must_be_instance_of Hash
+      @fch.changed.empty?.must_equal true
+    end
+
+    it 'has no conflicts' do
+      @fch.changed.must_be_instance_of Hash
+      @fch.changed.length.must_equal 0
+    end
+
+    it 'has empty hash as representation' do
+      @fch.to_hash.must_be_instance_of Hash
+      @fch.to_hash.empty?.must_equal true
+    end
+
+    it 'returns empty hash when planning' do
+      hash = @fch.plan_renames(//,'')
+      hash.must_be_instance_of Hash
+      hash.empty?.must_equal true
+
+      hash = @fch.plan_rollbacks
+      hash.must_be_instance_of Hash
+      hash.empty?.must_equal true
+
+      hash = @fch.plan_reapplication('.')
+      hash.must_be_instance_of Hash
+      hash.empty?.must_equal true
+    end
+
+  end
+
+  describe 'with data loaded' do
+    before do
+      @path = Dir.mktmpdir('test')
+      @old_dir = Dir.pwd
+      @fch = FolderContentsHistory.new
+      Dir.chdir(@path)
+      5.times do |num| 
+        File.open("test-#{num}",'w') do |file|
+          file.puts("a")
+        end
+      end
+      result = @fch.load_entries('.')
+    end
+
+    it 'loads data properly' do
+      result = @fch.load_entries('.')
+      result.must_be_instance_of Hash
+      result.keys.length.must_equal 5
+    end
+
+    it 'is changed' do
+      @fch.plan_renames(/(\d)/,'\1\1')
+      @fch.changed.must_be_instance_of Hash
+      @fch.changed.empty?.must_equal false
+    end
+
+    it 'has no conflicts' do
+      @fch.plan_renames(/(\d)/,'\1\1')
+      @fch.conflicts?.must_equal false
+    end
+
+    it 'has hash as representation' do
+      @fch.plan_renames(/(\d)/,'\1\1')
+      @fch.to_hash.must_be_instance_of Hash
+      @fch.to_hash.empty?.must_equal false
+    end
+
+    after do
+      Dir.chdir(@old_dir)
+      FileUtils.rm_rf(@path)
+    end
+  end
+
+  describe 'when reapplying' do
+    before do
+      @path = Dir.mktmpdir('test')
+      @old_dir = Dir.pwd
+      Dir.chdir(@path)
+      @fch = FolderContentsHistory.new
+      File.open("test-1",'w') do |file|
+        file.puts("a")
+      end
+      @fch.load_entries('.')
+      @fch.plan_renames(/test-1/,'test-2')
+      @fch.execute
+      @fch.plan_renames(/test-2/,'test-3')
+      @fch.execute
+      File.open('test-1','w') do |file|
+        file.puts
+      end
+    end
+
+    it 'reapplies correctly' do
+      File.delete('test-3')
+      @fch.plan_reapplication('.')
+      @fch.changed.must_be_instance_of Hash
+      @fch.changed.empty?.must_equal false
+    end
+
+    it 'warns about conflict' do
+      @fch.plan_reapplication('.')
+      -> { @fch.log }.must_output(<<-MSG.gsub(/^.*\|/,'')
+       |==================================================
+       |!!! Some files would be lost by this operation !!!
+       |==================================================
+       |test-1
+       |-> test-3
+       MSG
+       )
+    end
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: regren
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Adam Ruzicka
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 4.7.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 4.7.3
+description: A simple gem for batch renaming files
+email: a.ruzicka@outlook.com
+executables:
+- regren
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/regren
+- lib/filename_history.rb
+- lib/folder_contents_history.rb
+- test/filename_history_test.rb
+- test/folder_contents_history_test.rb
+homepage: https://github.com/adamruzicka/regren
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.3.0
+signing_key: 
+specification_version: 4
+summary: regren
+test_files: []