plexify 0.1.1 → 0.2.0

data/Gemfile

@@ -5,5 +5,7 @@ gemspec
 
 gem "ruby-tmdb", ">= 0.2.1"
 gem "colorize", ">= 0.5.8"
-gem "text", ">= 1.2.1"
 gem "ruby-progressbar", ">= 1.0.2"
+gem "debugger", ">= 1.2.2"
+gem "rspec", ">= 2.12.0"
+gem "amatch", ">= 0.2.10"

data/README.md

@@ -1,8 +1,9 @@
 # Plexify
 
-Currently in development. Not working yet.
+Plexify is a file organizer tool to manage medias. It analyses files and search for movies in TheMovieDB to have
+informations about them and create good folder names and add some additional stuffs like posters, desriptions
+(these two lasts aren't supported yet, but will be ;))
 
-TODO: Write a gem description
 
 ## Installation
 
@@ -18,14 +19,36 @@ Or install it yourself as:
 
     $ gem install plexify
 
+## Ruby
+
+Plexify is compatible with
+
+    ruby 1.9.3
+
 ## Usage
 
-TODO: Write usage instructions here
+Plexify analyses files and move them to an oranized folder, so it creates destination folders and media folders.
+
+The default usage is:
+
+    $ plexify -s /media/Temp -d /media/PlexMediaFolder
+
+or more simple
+
+    $ plexify /media/Temp /media/PlexMediaFolder
+    
+If you specify a destination with the -d flag, it will create two folders inside the destination folder named "Movies" and "TV_Shows".
+
+You can also specify movies and series folders like that:
+
+    $ plexify -s /media/Temp --movies-destination /media/PlexMediaFolder/Movies --series-destination /media/PlexMediaFolder/Series
+
+If you aren't really sure about the tool, you can either use plexify in test mode like that:
+
+    $ plexify -s /media/Temp -d /media/PlexMediaFolder --test
+
+It will just print found medias and not move files.
 
-## Contributing
+## Contributors
 
-1. Fork it
-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 new Pull Request
+1. Pierre FILSTROFF ([reaper](https://github.com/reaper/))

data/Rakefile

@@ -1 +1,3 @@
 require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new('spec')

data/lib/plexify.rb

@@ -5,19 +5,23 @@ require 'optparse'
 require 'colorize'
 require 'ruby-tmdb'
 require 'yaml'
-require 'text'
+require 'amatch'
 
 Dir[File.dirname(__FILE__) + "/plexify/**/*"].each{ |file| require file }
 
 module Plexify
-    class Plexify
-        def initialize(args)
-            @opts = Execute::Plexify.new(args)
-        end
+  class Plexify
+    def initialize(args)
+      @opts = Execute::Plexify.new(args)
+    end
 
-        # Run plexify !
-        def run!
-            @opts.parse!
-        end
+    # Run plexify !
+    def run!
+      @opts.parse!
     end
+  end
+      
+  def self.version
+    return "Plexify version #{VERSION}"
+  end
 end

data/lib/plexify/execute.rb

@@ -1,170 +1,180 @@
 module Plexify
-    module Execute
-        class Plexify
-            # Plexify::Execute initialize method
-            def initialize(args)
-                @args = args
-                @options = {}
-                @missing_args = []
+  module Execute
+    class Plexify
+      # Plexify::Execute initialize method
+      def initialize(args)
+        @args = args
+        @options = {}
+        @missing_args = []
+      end
+
+      # Parses the command-line arguments and execute files processing
+      def parse!
+        begin
+          @opts = OptionParser.new(&method(:set_opts))
+          @opts.parse!(@args)
+          check_arguments
+
+          if @args.any?
+            @options[:source] = @args[0] unless @options[:source]
+            @options[:destination] = @args[1] if @args[1] && !@options[:destination]
+          end
+
+          process_result
+
+          # Puts missing arguments
+        rescue OptionParser::MissingArgument => e
+          built_string = e.message
+          for arg in @missing_args
+            built_string += arg
+            unless @missing_args.last == arg
+              built_string += ", "
+            else
+              built_string += "\n\n"
             end
+          end
+          puts built_string
+          puts @opts
 
-            # Parses the command-line arguments and execute files processing
-            def parse!
-                begin
-                    @opts = OptionParser.new(&method(:set_opts))
-                    @opts.parse!(@args)
-                    check_arguments
-
-                    if @args.any?
-                        @options[:source] = @args[0] unless @options[:source]
-                        @options[:destination] = @args[1] unless @options[:destination]
-                    end
-
-                    process_result
-
-                # Puts missing arguments
-                rescue OptionParser::MissingArgument => e
-                    built_string = e.message
-                    for arg in @missing_args
-                        built_string += arg
-                        unless @missing_args.last == arg
-                            built_string += ", "
-                        else
-                            built_string += "\n\n"
-                        end
-                    end
-                    puts built_string
-                    puts @opts
-
-                # Puts exception message
-                rescue Exception => e
-                    raise e if @options[:trace] || e.is_a?(SystemExit)
-
-                    print "\n#{e.class}: " unless e.class == RuntimeError
-                    puts "#{e.message}"
-                    puts "  Use --trace for backtrace."
-                end
-                exit 0
-            end
+          # Puts exception message
+        rescue Exception => e
+          raise e if @options[:trace] || e.is_a?(SystemExit)
 
-            private
-            # Check missing arguments
-            def check_arguments
-                return if @args.size == 2
+          print "\n#{e.class}: " unless e.class == RuntimeError
+          puts "#{e.message}"
+          puts "  Use --trace for backtrace."
+        end
+        exit 0
+      end
 
-                @missing_args << "-s [source]" if !@options[:source] && !@args[0]
-                @missing_args << "-d [destination]" if !@options[:destination] && !@options[:movies_destination] && !@options[:series_destination]
-                @missing_args << "--movies-destination [destination]" if !@options[:destination] && !@options[:movies_destination] && !@options[:series_destination]
-                @missing_args << "--series-destination [destination]" if !@options[:destination] && !@options[:series_destination] && !@options[:movies_destination]
+      private
+      # Check missing arguments
+      def check_arguments
+        return if @args.size == 2
 
-                if @missing_args.any?
-                    raise OptionParser::MissingArgument
-                end
-            end
+        @missing_args << "-s [source]" if !@options[:source] && !@args[0]
+        @missing_args << "-d [destination]" if !@options[:test] && !@options[:destination] && !@options[:movies_destination] && !@options[:series_destination]
+        @missing_args << "--movies-destination [destination]" if !@options[:test] && !@options[:destination] && !@options[:movies_destination] && !@options[:series_destination]
+        @missing_args << "--series-destination [destination]" if !@options[:test] && !@options[:destination] && !@options[:series_destination] && !@options[:movies_destination]
 
-            # Set options definition for command-line execution
-            def set_opts(opts)
-                opts.banner = "Usage: plexify -s /media/temp --movies-destination /media/Movies --series-destination /media/Series\n\n"
+        if @missing_args.any?
+          raise OptionParser::MissingArgument
+        end
+      end
 
-                opts.on('-s [source]', '--source [source]', 'Source folder which includes media files. Temp folder.') do |source|
-                    @options[:source] = source
-                end
+      # Set options definition for command-line execution
+      def set_opts(opts)
+        opts.banner = "Usage: plexify -s /media/temp --movies-destination /media/Movies --series-destination /media/Series\n\n"
 
-                opts.on('-d [destination]', '--destination [dest]', 'Destination folder to put organized.') do |destination|
-                    @options[:destination] = destination
-                end
+        opts.on('-s [source]', '--source [source]', 'Source folder which includes media files. Temp folder.') do |source|
+          @options[:source] = source
+        end
 
-                opts.on('--movies-destination [dest]', 'Destination folder to put organized movies files.') do |movies_destination|
-                    @options[:movies_destination] = movies_destination
-                end
+        opts.on('-d [destination]', '--destination [dest]', 'Destination folder to put organized.') do |destination|
+          @options[:destination] = destination
+        end
 
-                opts.on('--series-destination [dest]', 'Destination folder to put organized series files.') do |series_destination|
-                    @options[:series_destination] = series_destination
-                end
+        opts.on('--movies-destination [dest]', 'Destination folder to put organized movies files.') do |movies_destination|
+          @options[:movies_destination] = movies_destination
+        end
 
-                opts.on_tail('-t', '--test', 'Test files name searching in media databases: only print results.') do
-                    @options[:test] = true
-                end
+        opts.on('--series-destination [dest]', 'Destination folder to put organized series files.') do |series_destination|
+          @options[:series_destination] = series_destination
+        end
 
-                opts.on_tail('--accept-removing-all', :NONE, 'Accept removing source files. [NOT WORKING YET]') do
-                    @options[:accept_removing_all] = true
-                end
+        opts.on_tail('-t', '--test', 'Test files name searching in media databases: only print results.') do
+          @options[:test] = true
+        end
 
-                opts.on_tail("-?", "-h", "--help", "Show this message.") do
-                    puts opts
-                    exit
-                end
+        opts.on_tail('--accept-removing-all', :NONE, 'Accept removing source files. [NOT WORKING YET]') do
+          @options[:accept_removing_all] = true
+        end
 
-                opts.on_tail("-v", "--version", "Print version") do
-                    puts("Plexify #{VERSION}")
-                    exit
-                end
-                
-                opts.on_tail('--trace', :NONE, 'Show a full traceback on error') do
-                  @options[:trace] = true
-                end
-            end
+        opts.on_tail("-?", "-h", "--help", "Show this message.") do
+          puts opts
+          exit
+        end
+
+        opts.on_tail("-v", "--version", "Print version") do
+          puts("Plexify #{VERSION}")
+          exit
+        end
 
-            # Process result
-            def process_result
+        opts.on_tail('--trace', :NONE, 'Show a full traceback on error') do
+          @options[:trace] = true
+        end
+      end
 
-                Logger.info("=> Preparing source folder")
-                source = Prepare::Source.new(@options)
-                source.prepare
-                Logger.info(" : #{source.files.size} #{source.files.size > 1 ? 'files' : 'file'} found")
+      # Process result
+      def process_result
 
-                unless @options[:test]
-                    Logger.info("\n=> Preparing destination folder")
-                    destination = Prepare::Destination.new(@options)
-                    destination.prepare
-                end
+        Logger.info("=> Preparing source folder")
+        source = Prepare::Source.new(@options)
+        source.prepare
+        Logger.info(" : #{source.files.size} #{source.files.size > 1 ? 'files' : 'file'} found")
+
+        unless @options[:test]
+          Logger.info("\n=> Preparing destination folder")
+          destination = Prepare::Destination.new(@options)
+          destination.prepare
+        end
 
-                media_manager = MediaManager.new
-                media_organizer = MediaOrganizer.new(source, destination) unless @options[:test]
-
-                files_processed_count = 0
-                
-                # Process files
-                for file in source.files
-                    basename = File.basename(file.path)
-                    Logger.info("\n\n=> Analyzing '#{basename}' file...")
-                    medias = media_manager.analyze(file)
-
-                    # Choose the good media
-                    if medias.any?
-                        Logger.info("\nFound medias :")
-
-                        # If the test argument is present, don't move files or prompt the user
-                        if @options[:test]
-                            for media in medias
-                                Logger.success("\n#{media.data.name} #{media.data.released ? "(#{Date.parse(media.data.released).year})" : nil}")
-                            end
-                        else
-                            Logger.success("\n0: The movie isn't in the list, go next without doing anything.")
-                            medias.each_with_index do |media, index|
-                                Logger.success("\n#{index+1}: #{media.data.name} #{media.data.released ? "(#{Date.parse(media.data.released).year})" : nil}")
-                            end
-
-                            Logger.success("\nChoose the movie: ")
-                            resp = STDIN.gets.chomp.to_i-1
-
-                            if resp >= 0 && resp <= medias.size
-                                media = medias[resp]
-                                Logger.success("\nMedia found : #{media.data.name} #{media.data.released ? "(#{Date.parse(media.data.released).year})" : nil}")
-                                media_organizer.move_to_destination(file, media)
-                                files_processed_count += 1
-                            elsif resp == -1
-                                Logger.info("Aborting...")
-                                next
-                            end
-                        end
-                    else
-                        Logger.error("\nMedia not found")
-                    end
+        media_manager = MediaManager.new
+        media_organizer = MediaOrganizer.new(source, destination) unless @options[:test]
+
+        files_processed_count = 0
+
+        # Process files
+        for file in source.files
+          basename = File.basename(file.path)
+          Logger.info("\n\n=> Analyzing '#{basename}' file...")
+          medias = media_manager.analyze(file)
+
+          # Choose the good media
+          if medias.any?
+
+            # If the test argument is present, don't move files or prompt the user
+            if @options[:test]
+              Logger.info("\nFound medias :")
+
+              for media in medias
+                Logger.success("\n#{media.data.name} #{media.data.released ? "(#{Date.parse(media.data.released).year})" : nil}")
+              end
+            else
+              Logger.success("\nThe movie is '#{medias.first.data.name} #{medias.first.data.released ? "(#{Date.parse(medias.first.data.released).year})" : nil}'. Right ? (y/n) ")
+              resp = STDIN.gets.chomp
+
+              if resp.eql?("y")
+
+                media_organizer.move_to_destination(file, medias.first)
+                files_processed_count += 1
+              else
+                Logger.success("\n0: The movie isn't in the list, go next without doing anything.")
+                medias.each_with_index do |media, index|
+                  Logger.success("\n#{index+1}: #{media.data.name} #{media.data.released ? "(#{Date.parse(media.data.released).year})" : nil}")
                 end
 
-                Logger.info("\n\n=> Files pocessed #{files_processed_count}/#{source.files.size}") unless @options[:test]
+                Logger.success("\nChoose the movie: ")
+                resp = STDIN.gets.chomp.to_i-1
+
+                if resp >= 0 && resp <= medias.size
+                  media = medias[resp]
+                  Logger.success("\nMedia found : #{media.data.name} #{media.data.released ? "(#{Date.parse(media.data.released).year})" : nil}")
+                  media_organizer.move_to_destination(file, media)
+                  files_processed_count += 1
+                elsif resp == -1
+                  Logger.info("Aborting...")
+                  next
+                end
+              end
             end
+          else
+            Logger.error("\nMedia not found")
+          end
         end
+
+        Logger.info("\n\n=> Files pocessed #{files_processed_count}/#{source.files.size}") unless @options[:test]
+      end
     end
+  end
 end

data/lib/plexify/logger.rb

@@ -1,19 +1,19 @@
 module Plexify
-    # Logger class
-    class Logger
-        # print informations
-        def self.info(content)
-            print content
-        end
+  # Logger class
+  class Logger
+    # print informations
+    def self.info(content)
+      print content
+    end
 
-        # print success in green
-        def self.success(content)
-            print content.colorize(:green)
-        end
+    # print success in green
+    def self.success(content)
+      print content.colorize(:green)
+    end
 
-        # print errors in red
-        def self.error(content)
-            print content.colorize(:red)
-        end
+    # print errors in red
+    def self.error(content)
+      print content.colorize(:red)
     end
+  end
 end

data/lib/plexify/media.rb

@@ -1,13 +1,13 @@
 module Plexify
-    # Media class
-    # Will include more methods to test media data
-    class Media
-        attr_accessor :data
-        attr_accessor :found_title
-        attr_accessor :score
+  # Media class
+  # Will include more methods to test media data
+  class Media
+    attr_accessor :data
+    attr_accessor :found_title
+    attr_accessor :score
 
-        def initialize(data)
-            @data = data
-        end
+    def initialize(data)
+      @data = data
     end
+  end
 end

data/lib/plexify/media_manager.rb

@@ -1,88 +1,106 @@
 module Plexify
-    class MediaManager
-        # Initialize variables and load tmdb media manager
-        def initialize
-            @tmdb_api_key = nil
-            @tmdb_default_language = nil
-            load_tmdb
-        end
-
-        # Search for a media in the Tmdb media manager database.
-        def analyze(file)
-            name = File.basename(file.path, File.extname(file.path))
-            splitted_name = name.split(/\W/).map(&:downcase)
+  class MediaManager
+    include Amatch
 
-            medias = analyse_names(splitted_name, {})
+    # Initialize variables and load tmdb media manager
+    def initialize
+      @tmdb_api_key = nil
+      @tmdb_default_language = nil
+      load_tmdb
+    end
 
-            flattened_medias = []
-            medias.each_pair do |title, media|
-                flattened_medias << media if flattened_medias.empty?
-                unless flattened_medias.map(&:data).map(&:id).include?(media.data.id)
-                    media.found_title = title
-                    flattened_medias << media
-                end
-            end
+    # Search for a media in the Tmdb media manager database.
+    def analyze(file)
+      name = File.basename(file.path, File.extname(file.path))
+      splitted_name = name.split(/\W/).map(&:downcase)
+      found_medias = analyze_names(splitted_name, {})
 
-            return flattened_medias
+      medias = Array.new
+      found_medias.each_pair do |title, list|
+        for media in list
+          medias << media if medias.empty?
+          unless medias.map(&:data).map(&:id).include?(media.data.id)
+            media.found_title = title
+            medias << media
+          end
         end
+      end
 
-        private
-        # Load tmdb media manager
-        def load_tmdb
-            load_plexify_config
-            Tmdb.api_key = @tmdb_api_key
-            Tmdb.default_language = @tmdb_default_language
-        end
+      # Check differences betweend the file title
+      # and found medias names
+      title = name.gsub(/\W/, " ").downcase
+      for media in medias
+        name = media.data.name.downcase
+        media.score = title.hamming_similar(name)
+      end
 
-        # Load plexify config yaml file in the home directory
-        # The file structure is :
-        # plexify:
-        #     tmdb:
-        #         api_key: xxxx
-        #         default_language: en
-        def load_plexify_config
-            config_file_path = File.join(File.dirname(__FILE__), "../../.plexify.yml")
-            config_file = File.open config_file_path
-            yaml_config = YAML::load(config_file)
-            
-            tmdb_config = yaml_config["plexify"]["tmdb"]
-            @tmdb_api_key = tmdb_config["api_key"]
-            @tmdb_default_language = tmdb_config["default_language"]
-        end
+      # Compare title with original media name
+      # if the score is better, it selects it
+      for media in medias
+        name = media.data.original_name.downcase
+        score = title.hamming_similar(name)
+        media.score = score if score > media.score
+      end
 
-        def analyse_names(list, medias)
-            title = String.new
+      # Return ten last medias sort by score
+      return medias.sort_by(&:score).reverse.delete_if {|m| medias.index(m) > 10 }
+    end
 
-            list.each_with_index do |str, index|
-                title << " " if title.length > 0
-                title << str
-                media = find(title)
+    private
+    # Load tmdb media manager
+    def load_tmdb
+      load_plexify_config
+      Tmdb.api_key = @tmdb_api_key
+      Tmdb.default_language = @tmdb_default_language
+    end
 
-                if media.empty?
-                    if medias.any?
-                        shift = list.shift
-                        analyse_names(list, medias)
-                    end
-                else
-                    medias[title] = Media.new(media)
-                end
-            end
-            return medias
-        end
+    # Load plexify config yaml file in the home directory
+    # The file structure is :
+    # plexify:
+    #     tmdb:
+    #         api_key: xxxx
+    #         default_language: en
+    def load_plexify_config
+      config_file_path = File.join(File.dirname(__FILE__), "../../.plexify.yml")
+      config_file = File.open config_file_path
+      yaml_config = YAML::load(config_file)
 
-        # Get Levenshtein distance
-        def levenshtein_distance(first, second)
-            Text::Levenshtein.distance(first, second)
-        end
+      tmdb_config = yaml_config["plexify"]["tmdb"]
+      @tmdb_api_key = tmdb_config["api_key"]
+      @tmdb_default_language = tmdb_config["default_language"]
+    end
 
-        # Find a movie in the Tmdb database with a title and a limit of one item
-        def find(title)
-            TmdbMovie.find(:title => title, :limit => 1)
-        end
+    # Analyze title name: iterates each words and find a related media
+    def analyze_names(list, medias)
+      title = String.new
+
+      list.each_with_index do |str, index|
+        title << " " if title.length > 0
+        title << str
+        found_medias = find(title)
 
-        # Find all movies in the Tmdb database with a title
-        def find_all(title)
-            TmdbMovie.find(:title => title)
+        if found_medias.empty?
+          if medias.any?
+            shift = list.shift
+            analyze_names(list, medias)
+          end
+        else
+          tmp_medias = Array.new
+          found_medias.each { |m| tmp_medias << Media.new(m) }
+          medias[title] = tmp_medias
         end
+      end
+      return medias
+    end
+
+    # Find a movie in the Tmdb database with a title and a limit of one item
+    def find(title)
+      TmdbMovie.find(:title => title, :limit => 5)
+    end
+
+    # Find all movies in the Tmdb database with a title
+    def find_all(title)
+      TmdbMovie.find(:title => title)
     end
+  end
 end

data/lib/plexify/media_organizer.rb

@@ -1,71 +1,71 @@
 module Plexify
-    # Class MediaOrganizer
-    # It manage source and destination folders
-    class MediaOrganizer
-        attr_reader :source
-        attr_reader :destination
+  # Class MediaOrganizer
+  # It manage source and destination folders
+  class MediaOrganizer
+    attr_reader :source
+    attr_reader :destination
 
-        # Initialize
-        def initialize(source, destination)
-            @source = source
-            @destination = destination
-        end
+    # Initialize
+    def initialize(source, destination)
+      @source = source
+      @destination = destination
+    end
 
-        # Move a file the his appropriate destination folder
-        def move_to_destination(file, media)
-            # Consider media is a movie
-            destination = @destination.movies_folder.path
+    # Move a file the his appropriate destination folder
+    def move_to_destination(file, media)
+      # Consider media is a movie
+      destination = @destination.movies_folder.path
 
-            # Create an appropriate media folder
-            media_folder_name = "#{media.data.name} (#{Date.parse(media.data.released).year})"
-            media_folder_path = File.join(destination, media_folder_name)
-            file_basename = File.basename(file.path)
+      # Create an appropriate media folder
+      media_folder_name = "#{media.data.name} (#{Date.parse(media.data.released).year})"
+      media_folder_path = File.join(destination, media_folder_name)
+      file_basename = File.basename(file.path)
 
-            # Create the movie folder
-            FileUtils.mkdir(media_folder_path) unless File.exists?(media_folder_path)
-            media_folder = File.open(media_folder_path)
+      # Create the movie folder
+      FileUtils.mkdir(media_folder_path) unless File.exists?(media_folder_path)
+      media_folder = File.open(media_folder_path)
 
-            if media_folder
-                renamed_file_basename = media_folder_name + File.extname(file_basename)
-                renamed_file_path = File.join(media_folder.path, renamed_file_basename)
+      if media_folder
+        renamed_file_basename = media_folder_name + File.extname(file_basename)
+        renamed_file_path = File.join(media_folder.path, renamed_file_basename)
 
-                # Copy the file with a progress bar
-                Logger.info("\nCopying file to '#{renamed_file_path}'")
-                copy_with_progressbar(file.path, renamed_file_path)
-                Logger.success("File '#{renamed_file_path}' copied") if File.exists?(renamed_file_path)
-            end
+        # Copy the file with a progress bar
+        Logger.info("Copying file to '#{renamed_file_path}'")
+        copy_with_progressbar(file.path, renamed_file_path)
+        Logger.success("File '#{renamed_file_path}' copied") if File.exists?(renamed_file_path)
+      end
 
-            Logger.info("\nDo you want to remove the source file '#{file_basename}' ? (y/n) ")
-            resp = STDIN.gets.chomp
+      Logger.info("\nDo you want to remove the source file '#{file_basename}' ? (y/n) ")
+      resp = STDIN.gets.chomp
 
-            if resp.eql?("y")
-                FileUtils.rm file.path
-                Logger.success("File '#{file_basename}' removed")
-            end
-        end
+      if resp.eql?("y")
+        FileUtils.rm file.path
+        Logger.success("File '#{file_basename}' removed")
+      end
+    end
 
-        private
+    private
 
-        # Copy a file with a great progress bar
-        def copy_with_progressbar(source, destination)
-            source_file = File.new(source, "r")
-            destination_file = File.new(destination, "w")
-            source_size = File.size(source)
-            batch_bytes = ( source_size / 100 ).ceil
-            total = 0
+    # Copy a file with a great progress bar
+    def copy_with_progressbar(source, destination)
+      source_file = File.new(source, "r")
+      destination_file = File.new(destination, "w")
+      source_size = File.size(source)
+      batch_bytes = ( source_size / 100 ).ceil
+      total = 0
 
-            p_bar = ProgressBar.create(:title => "Copying '#{File.basename(source_file.path)}'", :format => '|%b>%i| %p%% %t')
-            buffer = source_file.sysread(batch_bytes)
+      p_bar = ProgressBar.create(:title => "Copying '#{File.basename(destination_file.path)}'", :format => '|%b>%i| %p%% %t')
+      buffer = source_file.sysread(batch_bytes)
 
-            while total < source_size do
-                destination_file.syswrite(buffer)
-                p_bar.progress = ((total*100)/source_size).ceil + 1
-                total += batch_bytes
-                if (source_size - total) < batch_bytes
-                    batch_bytes = (source_size - total)
-                end
-                buffer = source_file.sysread(batch_bytes)
-            end
+      while total < source_size do
+        destination_file.syswrite(buffer)
+        p_bar.progress = ((total*100)/source_size).ceil + 1
+        total += batch_bytes
+        if (source_size - total) < batch_bytes
+          batch_bytes = (source_size - total)
         end
+        buffer = source_file.sysread(batch_bytes)
+      end
     end
+  end
 end

data/lib/plexify/prepare.rb

@@ -1,91 +1,91 @@
 module Plexify
-    module Prepare
-        # Destination class implementation
-        class Destination
-            attr_accessor :folder
-            attr_accessor :movies_folder
-            attr_accessor :series_folder
+  module Prepare
+    # Destination class implementation
+    class Destination
+      attr_accessor :folder
+      attr_accessor :movies_folder
+      attr_accessor :series_folder
 
-            # Plexify::Execute initialize method
-            def initialize(options)
-                @destination_path = options[:destination]
-                @movies_destination_path = options[:movies_destination]
-                @series_destination_path = options[:series_destination]
-            end
+      # Plexify::Execute initialize method
+      def initialize(options)
+        @destination_path = options[:destination]
+        @movies_destination_path = options[:movies_destination]
+        @series_destination_path = options[:series_destination]
+      end
 
-            def prepare
-                if @destination_path
-                    prepare_destination
-                else
-                    prepare_destinations
-                end
-            end
-
-            protected
-            # Prepare destination
-            def prepare_destination
-                # Create destination folder
-                destination_path = @destination_path
-                @folder = create_or_use_folder(destination_path)
+      def prepare
+        if @destination_path
+          prepare_destination
+        else
+          prepare_destinations
+        end
+      end
 
-                # Create "Movies" and "TV Shows" folder
-                @movies_folder = create_or_use_folder(destination_path, "Movies")
-                @series_folder = create_or_use_folder(destination_path, "TV Shows")
-            end
+      protected
+      # Prepare destination
+      def prepare_destination
+        # Create destination folder
+        destination_path = @destination_path
+        @folder = create_or_use_folder(destination_path)
 
-            # Prepare destinations
-            def prepare_destinations
-                # Create or use movies and series folders
-                movies_path = @movies_destination_path
-                series_path = @series_destination_path
+        # Create "Movies" and "TV Shows" folder
+        @movies_folder = create_or_use_folder(destination_path, "Movies")
+        @series_folder = create_or_use_folder(destination_path, "TV Shows")
+      end
 
-                @movies_folder = create_or_use_folder(movies_path) if movies_path
-                @series_folder = create_or_use_folder(series_path) if series_path
-            end
+      # Prepare destinations
+      def prepare_destinations
+        # Create or use movies and series folders
+        movies_path = @movies_destination_path
+        series_path = @series_destination_path
 
-            # Create or use a folder
-            def create_or_use_folder(*args)
-                path = args.first
+        @movies_folder = create_or_use_folder(movies_path) if movies_path
+        @series_folder = create_or_use_folder(series_path) if series_path
+      end
 
-                if args.size > 1
-                    name = args[1]
-                end
+      # Create or use a folder
+      def create_or_use_folder(*args)
+        path = args.first
 
-                folder_path = name ? File.join(path, name) : path
+        if args.size > 1
+          name = args[1]
+        end
 
-                if File.exists?(folder_path) && File.directory?(folder_path)
-                    folder = File.open(folder_path)
-                else
-                    Logger.info("\n=> Created missing '#{name ? name : File.basename(folder_path)}' folder in destination folder.")
-                    FileUtils.mkdir_p folder_path
-                    folder = File.open(folder_path) if File.exists?(folder_path)
-                end
+        folder_path = name ? File.join(path, name) : path
 
-                folder
-            end
+        if File.exists?(folder_path) && File.directory?(folder_path)
+          folder = File.open(folder_path)
+        else
+          Logger.info("\n=> Created missing '#{name ? name : File.basename(folder_path)}' folder in destination folder.")
+          FileUtils.mkdir_p folder_path
+          folder = File.open(folder_path) if File.exists?(folder_path)
         end
 
-        # Source class implementation
-        class Source
-            attr_accessor :folder
-            attr_accessor :files
-            
-            # Initialize
-            def initialize(options)
-                @source_path = options[:source]
-                @files = Array.new
-            end
+        folder
+      end
+    end
+
+    # Source class implementation
+    class Source
+      attr_accessor :folder
+      attr_accessor :files
+
+      # Initialize
+      def initialize(options)
+        @source_path = options[:source]
+        @files = Array.new
+      end
 
-            # Prepare source folder
-            def prepare
-                @folder = File.new @source_path
+      # Prepare source folder
+      def prepare
+        @folder = File.new @source_path
 
-                if File.exists?(@folder.path) && File.directory?(@folder.path)
-                    Dir.glob(@folder.path + "/**/*.{mkv,avi,mov}") do |file|
-                      @files << File.open(file)
-                    end
-                end
-            end
+        if File.exists?(@folder.path) && File.directory?(@folder.path)
+          Dir.glob(@folder.path + "/**/*.{mkv,avi,mov}") do |file|
+            @files << File.open(file)
+          end
         end
+      end
     end
+  end
 end

data/lib/plexify/version.rb

@@ -1,3 +1,3 @@
 module Plexify
-  VERSION = "0.1.1"
+  VERSION = "0.2.0"
 end

data/plexify.gemspec

@@ -14,9 +14,11 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency("ruby-tmdb", "= 0.2.1")
   gem.add_dependency("colorize", "= 0.5.8")
-  gem.add_dependency("text", "= 1.2.1")
+  gem.add_dependency("amatch", "= 0.2.10")
   gem.add_dependency("ruby-progressbar", "= 1.0.2")
 
+  gem.add_development_dependency 'rspec', '~> 2.12.0'
+
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})

data/spec/plexify_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Plexify, "#Version" do
+  it 'should return correct version string' do
+    Plexify.version.should == "Plexify version #{Plexify::VERSION}"
+  end
+end
+
+describe Plexify, "#Arguments" do
+  it 'should raise an error by passing bad arguments count' do
+    #TODO
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'bundler/setup'
+require 'plexify'
+
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.formatter     = 'documentation'
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: plexify
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-03 00:00:00.000000000 Z
+date: 2012-12-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ruby-tmdb
@@ -44,13 +44,13 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.5.8
 - !ruby/object:Gem::Dependency
-  name: text
+  name: amatch
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: 0.2.10
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -58,7 +58,7 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.2.1
+        version: 0.2.10
 - !ruby/object:Gem::Dependency
   name: ruby-progressbar
   requirement: !ruby/object:Gem::Requirement
@@ -75,6 +75,22 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 1.0.2
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.12.0
 description: Organize media folders to get ready with media managers
 email:
 - pfilstroff@gmail.com
@@ -99,6 +115,8 @@ files:
 - lib/plexify/prepare.rb
 - lib/plexify/version.rb
 - plexify.gemspec
+- spec/plexify_spec.rb
+- spec/spec_helper.rb
 homepage: ''
 licenses: []
 post_install_message: 
@@ -123,4 +141,6 @@ rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
 summary: Media managers files organizer
-test_files: []
+test_files:
+- spec/plexify_spec.rb
+- spec/spec_helper.rb