movie-manager-gem 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6cbb8b1dbd1e301de10676e2b67cbc035cdc2559
+  data.tar.gz: 3b6067ea40a7292d12c7cab4f1aa9889ecf123a0
+SHA512:
+  metadata.gz: a422d226d39ec8d47ca7c1ba940fb059a7a73bba261ee8e040cc970cd306d928cdea4d5831bc193a5529a7ea38e30cdafb5f77a84f015db90801ff28b6ff78e9
+  data.tar.gz: 92de05d5652c0791b8d93bc105ad0ba11f26fc5ef480b957694345894264f7249afe76d0e0d709a6ad28e2e438ebadc35418d114a200c09b28f1a7b7857a4041

data/.gitignore

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

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 David Hamme
+
+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/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 David Hamme
+
+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,78 @@
+# MovieManagerGem
+
+DH Movie Manager is a command line tool for organizing local movie files. 
+
+DHMM finds local movie files, queies Rotten Tomatoes, and stores the data in a sqlite3 database that you can use to run commands. Search for specific actors, directors, and genres. Filter results by audience score. Update your filenames to reflect the correct title. 
+Feeling indecisive? use the 'play unseen [genre]' command to play a random movie that suits your mood.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'movie_manager_gem'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install movie_manager_gem
+
+## Usage
+
+From your home directory, simply run 'movie-manager-gem'
+That's it. 
+
+Below are a list of valid commands. Brackets [ ] indicate user input.
+
+To begin, drag and drop in the folder that holds your movies to add them to the database:
+		start [file path]
+
+Return a list of actors with the given name:
+
+		search actor [name] [rating (optional)]	
+
+Return a list of directors with the given name:
+
+		search director [name] [rating (optional)]
+
+Return a list of movies with the given genre:
+
+		search genre [genre] [rating (optional)]	
+
+Return a list of all movies with a RottenTomatoes Audience Score above [rating]:	
+
+		search movies [rating]' 											
+
+
+Play a movie with the given title:
+
+		play [title]
+
+Play a random movie that you haven't seen from the given genre:
+
+		play unseen [genre] [rating (optional)]
+
+
+User will be asked which movies they have seen. This improves the 'play unseen [genre] function:
+
+		update watched			
+
+User can choose to update movie file names with the correct titles:
+
+		update file names 	
+
+
+Tips:
+- Rating is an optional argument
+- Partial searches (eg com vs comedy) can be used
+- Searches can be multiple words (eg 'search actor Gary Oldman 60')
+
+## Contributing
+
+1. Fork it ( https://github.com/hammeiam/movie_manager_gem/fork )
+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 a new Pull Request

data/Rakefile

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

data/bin/movie-manager-gem

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+#Dir[File.join(File.dirname(__FILE__),  'lib', '*.rb')].each {|file| require file }
+
+require_relative '../lib/movie-manager-gem'
+
+session = MovieManagerGem::Finder.new
+session.update_directories_status
+
+puts "Welcome to DH Movie Manager"
+puts "Type your command, 'exit' to leave, or 'help' to get started..."
+puts ""
+puts "First time? Type 'start' and drag & drop the folder that contains your movies" if !session.initialized?
+puts "eg 'start /Users/me/Movies'" if !session.initialized?
+
+#command = []
+while true
+	print '> '
+	command = $stdin.gets.chomp.split
+
+	if command[0] == 'start'
+		session.find_files_in(command[1..-1].join.gsub("\\", " "))
+
+	elsif command[0] == 'search'
+		if command[1] == 'movies'
+			session.list_all_movies(command[2]?command[2]:-1) # sets a default value of -1 for empty rating arguments
+
+		elsif command[1] == 'actor'
+			if command[-1] =~ /[0-9]+/
+				session.list_movies_with_actor(command[2..-2].join(" "), command[-1])
+			else
+				session.list_movies_with_actor(command[2..-1].join(" "))
+			end
+		elsif command[1] == 'director'
+			if command[-1] =~ /[0-9]+/
+				session.list_movies_with_director(command[2..-2].join(" "), command[-1])
+			else
+				session.list_movies_with_director(command[2..-1].join(" "))
+			end
+		elsif command[1] == 'genre'
+			if command[-1] =~ /[0-9]+/
+				session.list_movies_by_genre(command[2..-2].join(" "), command[-1])
+			else
+				session.list_movies_by_genre(command[2..-1].join(" "))
+			end
+		end
+
+	elsif command[0] == 'play' 
+		if command[1] == 'unseen'	# distinguish btw the 'play' and 'play unseen genre' functions
+			if command[-1] =~ /[0-9]+/
+				session.play_unseen_genre(command[2..-2].join(" "), command[-1])
+			else
+				session.play_unseen_genre(command[2..-1].join(" "))
+			end
+		else
+			session.play(command[1])
+		end
+
+	elsif command[0] == 'update' 
+		if command[1] == 'watched'	# distinguish btw update watched and update file names functions
+			session.update_watched_list
+		elsif command[1] == 'file' && command[2] == 'names'
+			session.update_file_names
+		end
+
+	elsif command[0] == 'help'
+		puts ""
+		puts "--- Below are a list of valid commands. Brackets [] indicate user input. ---"
+		puts ""
+		puts "'start [file path]' drag and drop in the folder that holds your movies to add them to the database"
+		puts ""
+		puts "'search actor [name] [rating (optional)]' returns a list of actors with the given name"
+		puts "'search director [name] [rating (optional)]' returns a list of directors with the given name"
+		puts "'search genre [genre] [rating (optional)]' returns a list of movies with the given genre"
+		puts "'search movies [rating]' returns a list of all movies with a RottenTomatoes Audience Score above [rating]"
+		puts ""
+		puts "'play [title]' plays movie with the given title"
+		puts "'play unseen [genre] [rating (optional)]' plays random movie that you haven't seen from the given genre"
+		puts ""
+		puts "'update watched' user will be asked which movies they have seen. This improves the 'play unseen [genre] function."
+		puts "'update file names' user can choose to update movie file names with the correct titles"
+		puts ""
+		puts "Examples:"
+		puts "search actor Stallone 60 (note that first or last names can be used. Min movie rating is optional)"
+		puts "play finding nemo (note that names and title searches can be more than 1 word long)"
+		puts "play unseen com (note that partial searches for names and genres are allowed. This will play a comedy)" 
+		puts ""
+		puts "--- end of help ---"
+
+			
+	elsif command[0] == 'exit'
+		print 'Bye '
+		system("echo $USER!")
+		break
+
+	else
+		puts "Does not compute. Type 'help' for a list of valid commands."
+	end
+end

data/lib/movie-manager-gem.rb

@@ -0,0 +1,628 @@
+require "movie-manager-gem/version"
+
+module MovieManagerGem
+  ### DH Searcher ###
+	class Finder
+		require 'rubygems'
+		require 'rottentomatoes'
+		require 'sequel'
+		require 'thread'
+		require 'sqlite3'	# sqlite3 implementation
+		# require 'pg'	# postgres implementation
+
+		include RottenTomatoes
+
+		def initialize()
+			# input Rotentomatoes api key
+			Rotten.api_key = "9t2nx4s6bb62s8hvjftx8sx4"
+
+			# start database
+			@@DB = Sequel.sqlite('movies.db')	# sqlite3 implementation
+			# @@DB = Sequel.postgres('testdb', :host=>'localhost', :user=>'David', :password=>'password')	# postgres implementation
+
+			# create tables within database
+			create_all_tables
+
+			# tie ruby-accessible datasets to database table
+			@movies_dataset						= @@DB[:movies]
+			@movie_genre_dataset			= @@DB[:movie_genre]
+			@genres_dataset						= @@DB[:genres]
+			@directories_dataset			= @@DB[:directories]
+			@movie_actor_dataset			= @@DB[:movie_actor]
+			@actors_dataset						= @@DB[:actors]
+			@movie_director_dataset		= @@DB[:movie_director]
+			@directors_dataset				= @@DB[:directors]
+
+			# joins
+			@movie_directories_join 	= @movies_dataset.join(:directories, :id => :directory_id) # must be before other joins
+			@movie_genre_join					= @movie_directories_join.join(:movie_genre, :movie_id => :movies__id).join(:genres, :id => :genre_id)
+			@movie_actor_join					= @movie_directories_join.join(:movie_actor, :movie_id => :movies__id).join(:actors, :id => :actor_id)
+			@movie_director_join			= @movie_directories_join.join(:movie_director, :movie_id => :movies__id).join(:directors, :id => :movie_director__director_id)
+
+			# queues and threads
+			@local_movies_queue				= Queue.new
+			@processed_movies_queue		= Queue.new
+			@threads									= []
+		end
+
+	### Update and Refine Data ###
+		def initialized?
+			@movies_dataset.first
+		end
+
+		def refine_unfound_movie_titles
+				# for n in movies where original title == title
+				# puts "What should the title of #{title} be?"
+				# title = gets.chop 
+		end
+
+		def update_file_names
+			# find where movie titles =0. 0=unchecked, 1=correct
+			# for each, ask if title is correct
+			# if yes, dataset.where(:id => each[:id]).update(:correct_filename => 1)
+		  # else
+		  incorrect_names = @movies_dataset.select(:id, :original_title, :title).where(:correct_filename => 0).all
+		  incorrect_names.each do |name|
+		  	puts "Is \"#{name[:title]}\" the correct title for \"#{File.basename(name[:original_title],".*")}\"? \n y/n"
+		  	print '> '
+		  	response = $stdin.gets.chomp.downcase
+				#name[:id] == basename(name[:original_title],".*")
+				case response
+				when 'y','yes'
+					new_title = File.dirname(name[:original_title]) + '/' + name[:title].gsub(/[\.|\_]/," ").gsub(/[\/|:]/,"-") + File.extname(name[:original_title])
+					File.rename(name[:original_title], new_title) #this is also in normalize
+					# mac replaces ':' with '/', this is a problem
+					# directories get confused when a movie title has a '/' in it
+					@movies_dataset.where(:id => name[:id]).update(:correct_filename => 1, :original_title => new_title)
+					puts "File updated"
+				when 'n', 'no'
+					# incorrect title, must refine, replace our RT search records
+					@movies_dataset.where(:id => name[:id]).update(:correct_filename => -1)
+					puts "crap, sorry..."
+				when 'end','exit'
+					break
+				else
+					puts "Respond with 'y' or 'n'"
+					# you'll have to run the command again to continue
+				end
+			end
+
+			# http://sequel.jeremyevans.net/rdoc/files/doc/cheat_sheet_rdoc.html#label-Update%2FDelete+rows
+			# be sure to bake in http://www.ruby-doc.org/core-2.1.2/File.html#method-c-rename
+			#File.rename(old,new)
+			#File.extname(file) gets extension
+			#File.dirname(file)
+			# change db record, change filename
+		end
+
+		def find_files_in(path) # works
+			# should there be a default path? Path to this Dir.
+			Dir.chdir(path) do
+				enqueue_local_movies
+				add_all_movies_to_table
+				update_directories_status
+			end
+		end
+
+		def update_watched_list # works
+			@movies_dataset.where(:watched => -1).all.each do |movie|
+				puts "Have you seen #{movie[:title]}? Y/N or end"
+				print '> '
+				response = $stdin.gets.chomp.downcase
+				case response
+				when 'y', 'yes'
+					update_watched_status(movie[:title],1)
+					puts 'Record updated'
+				when 'n', 'no'
+					update_watched_status(movie[:title],0)
+					puts 'Record updated'
+				when 'end'
+					break
+				else
+					puts 'I didn\'t catch that..'
+					update_watched_list
+				end
+			end
+		end
+
+	### List and Play Movies ###
+		def list_all_movies(min_score=-1) # works
+			movie_list = @movie_director_join.where({:available => 1}, (Sequel.expr(:audience_score) >= min_score)).group(:movies__id).order(:title).all # sqlite3 impementation
+			# movie_list = @movie_directories_join.order(:title).distinct(:movies__id,:title).where({:available => 1}, (Sequel.expr(:audience_score) >= min_score)).all? # postgres implementation
+
+			if movie_list.empty?
+				puts "Sorry, we don\'t have any movies with a score higher than #{min_score}"
+			else
+				puts "--- Movies Rated Higher Than #{min_score} ---"
+				movie_list.each{ |movie| puts movie[:title]} 
+			end
+		end
+
+		def list_movies_with_director(director, min_score = -1) # works
+			results_list = @directors_dataset.where(Sequel.ilike(:name, '%'+director+'%')).all
+			if results_list.length > 1
+				temp = []
+				results_list.each {|result| temp << result[:name]}
+				puts "Here are the results for '#{director}'. Please enter the number of the one you want."
+				temp.each_with_index do |name,i| 
+					puts "#{i+1}: #{name}"
+				end
+				print '> '
+				director_name = temp[$stdin.gets.chomp.to_i - 1]
+
+			elsif results_list.length == 1
+				director_name = results_list[0][:name]
+
+			else
+				puts "Sorry, we couldn't find a director named '#{director}'. Here are the directors we have:"
+				@directors_dataset.select(:name).order(:name).all.each {|director| puts '- ' + director[:name]}
+				return
+			end
+			movie_list = @movie_director_join.where({:name => director_name}, {:available => 1},  (Sequel.expr(:audience_score) >= min_score)).group(:movies__id).order(:title).all  # sqlite3 implementation
+			#movie_list = @movie_director_join.order(:title).distinct(:movies__id,:title).where({:name => director_name} & {:available => 1} & (Sequel.expr(:audience_score) >= min_score)).all  # postgres implementation
+
+			if movie_list.empty?
+				puts "Sorry, we don\'t have any movies directed by \'#{director_name}\'."
+			else
+				puts "--- Movies directed by '#{director_name}' ---"
+				movie_list.each{ |movie| puts movie[:title]} 	
+			end
+		end
+
+		def list_movies_with_actor(actor, min_score = -1) # works
+			results_list = @actors_dataset.where(Sequel.ilike(:name, '%'+actor+'%')).all
+
+			if results_list.length > 1
+				temp = []
+				results_list.each {|result| temp << result[:name]}
+				puts "Here are the results for '#{actor}'. Please enter the number of the one you want."
+				temp.each_with_index do |name,i| 
+					puts "#{i+1}: #{name}"
+				end
+				print '> '
+				actor_name = temp[$stdin.gets.chomp.to_i - 1]
+
+			elsif results_list.length == 1
+				actor_name = results_list[0][:name]
+
+			else
+				puts "Sorry, we couldn't find an actor named '#{actor}'. Here are the actors we have:"
+				@actors_dataset.select(:name).order(:name).all.each {|actor| puts '- ' + actor[:name]}
+				return
+			end
+			movie_list = @movie_actor_join.where({:name => actor_name}, {:available => 1}, (Sequel.expr(:audience_score) >= min_score)).group(:movies__id).order(:title).all  # sqlite3 implementation
+			# movie_list = @movie_actor_join.order(:title).distinct(:movies__id,:title).where({:name => actor_name}, {:available => 1}, (Sequel.expr(:audience_score) >= min_score)).all  # postgres implementation
+
+			if movie_list.empty?
+				puts "Sorry, we don\'t have any movies starring \'#{actor_name}\'."
+			else
+				puts "--- Movies starring '#{actor_name}' ---"
+				movie_list.each{ |movie| puts movie[:title]} 	
+			end
+		end
+
+		def list_movies_by_genre(genre, min_score = -1) # works
+			movie_list = @movie_genre_join.where(Sequel.ilike(:genre, '%'+genre+'%') & {:available => 1} & (Sequel.expr(:audience_score) >= min_score)).group(:movies__id).order(:title).all  # sqlite3 implementation
+			# movie_list = @movie_genre_join.order(:title).distinct(:movies__id,:title).where(Sequel.ilike(:genre, '%'+genre+'%') & {:available => 1} & (Sequel.expr(:audience_score) >= min_score)).all # postgres implementation
+
+			if movie_list.empty?
+				puts 'Sorry, we don\'t have that genre. Please enter one from the list:'
+				@genres_dataset.select(:genre).order(:genre).all.each {|genre| puts '- ' + genre[:genre]}
+			else
+				search_genre = movie_list.first[:genre]
+				puts "--- Movies with genre '#{search_genre}' ---"
+				movie_list.each{ |movie| puts movie[:title]} 
+			end
+		end
+
+		def play_unseen_genre(genre, min_score = -1) # works
+			movie_genre_list = @movie_genre_join.where(Sequel.ilike(:genre, '%'+genre+'%') & {:available => 1} & (Sequel.expr(:audience_score) >= min_score)).group(:movies__id).all  # sqlite3 implementation
+			# movie_genre_list = @movie_genre_join.order(:title).distinct(:movies__id,:title).where(Sequel.ilike(:genre, '%'+genre+'%') & {:available => 1} & (Sequel.expr(:audience_score) >= min_score)).all  # postgres implementation
+			if movie_genre_list.empty?
+				puts "Sorry, we don\'t have any movies with the genre #{genre}."
+				# this exception doesn't reveal if there are no movies of that genre above the minimum score
+			else
+				unwatched_list = movie_genre_list.select{|movie| movie[:watched] != 1}
+				if unwatched_list.empty?
+					puts "Sorry, you\'ve seen all of your #{genre} movies"
+				else
+					movie_title = unwatched_list.sample[:title]
+					play(movie_title,false)
+				end
+			end		
+		end
+
+		def play(movie_title, user_input=true) # works
+			# does a search for the title if a user input it. opens the exact file if another function provided the name
+			if user_input
+				movie_to_play = @movie_directories_join.where(Sequel.ilike(:title, '%'+movie_title+'%'), :available => 1).group(:movies__id).first  # sqlite3 implementation
+				# movie_to_play = @movie_directories_join.order(:title).distinct(:movies__id,:title).where(Sequel.ilike(:title, '%'+movie_title+'%'), :available => 1).first  # postgres implementation
+			else
+				movie_to_play = @movies_dataset.where(:title => movie_title).first
+			end
+
+			if movie_to_play 
+				puts "Play #{movie_to_play[:title]}? Y/N"
+				print '> '
+				response = $stdin.gets.chomp.downcase
+				case response
+				when 'y', 'yes'
+					update_watched_status(movie_to_play[:title],1)
+					system("open \"#{movie_to_play[:original_title]}\"")	# unix needs double quotes around file names with spaces
+				when 'n', 'no'
+					puts 'Okay...'
+				else
+					puts 'Speak English, man!'
+					play(movie_title)
+				end
+			else
+				puts "No movie named '#{movie_title}' found, try a different search"
+			end
+		end
+
+	### Movie-handling fuctions ###
+
+		def enqueue_local_movies 	# works
+			movies_glob = Dir.glob('**/*.{mkv,MKV,avi,AVI,mp4,MP4,mpg,MPG,mov,MOV}').uniq
+			movies_glob.each {|movie| @local_movies_queue << [File.absolute_path(movie), normalize_title(movie), nil]}
+			#movies.select!{|movie| File.size(movie) > 600_000_000} # works
+		end
+
+		def normalize_title(title) # works
+			# output should seperate path, suffix. Change periods and underscores to spaces. Possibly change / to : 
+			File.basename(title,'.*').gsub(/[\.|\_]/," ").gsub(/[\/|:]/,"-")
+		end
+
+		def update_directories_status # works 
+			@directories_dataset.select(:directory_path).all.each do |dir|
+				if Dir.exists?(dir[:directory_path])
+					@directories_dataset.where(:directory_path => dir[:directory_path]).update(:available => 1)
+				else
+					@directories_dataset.where(:directory_path => dir[:directory_path]).update(:available => 0)
+				end
+			end
+		end
+
+		def update_watched_status(movie_title, status)	# works. 
+			@movies_dataset.where(:title => movie_title).update(:watched => status)
+		end
+
+		def add_all_movies_to_table	# works # add func to auto-find/add new movies. may need to rework enqueue_local_movies to output array
+			# RottenTomatoes' API seems to error at >3 threads
+			2.times do
+				# this code was supplied by Theo on SO
+				# http://stackoverflow.com/questions/6558828/thread-and-queue
+				@threads << Thread.new do
+					until @local_movies_queue.empty?
+						long_name, clean_name, data = @local_movies_queue.pop(true) rescue nil
+						if long_name
+							if movies_record_exists?(long_name)
+								movie_title = @movies_dataset.select(:title).where(:original_title => long_name).first[:title]
+								puts "#{movie_title} record already exists"
+							else
+								data = get_rt_movie_info(clean_name)
+								@processed_movies_queue << [long_name, clean_name, data]
+								add_movie(@processed_movies_queue.pop)
+							end
+						end
+					end
+				end
+			end
+			@threads.each { |t| t.join } 
+		end
+
+		def add_movie((long_name, clean_name, data)) # works
+			if data
+
+				# Add Directories to directories_dataset
+				@directories_dataset.insert(:directory_path =>  File.dirname(long_name)) unless directories_record_exists?(File.dirname(long_name))
+
+				# Add Movie to movies_dataset
+				@movies_dataset.insert( :original_title => long_name, 
+					:title => data.title,
+					:critic_score => data.ratings.critics_score,
+					:audience_score => data.ratings.audience_score,
+					:date_added => Time.new(),
+					:directory_id => @directories_dataset.select(:id).where(:directory_path => File.dirname(long_name)).first[:id])
+
+				movie_id = @movies_dataset.select(:id).where(:title => data.title).first[:id]
+
+				# Add Actors to actors_dataset and movie_actor_dataset
+				data.abridged_cast.each do |actor| 
+					@actors_dataset.insert(:name => actor[:name]) unless actors_record_exists?(actor[:name]) # used to be :name => actor.name. Make sure this works online!
+					@movie_actor_dataset.insert(:movie_id => movie_id,
+						:actor_id => @actors_dataset.select(:id).where(:name => actor[:name]).first[:id])
+				end if data.abridged_cast
+
+				# Add Genres to genres_dataset and movie_genre_dataset
+				data.genres.each do |genre| 
+					@genres_dataset.insert(:genre => genre) unless genres_record_exists?(genre)
+					@movie_genre_dataset.insert(:movie_id => movie_id,
+						:genre_id => @genres_dataset.select(:id).where(:genre => genre).first[:id])
+				end if data.genres
+
+				# Add Directors to directors_dataset and movie_director_dataset 
+				data.abridged_directors.each do |director|   
+					@directors_dataset.insert(:name => director[:name]) unless directors_record_exists?(director[:name])
+					@movie_director_dataset.insert(:movie_id => movie_id,
+						:director_id => @directors_dataset.select(:id).where(:name => director[:name]).first[:id])
+				end if data.abridged_directors
+
+				puts "#{data.title} added to table" 
+
+			else
+				@movies_dataset.insert(:original_title => long_name, :title => clean_name, :date_added => Time.new())
+				puts "#{clean_name} added to table"
+			end
+		end
+
+		def get_rt_movie_info(clean_name) # works
+			# with internet
+			begin
+				output = RottenMovie.find(:title => clean_name, :expand_results => true, :limit => 1)	# hits RT once to get general movie info
+				sleep 1
+				output = RottenMovie.find(:id => output.id)	if output.class == PatchedOpenStruct # hits RT a second time with id# to get most detailed info :(
+			rescue		# addresses the occasional crash that RT limits plus our volume of calls can bring on.
+				sleep 1
+				output = RottenMovie.find(:title => clean_name, :expand_results => true, :limit => 1)	# hits RT once to get general movie info
+				sleep 1
+				output = RottenMovie.find(:id => output.id)	if output.class == PatchedOpenStruct # hits RT a second time with id# to get most detailed info :(
+			end			
+			return output if output.class == PatchedOpenStruct
+			return nil
+
+			# without internet (local offline testing)
+			# output = FakeMovie.new(clean_name)
+			# return output
+		end
+
+
+	### Exists? ###
+	def movies_record_exists?(original)	
+		return false if @movies_dataset.select(:id).where(:original_title => original).all.length == 0 
+		return true
+	end
+
+	def actors_record_exists?(name)	
+		return false if @actors_dataset.select(:id).where(:name => name).all.length == 0 
+		return true
+	end
+
+	def directors_record_exists?(name)	
+		return false if @directors_dataset.select(:id).where(:name => name).all.length == 0 
+		return true
+	end
+
+	def genres_record_exists?(genre)
+		return false if @genres_dataset.select(:id).where(:genre => genre).all.length == 0 
+		return true
+	end
+
+	def directories_record_exists?(path)
+		return false if @directories_dataset.select(:directory_path).where(:directory_path => path).all.length == 0 
+		return true
+	end
+
+	### Tables & DBs ###
+	def create_all_tables
+		create_directories_table 	unless @@DB.table_exists?(:directories)
+
+		create_movies_table 		unless @@DB.table_exists?(:movies)
+
+		create_genres_table 		unless @@DB.table_exists?(:genres)
+		create_movie_genre_table 	unless @@DB.table_exists?(:movie_genre)
+
+		create_actors_table 		unless @@DB.table_exists?(:actors)
+		create_movie_actor_table 	unless @@DB.table_exists?(:movie_actor)
+
+		create_directors_table 		unless @@DB.table_exists?(:directors)
+		create_movie_director_table unless @@DB.table_exists?(:movie_director)
+	end
+
+	def create_movies_table
+		if @@DB.table_exists?(:movies)
+			raise StandardError, 'Movies table already exists, try a different name'	
+		else
+			@@DB.create_table :movies do
+				primary_key :id
+				String  	:original_title
+				String  	:title
+				  Integer	:critic_score, 		:default => -1 	#1-100
+				  Integer	:audience_score, 	:default => -1 	#1-100
+				  Integer 	:my_score, 			:default => -1 	#1-100
+				  Integer 	:correct_filename, 	:default => 0  	#0/no, 1/yes
+				  Integer 	:watched, 			:default => -1 	#-1/unknown, 0/no, 1/yes
+				  String  	:date_added
+				  Integer 	:directory_id 
+				end 
+			end
+		end
+
+		def create_directories_table
+			if @@DB.table_exists?(:directories)
+				raise StandardError, 'Directories table already exists, try a different name'	
+			else
+				@@DB.create_table :directories do
+					primary_key :id
+					String :directory_path
+					Integer :available, 		:default => 1
+				end 
+			end
+		end
+
+		def create_genres_table
+			if @@DB.table_exists?(:genres)
+				raise StandardError, 'Genres table already exists, try a different name'	
+			else
+				@@DB.create_table :genres do
+					primary_key :id
+					String :genre
+				end
+			end
+		end
+
+		def create_movie_genre_table
+			if @@DB.table_exists?(:movie_genre)
+				raise StandardError, 'Movie_Genre table already exists, try a different name'	
+			else
+				@@DB.create_table :movie_genre do
+					primary_key :id
+					Integer :movie_id
+					Integer :genre_id
+				end
+			end
+		end
+
+		def create_actors_table
+			if @@DB.table_exists?(:actors)
+				raise StandardError, 'Actors table already exists, try a different name'	
+			else
+				@@DB.create_table :actors do
+					primary_key :id
+					String :name
+				end
+			end
+		end
+
+		def create_movie_actor_table
+			if @@DB.table_exists?(:movie_actor)
+				raise StandardError, 'Movie_Actor table already exists, try a different name'	
+			else
+				@@DB.create_table :movie_actor do
+					primary_key :id
+					Integer :movie_id
+					Integer :actor_id
+				end
+			end
+		end
+
+		def create_directors_table 
+			if @@DB.table_exists?(:directors)
+				raise StandardError, 'Directors table already exists, try a different name'	
+			else
+				@@DB.create_table :directors do
+					primary_key :id
+					String :name
+				end
+			end
+		end
+
+		def create_movie_director_table
+			if @@DB.table_exists?(:movie_director)
+				raise StandardError, 'Movie_Director table already exists, try a different name'	
+			else
+				@@DB.create_table :movie_director do
+					primary_key :id
+					Integer :movie_id
+					Integer :director_id
+				end
+			end
+		end
+
+		def drop_table(table_name = table_name.to_sym)
+			if @@DB.table_exists?(table_name)
+				puts "Are you sure you want to drop table \'#{table_name}\'? Y/N"
+				response = 1000.chomp.downcase
+
+				case response
+				when 'y', 'yes'
+					@@DB.drop_table(table_name)
+					puts 'Table dropped'
+				when 'n', 'no'
+					puts 'Table not dropped'
+				else
+					puts 'Reply with Y or N'
+					drop_table(table_name)
+				end
+			else
+				raise StandardError, 'Table doesn\'t exist'
+			end
+		end
+	end
+
+	class FakeMovie 	# works
+		# returns results when testing offline
+		attr_reader :title, :ratings, :critics_score, :audience_score, :my_score, :genres, :abridged_directors, :abridged_cast, :correct_filename, :watched, :name
+		def initialize(movie_title)
+			sleep 2 # you have to wait for RT, you have to wait for me!
+
+			@random							= Random.new
+			@title 							= movie_title.upcase
+			@my_score 					= @random.rand(100)+1
+			@genres 						= %w(Comedy Documentary Drama Horror Western XXX).sample(@random.rand(3)+1)
+			@correct_filename 	= @random.rand(2)
+			@watched 						= @random.rand(2)
+
+			# cast & director names
+			@first 							= %w(Abe Bob Carl Dolf Earl)
+			@last 							= %w(Buler Crabtree Daniels McDonald)
+
+			# ratings
+			@critics_score 			= 101
+			@audience_score 		= 101
+		end
+
+		def ratings
+			return self
+		end
+
+		def abridged_cast
+			out = []
+			(@random.rand(5)+1).times do
+				out << {name: @first.sample + ' ' + @last.sample }
+			end
+			return out
+		end
+
+		def abridged_directors
+			out = []
+			(@random.rand(3)+1).times do
+				out << {name: 'Director ' + @last.sample }
+			end
+			return out
+		end
+	end
+
+#### TO DO: ####
+#
+# some directories are listed as NULL. Find out why and fix it.
+#
+# X add directories DB
+# X - add "directory present?" column to movies DB 0/1
+# X - add "directory_present?" function to update dir status, runs on initialization. We assume no devices are being removed within a session.
+# X - add "directory_present => 1" to all existing searches
+#
+# X update add_all_movies_to_table. Auto-find/add new movies. 
+#
+# X if RT call fails, restart and continue. 
+#
+# X add ARGV for command line input, woo! Look into Thor to help list commands
+#
+# X Let user specify directory root. use Dir.chdir(new_dir). Volume can be dragged and dropped in. request on init.
+#
+# X func search by actor/director 
+# X improve act/dir search with last name refinement
+#
+# Look into using Find instead of Dir.glob to allow the user to exclude some folders. 
+# http://ruby-doc.org/stdlib-1.9.3/libdoc/find/rdoc/Find.html
+# can maybe also use reject on glob
+# http://stackoverflow.com/questions/4505566/is-there-a-way-to-glob-a-directory-in-ruby-but-exclude-certain-directories
+#
+# X func is x the correct name? y/n
+#
+# swtich back to sqlite3 to make this a one click startup.
+#
+# X create a setup command. if db is empty, spcify a dir to look in, add movies, update dirs. 
+#
+# X consider filtering actor/dir results if dir is unattached
+# consider tracking play count rather than having it be binary
+# consider making better use of the directory & origial movie name combo. feels redundant. 
+#
+# X func update file names to reflect correct titles. Will need to be unix-safe
+# http://superuser.com/questions/358855/what-characters-are-safe-in-cross-platform-file-names-for-linux-windows-and-os
+# 
+# put on the web.
+# Add filetypes. 
+# How to deal with file being renamed by user?
+# Look at 'index on expressions'
+end

data/lib/movie-manager-gem/version.rb

@@ -0,0 +1,3 @@
+module MovieManagerGem
+      VERSION = "0.0.1"
+end

data/movie-manager-gem.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'movie-manager-gem/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "movie-manager-gem"
+  spec.version       = MovieManagerGem::VERSION
+  spec.authors       = ["David Hamme"]
+  spec.email         = ["dhamme@gmail.com"]
+  spec.summary       = %q{A command line tool for organizing local movie files. }
+  spec.description   = %q{DH Movie Manager finds local movie files, queries Rotten Tomatoes, and stores the data in a sqlite3 database that you can use to run commands. Search for specific actors, directors, and genres. Filter results by audience score. Update your filenames to reflect the correct title. 
+Feeling indecisive? use the 'play unseen [genre]' command to play a random movie that suits your mood.}
+  spec.homepage      = "https://github.com/hammeiam/movie-manager-gem"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency "rottentomatoes"
+  spec.add_dependency "sequel"
+  spec.add_dependency "thread"
+  spec.add_dependency "sqlite3"
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: movie-manager-gem
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- David Hamme
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rottentomatoes
+  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: sequel
+  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: thread
+  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: sqlite3
+  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'
+description: "DH Movie Manager finds local movie files, queries Rotten Tomatoes, and
+  stores the data in a sqlite3 database that you can use to run commands. Search for
+  specific actors, directors, and genres. Filter results by audience score. Update
+  your filenames to reflect the correct title. \nFeeling indecisive? use the 'play
+  unseen [genre]' command to play a random movie that suits your mood."
+email:
+- dhamme@gmail.com
+executables:
+- movie-manager-gem
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/movie-manager-gem
+- lib/movie-manager-gem.rb
+- lib/movie-manager-gem/version.rb
+- movie-manager-gem.gemspec
+- movies.db
+homepage: https://github.com/hammeiam/movie-manager-gem
+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.1.9
+signing_key: 
+specification_version: 4
+summary: A command line tool for organizing local movie files.
+test_files: []