movier 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1e14e4ce7fa47a7540508730f642030474a8c000
-  data.tar.gz: a259177d845f25aeed6c19de3b2a8a4764563a88
+  metadata.gz: af01724f8aee1a5789dc504d4e15af1aef675b84
+  data.tar.gz: 7635c03202e6ea156369c73229e8367bf64494eb
 SHA512:
-  metadata.gz: e7af2d17325877a58ddfe689ca02c0f1654626c52242d2f3028ae62a77df7ee37c399dfe6d68bb2d796b1dab4ea6e03707465396d51226a7919ee0b15f201b46
-  data.tar.gz: 8e88d837cc42e4ccff70e29be1380fc75f1be23366822a974b53eb4d375b01b688873aa31f8b9bcbf4ee576f0dfafbf645b34d8edfa9c7ab8dc644678aaf16ce
+  metadata.gz: 85b89a53bdd233dd18be3e352708d70629e44823e0b2b3cc0e83e7fbc0e4a5abb864df5b273594b778cff87acb05bb44d81934634e26aa454cda8244d1aecd7f
+  data.tar.gz: bbaf57f751f896609a9365fd2dc12a94eb57eadf33e847332765322a7453b08a69c4384d4735a6da51a01ef971bda6d9d69f5e047f1684d65afe2bf57a8ffda0

data/.gitignore

@@ -0,0 +1,3 @@
+.rvmrc
+Gemfile.lock
+pkg/

data/Gemfile

@@ -0,0 +1,2 @@
+source 'https://rubygems.org'
+gemspec

data/Rakefile

@@ -0,0 +1,44 @@
+require 'rake/clean'
+require 'rubygems'
+require 'rubygems/package_task'
+require 'rdoc/task'
+require 'cucumber'
+require 'cucumber/rake/task'
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_files.include("README.rdoc","lib/**/*.rb","bin/**/*")
+  rd.title = 'Your application title'
+end
+
+spec = eval(File.read('movier.gemspec'))
+
+Gem::PackageTask.new(spec) do |pkg|
+end
+CUKE_RESULTS = 'results.html'
+CLEAN << CUKE_RESULTS
+desc 'Run features'
+Cucumber::Rake::Task.new(:features) do |t|
+  opts = "features --format html -o #{CUKE_RESULTS} --format progress -x"
+  opts += " --tags #{ENV['TAGS']}" if ENV['TAGS']
+  t.cucumber_opts =  opts
+  t.fork = false
+end
+
+desc 'Run features tagged as work-in-progress (@wip)'
+Cucumber::Rake::Task.new('features:wip') do |t|
+  tag_opts = ' --tags ~@pending'
+  tag_opts = ' --tags @wip'
+  t.cucumber_opts = "features --format html -o #{CUKE_RESULTS} --format pretty -x -s#{tag_opts}"
+  t.fork = false
+end
+
+task :cucumber => :features
+task 'cucumber:wip' => 'features:wip'
+task :wip => 'features:wip'
+require 'rake/testtask'
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+end
+
+task :default => [:test,:features]

data/features/movier.feature

@@ -0,0 +1,8 @@
+Feature: My bootstrapped app kinda works
+  In order to get going on coding my awesome app
+  I want to have aruba and cucumber setup
+  So I don't have to do it myself
+
+  Scenario: App just runs
+    When I get help for "movier"
+    Then the exit status should be 0

data/features/step_definitions/movier_steps.rb

@@ -0,0 +1,6 @@
+When /^I get help for "([^"]*)"$/ do |app_name|
+  @app_name = app_name
+  step %(I run `#{app_name} help`)
+end
+
+# Add more step definitions here

data/features/support/env.rb

@@ -0,0 +1,15 @@
+require 'aruba/cucumber'
+
+ENV['PATH'] = "#{File.expand_path(File.dirname(__FILE__) + '/../../bin')}#{File::PATH_SEPARATOR}#{ENV['PATH']}"
+LIB_DIR = File.join(File.expand_path(File.dirname(__FILE__)),'..','..','lib')
+
+Before do
+  # Using "announce" causes massive warnings on 1.9.2
+  @puts = true
+  @original_rubylib = ENV['RUBYLIB']
+  ENV['RUBYLIB'] = LIB_DIR + File::PATH_SEPARATOR + ENV['RUBYLIB'].to_s
+end
+
+After do
+  ENV['RUBYLIB'] = @original_rubylib
+end

data/lib/movier/api.rb

