plexify 0.1.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.plexify.yml

@@ -0,0 +1,4 @@
+plexify:
+    tmdb:
+        api_key: a1d640d24a78fb94c297cac5483ba31e
+        default_language: fr

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in plexify.gemspec
+gemspec
+
+gem "ruby-tmdb", ">= 0.2.1"
+gem "colorize", ">= 0.5.8"
+gem "text", ">= 1.2.1"
+gem "ruby-progressbar", ">= 1.0.2"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Pierre FILSTROFF
+
+MIT License
+
+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,31 @@
+# Plexify
+
+Currently in development. Not working yet.
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'plexify'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install plexify
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+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

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/plexify

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.dirname(__FILE__) + '/../lib'
+require "plexify"
+
+plexify = Plexify::Plexify.new(ARGV)
+plexify.run!

data/lib/plexify/execute.rb

@@ -0,0 +1,170 @@
+module Plexify
+    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] 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
+
+            private
+            # Check missing arguments
+            def check_arguments
+                return if @args.size == 2
+
+                @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]
+
+                if @missing_args.any?
+                    raise OptionParser::MissingArgument
+                end
+            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('-s [source]', '--source [source]', 'Source folder which includes media files. Temp folder.') do |source|
+                    @options[:source] = source
+                end
+
+                opts.on('-d [destination]', '--destination [dest]', 'Destination folder to put organized.') do |destination|
+                    @options[:destination] = 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('--series-destination [dest]', 'Destination folder to put organized series files.') do |series_destination|
+                    @options[:series_destination] = series_destination
+                end
+
+                opts.on_tail('-t', '--test', 'Test files name searching in media databases: only print results.') do
+                    @options[:test] = true
+                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("-?", "-h", "--help", "Show this message.") do
+                    puts opts
+                    exit
+                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
+
+            # Process result
+            def process_result
+
+                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
+                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

@@ -0,0 +1,19 @@
+module Plexify
+    # 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 errors in red
+        def self.error(content)
+            print content.colorize(:red)
+        end
+    end
+end

data/lib/plexify/media.rb

@@ -0,0 +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
+
+        def initialize(data)
+            @data = data
+        end
+    end
+end

data/lib/plexify/media_manager.rb

@@ -0,0 +1,88 @@
+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)
+
+            medias = analyse_names(splitted_name, {})
+
+            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
+
+            return flattened_medias
+        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
+
+        # 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
+
+        def analyse_names(list, medias)
+            title = String.new
+
+            list.each_with_index do |str, index|
+                title << " " if title.length > 0
+                title << str
+                media = find(title)
+
+                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
+
+        # Get Levenshtein distance
+        def levenshtein_distance(first, second)
+            Text::Levenshtein.distance(first, second)
+        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
+
+        # 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

@@ -0,0 +1,71 @@
+module Plexify
+    # 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
+
+        # 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 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)
+
+                # 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
+
+            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
+
+        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
+
+            p_bar = ProgressBar.create(:title => "Copying '#{File.basename(source_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
+        end
+    end
+end

data/lib/plexify/prepare.rb

@@ -0,0 +1,91 @@
+module Plexify
+    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
+
+            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)
+
+                # 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
+
+            # Prepare destinations
+            def prepare_destinations
+                # Create or use movies and series folders
+                movies_path = @movies_destination_path
+                series_path = @series_destination_path
+
+                @movies_folder = create_or_use_folder(movies_path) if movies_path
+                @series_folder = create_or_use_folder(series_path) if series_path
+            end
+
+            # Create or use a folder
+            def create_or_use_folder(*args)
+                path = args.first
+
+                if args.size > 1
+                    name = args[1]
+                end
+
+                folder_path = name ? File.join(path, name) : path
+
+                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
+            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
+
+                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

@@ -0,0 +1,3 @@
+module Plexify
+  VERSION = "0.1.0"
+end

data/lib/plexify.rb

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

data/plexify.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'plexify/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "plexify"
+  gem.version       = Plexify::VERSION
+  gem.authors       = ["Pierre FILSTROFF"]
+  gem.email         = ["pfilstroff@gmail.com"]
+  gem.description   = %q{Organize media folders to get ready with media managers}
+  gem.summary       = %q{Media managers files organizer}
+  gem.homepage      = ""
+
+  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)/})
+  gem.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: plexify
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Pierre FILSTROFF
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-12-03 00:00:00.000000000 Z
+dependencies: []
+description: Organize media folders to get ready with media managers
+email:
+- pfilstroff@gmail.com
+executables:
+- plexify
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .plexify.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/plexify
+- lib/plexify.rb
+- lib/plexify/execute.rb
+- lib/plexify/logger.rb
+- lib/plexify/media.rb
+- lib/plexify/media_manager.rb
+- lib/plexify/media_organizer.rb
+- lib/plexify/prepare.rb
+- lib/plexify/version.rb
+- plexify.gemspec
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Media managers files organizer
+test_files: []