@@ -0,0 +1,56 @@
+module Movier
+
+  # Fetch information about a movie from IMDB.com
+  #
+  # * *Args*    :
+  #   - +id+ -> IMDB.com id for the movie
+  # * *Returns* :
+  #   - hash of movie information
+  # * *Raises* :
+  #   - +RuntimeError+ -> error that occurred when making a request to the API
+  #
+  def self.fetch_details(id)
+    response           = omdbapi({ i: id })
+    response["votes"]  = response["imdbVotes"].delete(",").to_i
+    response["rating"] = response["imdbRating"].to_f
+    response["weight"] = response["votes"] * response["rating"]
+    response
+  end
+
+  # Search for a title on IMDB.com
+  #
+  # * *Args*    :
+  #   - +keyword+ -> keywords to search with
+  #   - +year+ -> (optional) year in which the title was released
+  #   - +type+ -> (default: movie) type of the title to return
+  # * *Returns* :
+  #   - hash with the information about movie titles found
+  # * *Raises* :
+  #   - +RuntimeError+ -> error that occurred when making a request to the API
+  #
+  def self.search(keyword, year = nil, type = "Movie")
+    response = omdbapi({ s: keyword })["Search"]
+    response = response.select{ |m| m["Type"].downcase == type.downcase } unless type.downcase == "all"
+    response = response.select{ |m| m["Year"] == year } if year
+    response
+  end
+
+  # Make a request to OMDBApi.com
+  #
+  # * *Args*    :
+  #   - +params+ -> hash of params to pass with this request
+  # * *Returns* :
+  #   - hash of response received
+  # * *Raises* :
+  #   - +RuntimeError+ -> error that occurred when making a request to the API
+  #
+  def self.omdbapi(params)
+    query = ""; params.each { |k, v| query += "#{k}=#{v}" }
+    response = HTTParty.get("http://omdbapi.com/?#{URI::encode(query)}")
+    failed_with response.response unless response.success?
+    response = JSON.parse(response.parsed_response)
+    failed_with response["Error"] if response["Error"]
+    response
+  end
+
+end

data/lib/movier/helpers.rb

@@ -0,0 +1,69 @@
+module Movier
+
+  # ask a user for a directory path, until we find one
+  #
+  # * *Args*    :
+  #   - +message+ -> question to show to the user
+  # * *Returns* :
+  #   - path to the provided directory
+  #
+  def self.ask_for_directory(message = nil)
+    message ||= "Please, provide a directory path to use. "
+    dir = nil
+    until dir && File.directory?(dir)
+      warn_with "Found no such directory!" if dir
+      dir = ask(message) { |x| x.default = ENV['HOME'] }
+    end
+    dir
+  end
+
+  # colorize output based on a movie's rating
+  #
+  # * *Args*    :
+  #   - +status+ -> status for this message
+  #   - +message+ -> actual message
+  #   - +rating+ -> rating for this movie
+  #
+  def self.say_rated(status, message, rating, do_break = false)
+    rating = rating.to_f
+    scheme = :below6 if rating < 6
+    scheme = :above6 if rating >= 6
+    scheme = :above8 if rating >= 8
+    say_with_status status, message, scheme, do_break
+  end
+
+  # titleize a string
+  #
+  # * *Args*    :
+  #   - +string+ -> string that will be titleized
+  # * *Returns* :
+  #   - titleized string
+  #
+  def self.titleize(string)
+    string.gsub(/\w+/) { |word| word.capitalize }
+  end
+
+  # find the imdb.txt file for a given movie path
+  # this file is created by Movier, once the movie has been parsed
+  #
+  # * *Args*    :
+  #   - +movie_path+ -> path to the movie being checked
+  # * *Returns* :
+  #   - path to the imdb.txt file for the given movie path
+  #
+  def self.imdb_file_for(movie_path)
+    File.join(Filename.dirname(movie_path), "imdb.txt")
+  end
+
+  # check whether the movie with given path has already been organized
+  #
+  # * *Args*    :
+  #   - +movie_path+ -> path to the movie being checked
+  # * *Returns* :
+  #   - true, if the movie has been organized. false, otherwise
+  #
+  def self.organized?(movie_path)
+    File.exists?(imdb_file_for(movie_path))
+  end
+
+end

data/lib/movier/info.rb

@@ -0,0 +1,32 @@
+module Movier
+  # Find and return information about a movie with the given keywords
+  #
+  # * *Args*    :
+  #   - +keyword+ -> keywords to search for in movie title
+  #   - +options+ -> hash that alters the behavior of the search
+  #                  if +:year+ key is specified, restricts search to that year
+  #                  if +:detailed+ key is specified, shows detailed results
+  def self.info(keyword, options)
+    lmdb = Movier::LMDB.new
+    movies = search(keyword, options[:year], options[:all] ? "all" : "movie")
+    movies.each do |m|
+      m = fetch_details m["imdbID"]
+      nice_name = m["Title"] + " [" + m["Year"] + "]"
+      next if m["votes"] < 1000 && !options[:all]
+      if options[:detailed]
+        tip_now nice_name, titleize(m["Type"])
+        rating = "#{m["Rated"]} at #{m["imdbRating"]} points with #{m["imdbVotes"]} votes"
+        say_rated "Rating", rating, m["rating"]
+        say_rated "Plot", m["Plot"], m["rating"], true
+        say_rated "Actors", m["Actors"], m["rating"], true
+        say_rated "Runtime", m["Runtime"], m["rating"]
+        say_rated "Genre", m["Genre"], m["rating"]
+        puts
+      else
+        message = "#{nice_name} @ #{m["imdbRating"]} ( #{m["imdbVotes"]} votes )"
+        type = lmdb.lookup(m["imdbID"]) ? "Available Movie" : "Movie"
+        say_rated titleize(type), message, m["rating"]
+      end
+    end
+  end
+end

data/lib/movier/lmdb.rb

@@ -0,0 +1,248 @@
+module Movier
+  class LMDB
+    DataFolder = File.join(ENV['HOME'], ".movier")
+    DataFile = File.join(DataFolder, "data.yaml")
+
+    attr_reader :movies, :boxes
+
+    def initialize
+      FileUtils.mkdir_p DataFolder
+      FileUtils.touch DataFile unless File.exists?(DataFile)
+      read_data
+    end
+
+    def read_data
+      data    = Movier.read_yaml(DataFile)
+      @boxes  = data ? data[:boxes]  : []
+      @movies = data ? data[:movies] : []
+    end
+
+    def write_data(movies = nil, boxes = nil)
+      boxes ||= @boxes; movies ||= @movies;
+      data = { boxes: boxes, movies: movies }
+      Movier.write_yaml DataFile, data
+      read_data
+    end
+
+    def find_persons(kind = :actors)
+      invalid_kind = @movies.first && !@movies.first.has_key?(kind.to_sym)
+      raise "I don't have any info about #{Movier.titleize(kind.to_s)}" if invalid_kind
+      persons = @params[kind.to_sym]
+      if persons
+        persons.split(",").each do |person|
+          @movies.select!{ |movie| movie[kind.to_sym].join(", ").downcase.include? person.downcase.strip}
+        end
+      end
+    end
+
+    def genre
+      genre = [ "Action", "Adventure", "Animation", "Biography", "Comedy",
+                "Crime", "Documentary", "Drama", "Family", "Fantasy",
+                "Film-Noir", "Game-Show", "History", "Horror", "Music",
+                "Musical", "Mystery", "News", "Reality-TV", "Romance",
+                "Sci-Fi", "Sport", "Talk-Show", "Thriller", "War", "Western" ]
+      Movier.tip_now "Listing all IMDB.com defined genre"
+      puts " " * 20 + "=" * 20
+      genre.each_slice(6) do |g|
+        puts " "*20 + g.join(", ")
+      end
+
+    end
+
+    def lookup(id)
+      @movies.each do |movie|
+        return movie if movie[:id] == id
+      end
+      false
+    end
+
+    def find(params)
+      read_data; @params = params; @params[:verbose] = true if @params[:shuffle]
+      raise "Please, add some movie boxes, before searching in the local movie database" unless @movies.any?
+
+      @movies.select!{|movie| movie[:title].downcase.include? @params[:keywords].downcase} if @params[:keywords]
+      [:directors, :writers, :actors, :genre, :tags].each { |kind| find_persons(kind) }
+      @movies.select!{|movie| movie[:rated] == @params[:rated] } if @params[:rated]
+      @movies.select!{|movie| movie[:rating] >= @params[:points].to_f } if @params[:points]
+
+      # filter on tag exclusion
+      tags = @params[:exclude_tags]
+      if tags
+        tags.split(",").each do |tag|
+          @movies.reject!{ |movie| movie[:tags].join(", ").downcase.include? tag.downcase.strip}
+        end
+      end
+      @movies.reject!{|movie| movie[:tags].join(", ").downcase.include? "watched"} unless @params[:tags] &&
+        @params[:tags].include?("watched")
+
+      sort_movies
+      @movies = @movies.slice(0, @params[:limit].to_i) if @params[:limit].to_i > 0
+      @movies = [ @movies.shuffle.first ] if @params[:shuffle]
+
+      counter = 1
+      @movies.each do |movie|
+        nice_name = "#{movie[:title]} [#{movie[:year]}]"
+        if @params[:verbose]
+          Movier.tip_now "%03d" % counter + ") " + nice_name, Movier.titleize(movie[:type])
+          Movier.tip_now movie[:path], "Path"
+          rating = "#{movie[:rated]} at #{movie[:rating]} points."
+          Movier.say_rated "Rating", rating, movie[:rating]
+          Movier.say_rated "Votes", "#{movie[:votes]} IMDB.com votes", movie[:rating]
+          Movier.say_rated "Genre", movie[:genre].join(", "), movie[:rating], true
+          Movier.say_rated "Runtime", movie[:runtime], movie[:rating]
+          Movier.say_rated "Directors", movie[:directors].join(", "), movie[:rating], true
+          Movier.say_rated "Actors", movie[:actors].join(", "), movie[:rating], true
+          Movier.say_rated "Writers", movie[:writers].join(", "), movie[:rating], true if @params[:writer]
+          Movier.say_rated "Plot", movie[:plot], movie[:rating], true
+          Movier.say_rated "Tags", movie[:tags].join(", "), movie[:rating] if movie[:tags].any?
+        else
+          message = "#{"%03d" % counter}) #{nice_name}"
+          Movier.say_rated Movier.titleize(movie[:type]), message, movie[:rating]
+          rating = "#{movie[:rated]} at #{movie[:rating]} points with #{movie[:votes]} votes."
+          Movier.say_rated "Rating", rating, movie[:rating]
+          Movier.say_rated "Directors", movie[:directors].join(", "), movie[:rating], true if @params[:directors]
+          Movier.say_rated "Actors", movie[:actors].join(", "), movie[:rating], true
+          Movier.say_rated "Tags", movie[:tags].join(", "), movie[:rating] if movie[:tags].any?
+        end
+        puts
+        counter += 1
+      end
+      return if @movies.empty?
+      filtered = @movies
+
+      # add some tags to this search
+      if @params[:add_tags]
+        tags = @params[:add_tags].split(",").map{|t| Movier.titleize(t.strip)}
+        read_data
+        filtered.each do |f|
+          @movies.each_with_index do |m,i|
+            @movies[i][:tags] |= tags if m[:id] == f[:id]
+          end
+        end
+        write_data
+        Movier.tip_now "Added tags: '#{tags.join(", ")}' to this search!"
+      end
+
+      # TODO: remove tags?
+
+      message = "Do you want me to play #{@params[:shuffle] ? "this" : "some"} movie for you? [enter number from above] "
+      begin; open = ask(message) {|x| x.default = "no" }; rescue Exception; end
+      if open == "no" && @params[:shuffle]
+        find @params
+      elsif open && open.to_i > 0
+        movie = filtered[open.to_i - 1]
+        # TODO: fix this to use a pure ruby implementation
+        nice_name = "#{movie[:title]} [#{movie[:year]}]"
+        movie_dir = "#{movie[:path]}".gsub(" ", "\\ ")
+        movie_file = `find #{movie_dir} -type f`.strip.split("\n")
+        movie_file = movie_file.select{|f| File.size(f) > 100 * 2**20}.first
+        Movier.tip_now "Opening: #{nice_name} with VLC Player"
+        `open "#{movie_file}" -a VLC &`
+      end
+    end
+
+    def sort_movies
+      @movies = @movies.sort_by {|movie| movie[:weight] }.reverse
+    end
+
+    # Update the local movie database,
+    # by revisiting all tracked directories,
+    # and building the database from there.
+    #
+    def update_itself
+      message  = "Found no movie box in the local database.\n"
+      message += "Please, run `movier add` to add some movie boxes, before updating me!"
+      raise message if @boxes.empty?
+      @boxes.each { |box| delete(box); add(box) }
+    end
+
+    def delete(dir = nil)
+      dir = File.expand_path dir
+      @movies.reject!{ |movie| movie[:box] == dir }
+      @boxes.reject!{ |box| box == dir }
+      write_data
+      current_state
+    end
+
+    # Add a given directory to the local movie database.
+    # The directory should be pre-organized using the Organize command.
+    #
+    # * *Args*    :
+    #   - +dir+ -> directory to add to the local movie database
+    #
+    def add(dir = nil)
+      dir = File.expand_path dir
+      raise "No such directory!" unless File.directory?(dir)
+
+      imdb = Dir.glob("#{dir}/**/imdb.txt")
+      raise 'You should first run `movier organize` on this directory!' unless imdb.count > 0
+
+      count = 0
+      imdb.each do |file|
+        movie = Movier.read_yaml file
+        if in_database?(movie) && !@boxes.include?(dir)
+          Movier.warn_with "#{movie[:imdb]["Title"]} already exists in database!"
+        elsif !in_database?(movie)
+          @movies.push sanitize(movie, dir, file)
+          count += 1
+        end
+      end
+
+      @boxes.push dir unless @boxes.include? dir
+      write_data
+
+      Movier.passed_with "Added #{count} new movies in LMDB."
+      current_state
+    end
+
+    def current_state
+      Movier.tip_now "LMDB now contains #{@movies.count} movies, and #{@boxes.count} boxes."
+    end
+
+    def sanitize(movie, dir, imdb_file)
+      imdb = movie[:imdb]
+      nice_name = "#{imdb["Title"]} [#{imdb["Year"]}]"
+      hash = (Digest::MD5.new << nice_name).to_s.slice(0,8)
+      data = {
+        title:      imdb["Title"],
+        year:       imdb["Year"],
+        rated:      imdb["Rated"],
+        released:   imdb["Released"],
+        runtime:    imdb["Runtime"],
+        genre:      make_parts(imdb["Genre"]),
+        directors:  make_parts(imdb["Director"]),
+        writers:    make_parts(imdb["Writer"]),
+        actors:     make_parts(imdb["Actors"]),
+        plot:       imdb["Plot"],
+        poster:     imdb["Poster"],
+        _poster:    File.join(dir, nice_name, "poster#{File.extname(imdb["Poster"])}"),
+        rating:     imdb["imdbRating"].to_f,
+        votes:      imdb["imdbVotes"].to_s.delete(",").to_i,
+        type:       imdb["Type"],
+        id:         imdb["imdbID"],
+        hash:       hash.force_encoding("UTF-8"),
+        tags:       [],
+        box:        dir,
+        path:       File.dirname(imdb_file)
+      }
+      data[:weight] = (data[:rating] * data[:votes]).to_i
+      data
+    end
+
+    def make_parts(string, delimiter = ",")
+      string.split(delimiter).map{|x| x.strip}
+    end
+
+    def in_database?(movie)
+      @movies.select{|m| m[:id] == movie[:imdb]["imdbID"]}.any?
+    end
+  end
+
+  def self.read_yaml(file)
+    YAML.load_file(file)
+  end
+
+  def self.write_yaml(file, data)
+    File.open(file, "w") {|f| f.puts data.to_yaml }
+  end
+end

data/lib/movier/movier.rb

@@ -0,0 +1,17 @@
+# __BEGIN__
+#
+#
+# i am here, because of bundler's love for me :)
+#
+#
+# ============================================
+# do not hate me for I have no class,
+# my creator was an idiot, alas!
+# what started as a simple idea,
+# soon grew up, like his love for Tia!
+# maybe, he will give me a brand new skin,
+# till then, I am just a module, to begin!! :(
+# ============================================
+#
+#
+# __END__

data/lib/movier/organize.rb

@@ -0,0 +1,251 @@
+module Movier
+
+  # Organize a given folder of movies
+  #
+  # * *Args*    :
+  #   - +path+ -> path to the folder with movies that need to be organized
+  #
+  def self.organize(path, options = {})
+    # path where files that need to be organized are.
+    path = path.first
+    path = Dir.pwd if not path or path.empty?
+    path = File.expand_path(path)
+
+    # select files that are larger than 100 MB and not yet, organized.
+    movies = Dir.glob("#{path}/**/*")
+    movies = movies.select{ |f| File.size(f) >= 100*2**20 }
+    movies = movies.reject{ |f| organized?(f) }
+
+    # if we can't find such files, let the user know so.
+    # otherwise, display how many files, we have found
+    if movies.count > 0
+      tip_now("Found approx. #{movies.count} movies")
+
+      # ask user where the organized files will be put up?
+      tip_now "Movies will be saved as: <organized>/<Language>/<rating>+/<movie_name> [<year>]"
+      options[:dir] = ask_for_directory("Where should I put the organized files? ")
+
+      # organize movies one by one
+      movies.each { |movie_path| organize_movie movie_path, options }
+
+      # show that we are done
+      passed_with("All movies were organized!")
+    else
+      passed_with("All movies have already been organized.")
+    end
+  end
+
+  private
+
+  # Organize a single movie, given a path
+  #
+  # * *Args*    :
+  #   - +movie_path+ -> path of the movie that will be organized
+  #
+  def self.organize_movie(movie_path, options)
+    movie_path = File.expand_path(movie_path)
+    # let the user know which movie we are parsing..
+    tip_now movie_path, "Checking.."
+
+    # pick a target movie from IMDB.com based on the file path
+    movie = pick_movie movie_path, options[:guess]
+
+    # if we were unable to find the movie, or it was ignored, move ahead
+    return unless movie
+
+    # let the user know, which target was selected
+    imdb  = movie[:imdb]
+    selected  = "#{imdb["Title"]} [#{imdb["Year"]}"
+    selected += " at #{imdb["imdbRating"]} points with #{imdb["imdbVotes"]} votes"
+    say_rated "Selected", selected, imdb["imdbRating"]
+
+    # since, we can't find movie's language, ask user for it.
+    lang = options[:lang] || ask("What language this movie is in? ") {|x| x.default = "en" }
+
+    # rearrange/reorganize the movie
+    set_language_and_rearrange(movie, options[:dir], lang)
+  end
+
+  # pick a target movie from IMDB.com based on the movie's file path
+  #
+  # * *Args*    :
+  #   - +movie+ -> path to the movie
+  # * *Returns* :
+  #   - hash of information about the selected movie target
+  #
+  def self.pick_movie(movie_path, guess = true)
+    # pick -> our selected target from IMDB.com
+    pick = false
+
+    # get whatever information we can get from movie's path
+    movie = sanitize_and_get_information_from movie_path
+
+    # search for movies with this information
+    search = search_movie(movie[:name], movie[:year])
+
+    # get information from IMDB.com for each movie found
+    search.map!{ |mov| fetch_details mov["imdbID"] }
+    # sort our movies
+    search.sort_by {|m| m["weight"] }
+
+    # can we make an intelligent guess ?
+    guessable = guess &&
+                search.count > 1 && (
+                search[1]["votes"]  < 5000   &&
+                search[0]["votes"]  > 100000 ) || (
+                search[0]['votes']  > 10000  &&
+                search[0]["weight"] > 40 * search[1]["weight"] )
+
+    # pick if only one movie was found, or if search is guessable
+    pick = search[0] if search.count == 1 || guessable
+
+    # let the user pick a movie otherwise from given options
+    unless pick
+      tip_now "Please, choose the correct movie title below:"
+      choose do |menu|
+        # let the user pick from found movie titles
+        search.each do |m|
+          m["details"]  = "#{m["Title"]} [#{m["Year"]}] at "
+          m["details"] += "#{m["imdbRating"]} points "
+          m["details"] += "with #{m["imdbVotes"]} votes.\n\t"
+          m["details"] += "Plot: #{m["Plot"]}\n\t"
+          m["details"] += "Actors: #{m["Actors"]}\n"
+          menu.choice(m["details"]) { pick = m }
+        end
+        # let the user provide an IMDB ID
+        menu.choice("[ Use IMDB ID ]") do
+          id = ask("IMDB.com ID for the given title? ")
+          pick = fetch_details id
+        end
+        menu.choice("[ Use another keyword ]") do
+          keyword = ask("Keyword to search with? ")
+          pick_movie keyword
+        end
+        # let the user ignore this movie for organizing purposes
+        menu.choice("[ Ignore ]") { return false }
+      end
+    end
+
+    # return our pick or false for skipping this movie
+    movie[:imdb] = pick
+    pick ? movie : false
+  end
+
+  # Search a movie given some keywords, and optionally, an year.
+  # Loop until we have a target movie from IMDB.com.
+  # If need arises, ask user to provide us some keywords or an IMDB.com ID.
+  #
+  # * *Args*    :
+  #   - +keyword+ -> keywords for the search
+  #   - +year+ -> (optional) year of this movie
+  #   - +ask_user+ -> if true, asks a user for movie name/id
+  # * *Returns* :
+  #   - hash of search results
+  #
+  def self.search_movie(keyword, year = nil, ask_user = false)
+    search = []; counter = 1
+    until search.any?
+      # on first search, it will search with keyword being passed
+      # on second search, will search with initial two words in the keyword
+      # on third search and onwards, will ask user for keywords/id
+      tip_now "Using keywords: #{keyword}", "Searching.." if counter > 1
+      begin; search = search(keyword, year, "movie"); rescue; end
+      begin; search = search(keyword, nil, "Movie") if year and not search.any?; rescue; end
+
+      if counter == 1
+        keyword = keyword.split
+        keyword = keyword.count == 1 ? keyword[0] : "#{keyword[0]} #{keyword[1]}"
+      elsif not search.any?
+        keyword = ask("Please, provide keywords/IMDB ID to search with: ")
+        return [{ "imdbID" => keyword }] if keyword =~ /tt\d{7}/
+      end
+
+      counter += 1;
+    end
+    search
+  end
+
+  # Set language for a movie, and then rearrange/reorganize it on the disk
+  #
+  # * *Args*    :
+  #   - +movie+ -> hash of information about this movie
+  #   - +path+ -> directory where the organized movies will be kept
+  #   - +lang+ -> language of this movie
+  #
+  def self.set_language_and_rearrange(movie, org_path, lang = "en")
+    # get the language for this movie
+    lang = case lang.downcase
+           when "en", "eng", "english" then "English"
+           when "hi", "hindi" then "Hindi"
+           when "fr", "french" then "French"
+           else lang.titlecase
+           end
+
+    # set the directory path for this movie
+    # directory structure is:
+    #   <org_path>/<language>/<rating>+/<movie name> [<year>]/
+    # e.g. for the Top Gun movie:
+    #   /Volumes/JukeBox/Movies/English/6+/Top Gun [1986]/
+    imdb = movie[:imdb]
+    nice_name = "#{imdb["Title"]} [#{imdb["Year"]}]".gsub(/(\\|\/|\:)/, ' - ')
+    movie_path = File.join(org_path, lang, "#{imdb["imdbRating"]}+", nice_name)
+    FileUtils.mkdir_p movie_path
+
+    Dir.chdir(movie_path) do
+      # move the movie to this folder
+      # TODO: skip copying the file if this movie already exists
+      FileUtils.mv movie[:path], nice_name + File.extname(movie[:path])
+      # create imdb.txt file inside this folder
+      File.open("imdb.txt", "w") {|f| f.puts movie.to_yaml}
+      # download the movie posted to this folder
+      `wget #{imdb["Poster"]} -qO poster#{File.extname(imdb["Poster"])}` unless
+        imdb["Poster"] == "N/A"
+    end
+  end
+
+  # Sanitize whatever information we got from movie's path
+  #
+  # * *Args*    :
+  #   - +path+ -> path to the movie
+  # * *Returns* :
+  #   - hash of sanitized information about the movie
+  #
+  def self.sanitize_and_get_information_from(path)
+    movie = capture_movie(path)
+    movie[:name] = movie[:name].gsub(/(BR|DVD|[a-z]*)Rip/i, "")
+    movie[:name] = movie[:name].gsub(/divx/i, "")
+    movie[:name] = movie[:name].gsub(/[._-]/, " ").strip
+    movie[:parent] = File.basename(File.dirname(path))
+    movie[:path] = path
+    movie
+  end
+
+  # Capture information about the movie from its path
+  #
+  # * *Args*    :
+  #   - +path+ -> path of this movie
+  # * *Returns* :
+  #   - hash of information about the movie
+  #
+  def self.capture_movie(path)
+    movie = File.basename(path, File.extname(path))
+
+    # try for: movie name [year] something.something
+    regex = /(.*)\[(\d{4})\].*/
+    match = movie.match regex
+    return {type: 1, name: match[1], year: match[2]} if match
+
+    # try for: movie name (year) something.something
+    regex = /(.*)\((\d{4})\).*/
+    match = movie.match regex
+    return {type: 2, name: match[1], year: match[2]} if match
+
+    # try for: movie name year something.something
+    regex = /(.*)(\d{4}).*/
+    match = movie.match regex
+    return {type: 3, name: match[1], year: match[2]} if match
+
+    # go generic
+    return {type: 0, name: movie }
+  end
+end

data/lib/movier/say.rb

@@ -0,0 +1,49 @@
+module Movier
+  # say something in a nicely formatted way
+  #
+  # * *Args*    :
+  #   - +status+ -> status for this message
+  #   - +message+ -> actual message
+  #   - +colorscheme+ -> color scheme to be used for this message
+  def self.say_with_status(status, message, colorscheme = nil, do_break = false)
+    # Create a color scheme, naming color patterns with symbol names.
+    ft = HighLine::ColorScheme.new do |cs|
+      cs[:regular]     = [ ]
+      cs[:above8]      = [:bold, :green]
+      cs[:above6]      = [:bold, :yellow]
+      cs[:below6]      = [:red]
+      cs[:information] = [ :bold, :cyan ]
+      cs[:success]     = [ :green ]
+      cs[:error]       = [ :bold, :red]
+      cs[:warning]     = [ :bold, :yellow ]
+    end
+    # Assign that color scheme to HighLine...
+    HighLine.color_scheme = ft
+    # default color scheme
+    colorscheme ||= :regular
+    status += " " * (20 - status.length)
+    message = message.gsub("'", %q(\\\'))
+    if do_break
+      message = message.split.each_slice(10).map{|x| x.join(" ") }
+      message = message.join("\n" + " " * 25)
+    end
+    say("<%= color('    #{status} #{message}', '#{colorscheme}') %>")
+  end
+
+  def self.tip_now(message, status="Information", do_break = false)
+    say_with_status status, message, :information, do_break
+  end
+
+  def self.passed_with(message, do_break = false)
+    say_with_status "Success", message, :success, do_break
+  end
+
+  def self.warn_with(message, do_break = false)
+    say_with_status "Warning", message, :warning, do_break
+  end
+
+  def self.failed_with(message, do_break = false)
+    say_with_status "ERROR", message, :error, do_break
+    raise message
+  end
+end

data/lib/movier/version.rb

@@ -1,3 +1,3 @@
 module Movier
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/lib/movier.rb

@@ -3,11 +3,11 @@ require 'movier/version.rb'
 # Add requires for other files you add to your project here, so
 # you just need to require this one file in your bin file
 
+# require 'pry'
 require 'open-uri'
 require 'json'
 require 'httparty'
 require 'highline/import'
-# require 'pry'
 require 'digest/md5'
 
 require 'movier/say.rb'

data/movier.gemspec

@@ -0,0 +1,31 @@
+# Ensure we require the local version and not one we might have installed already
+require File.join([File.dirname(__FILE__),'lib','movier','version.rb'])
+Gem::Specification.new do |s| 
+  s.name = 'movier'
+  s.version = Movier::VERSION
+  s.author = 'Nikhil Gupta'
+  s.email = 'me@nikhgupta.com'
+  s.homepage = 'http://nikhgupta.com'
+  s.platform = Gem::Platform::RUBY
+  s.summary = 'Movier is a gem that allows you to quickly organize your movies'
+  s.description = 'Movier is a gem that allows you to quickly organize your movies'
+# Add your other files here if you make them
+  s.files = `git ls-files`.split
+  s.require_paths << 'lib'
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README.rdoc','movier.rdoc']
+  s.rdoc_options << '--title' << 'movier' << '--main' << 'README.rdoc' << '-ri'
+  s.bindir = 'bin'
+  s.executables << 'movier'
+
+  s.add_dependency 'json'
+  s.add_dependency 'highline'
+  s.add_dependency 'httparty'
+
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rdoc'
+  s.add_development_dependency 'aruba'
+
+  s.add_runtime_dependency 'gli','2.5.3'
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: movier
 version: !ruby/object:Gem::Version
-  version: 0.0.4
+  version: 0.0.5
 platform: ruby
 authors:
 - Nikhil Gupta
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-01 00:00:00.000000000 Z
+date: 2013-03-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: highline
   requirement: !ruby/object:Gem::Requirement
@@ -108,7 +122,7 @@ dependencies:
     - - '='
       - !ruby/object:Gem::Version
         version: 2.5.3
-description: 
+description: Movier is a gem that allows you to quickly organize your movies
 email: me@nikhgupta.com
 executables:
 - movier
@@ -117,10 +131,24 @@ extra_rdoc_files:
 - README.rdoc
 - movier.rdoc
 files:
+- .gitignore
+- Gemfile
+- README.rdoc
+- Rakefile
 - bin/movier
-- lib/movier/version.rb
+- features/movier.feature
+- features/step_definitions/movier_steps.rb
+- features/support/env.rb
 - lib/movier.rb
-- README.rdoc
+- lib/movier/api.rb
+- lib/movier/helpers.rb
+- lib/movier/info.rb
+- lib/movier/lmdb.rb
+- lib/movier/movier.rb
+- lib/movier/organize.rb
+- lib/movier/say.rb
+- lib/movier/version.rb
+- movier.gemspec
 - movier.rdoc
 homepage: http://nikhgupta.com
 licenses: []