world_top_movies 0.1.6

data/lib/world_top_movies/cli.rb

@@ -0,0 +1,334 @@
+class WorldTopMovies::CLI
+  attr_accessor :movie_instance, :genre, :status
+
+  @@prompt = TTY::Prompt.new
+  @@user = nil
+
+  def self.prompt
+    @@prompt
+  end
+
+  def self.user
+    @@user
+  end
+
+  def run
+    introduce
+    select_movies_lookup_or_fav_movies
+  end
+
+  private
+
+  def introduce
+    # Introduces the app and ask for user credentials
+    artii = Artii::Base.new({})
+    puts "-----------------------------------------------------------------------------------"
+    puts artii.asciify("World's Top Movies!")
+    puts "-----------------------------------------------------------------------------------"
+    puts "    By Harold Torres Marino | p: +61 401 927 123 | e: haroldtm55@gmail.com".colorize(:mode => :italic)
+    puts "-----------------------------------------------------------------------------------"
+    sleep(0.5)
+    puts "\nWelcome to the World's Top Movies of all times, a place where you can look up for worldwide top rated movies!\n\n"
+    sleep(1.5)
+    username = self.class.prompt.ask("Please enter your username to log in or sign up: ") do |q|
+      q.required(true, "Oops, seems you haven't provided your username! Try again please.")
+      q.validate(/^[a-zA-Z0-9._-]+$/, "Oops, seems like that username is invalid. Only alphanumerical characters plus . - _ are allowed. Try again please.")
+      q.modify(:down)
+    end
+    @@user = WorldTopMovies::DB::User.find_or_create_by(username: username)
+    sleep(0.5)
+    puts "\nThanks #{username}. I'd like to ask you some questions, ok?"
+  end
+
+  def select_movies_lookup_or_fav_movies
+    options = [
+      "Top Movies Lookup",
+      "My Favourite Movies section",
+      "My Movie Notes",
+      "Exit app",
+    ]
+    next_action = self.class.prompt.select(
+      "\nPlease choose where you want to go...", options
+    )
+    next_action == options[0] && scrape_and_print_movies
+    next_action == options[1] && select_action_favourite_movies
+    next_action == options[2] && select_action_movies_with_notes
+    next_action == options.last && close_app
+    select_next_action
+  end
+
+  def scrape_and_print_movies
+    # Asks the user which genre they want to see, then scrapres and generates the instances
+    sleep(1.5)
+    puts ""
+    type_of_scrape = self.class.prompt.select(
+      "Would you like to see the list of all movies in general or by genre?",
+      %w(General Genre)
+    )
+    puts "\nAlright! We're going to see the top #{type_of_scrape} movies..."
+    puts ""
+    sleep(1.5)
+    self.genre = nil if type_of_scrape == "General"
+    type_of_scrape == "Genre" && (self.genre = self.class.prompt.select(
+      "Choose a genre:\n", WorldTopMovies::Scraper.genres
+    ))
+    WorldTopMovies::Movie.scrape_and_print_movies_compact(self.genre)
+  end
+
+  def select_next_action
+    # Ask user to select a new action and re run the app from the chosen action
+    puts ""
+    sleep(0.5)
+    options = [
+      "See more info of a movie from the last selected genre or general list",
+      "Add favourite movies from the last selected genre or general list",
+      "Start a new lookup",
+      "Go to My Favourite Movies section",
+      "Go to My Movie notes",
+      "Print all the movies displayed so far",
+      "Exit app",
+    ]
+
+    next_action = self.class.prompt.select(
+      "What would you like to do now?", options
+    )
+    if next_action == options[0]
+      select_and_print_specific_movie
+      add_fav_or_leave_note
+    end
+    next_action == options[1] && add_favourite_movies
+    next_action == options[2] && scrape_and_print_movies
+    next_action == options[3] && select_action_favourite_movies
+    next_action == options[4] && select_action_movies_with_notes
+    next_action == options[5] && WorldTopMovies::Movie.scrape_and_print_movies_compact("all")
+    next_action == options.last && close_app
+    select_next_action
+  end
+
+  def select_and_print_specific_movie
+    # Asks user to select a movie from print_movies_compact
+    sleep(0.5)
+    puts ""
+    movie_url = self.class.prompt.select(
+      "Select a movie: ", WorldTopMovies::Movie.all_titles_and_links_hash_by_genre(self.genre), enum: ")"
+    )
+    self.movie_instance = WorldTopMovies::Movie.find_by_url(movie_url)
+    self.movie_instance.scrape_and_print_movie
+  end
+
+  def add_favourite_movies
+    # Finds or creates a new Favourite movie instances and adds them to the database
+    sleep(0.5)
+    movie_urls = self.class.prompt.multi_select(
+      "\nSelect movies: ", WorldTopMovies::Movie.all_titles_and_links_hash_by_genre(self.genre), enum: ")",
+    )
+    WorldTopMovies::DB::Movie.add_movies(user: self.class.user, movie_urls: movie_urls)
+    movie_urls.size > 0 ? puts("\nThe movie(s) have been added to your favourites!") : puts("\nNo movies were selected.")
+  end
+
+  def add_fav_or_leave_note
+    options = [
+      "Add it to your favourites",
+      "Leave a note",
+      "Nothing in particular",
+    ]
+    puts ""
+    next_action = self.class.prompt.select(
+      "What would you like to do with this movie?", options
+    )
+    next_action == options[0] && add_favourite_movie
+    next_action == options[1] && leave_note
+    select_next_action
+  end
+
+  def leave_note
+    note_message = self.class.prompt.ask("Please leave your note\n\n") do |q|
+      q.required(true, "Oops, seems you haven't left any note! Try again please.")
+    end
+    WorldTopMovies::DB::Note.create_note(movie_url: self.movie_instance.url, note_message: note_message, user: self.class.user)
+    puts "\nYour note has been saved!"
+    sleep(1.5)
+  end
+
+  def add_favourite_movie
+    # Finds or creates a new Favourite movie instance and adds it to the database
+    sleep(0.5)
+    # add_to_favourite = self.class.prompt.yes?("\nWould you like to add this movie to your favourites?")
+    if self.class.user.movies.none? { |m| m.url == self.movie_instance.url }
+      WorldTopMovies::DB::Movie.add_movies(user: self.class.user, movie_urls: self.movie_instance.url)
+      puts "\n#{self.movie_instance.title} has been added to your favourite movies!"
+    else
+      puts("\nOops! #{self.movie_instance.title} is already in your favourites!")
+    end
+  end
+
+  def delete_favourite_movies
+    sleep(0.5)
+    if self.class.user.movies.empty?
+      puts "\nOops, you haven't favourited any movies yet!!"
+    else
+      movie_urls = self.class.prompt.multi_select(
+        "\nSelect movies: ", self.class.user.favourite_movie_titles, enum: ")",
+      )
+      movie_urls.each do |movie_url|
+        WorldTopMovies::DB::UserMovie.delete_movie_record_from_user(user: self.class.user, movie_url: movie_url)
+        WorldTopMovies::Movie.delete_movie_instance_from_user(user: self.class.user, movie_url: movie_url)
+      end
+      movie_urls.size > 0 ? puts("\nThe movie(s) have been successfully deleted") : puts("\nNo movies were selected.")
+    end
+  end
+
+  def print_favourite_movies
+    sleep(1)
+    if !self.class.user.movies.empty?
+      self.class.user.print_all_favourite_movie_titles
+    else
+      puts "\nOops, you haven't favourited any movies yet!!"
+    end
+  end
+
+  def select_and_print_specific_favourite_movie
+    # Asks user to select a movie from print_movies_compact
+    sleep(0.5)
+    if self.class.user.movies.empty?
+      puts "\nOops, you haven't favourited any movies yet!!"
+    else
+      puts ""
+      
+      movie_url = self.class.prompt.select(
+        "Select a movie: ", self.class.user.favourite_movie_titles, enum: ")"
+      )
+      WorldTopMovies::DB::Movie.all.find { |m| m.url == movie_url }.print_movie_details
+    end
+  end
+
+  def select_action_favourite_movies
+    puts ""
+    if self.class.user.movies.empty?
+      puts "Oops, you haven't favourited any movies yet, let's change that!!"
+      scrape_and_print_movies
+      select_next_action
+    else
+      sleep(0.5)
+      options = [
+        "See all your favourite movies",
+        "See more info of any of your favourite movies",
+        "Delete any of your favourite movies",
+        "Take me to the top movies lookup",
+        "Exit app",
+      ]
+
+      next_action = self.class.prompt.select(
+        "What would you like to do now?", options
+      )
+      if next_action == options[0]
+        print_favourite_movies
+        select_action_favourite_movies
+      elsif next_action == options[1]
+        select_and_print_specific_favourite_movie
+        select_action_favourite_movies
+      elsif next_action == options[2]
+        delete_favourite_movies
+        select_action_favourite_movies
+      elsif next_action == options[3]
+        scrape_and_print_movies
+        select_next_action
+      else
+        close_app
+      end
+    end
+  end
+
+  def print_all_notes
+    if !self.class.user.notes.empty?
+      self.class.user.print_all_notes
+    else
+      puts "\nOops, you haven't left any notes yet!!"
+    end
+  end
+
+  def print_movies_with_notes
+    sleep(1)
+    if !self.class.user.notes.empty?
+      self.class.user.print_movies_with_notes
+    else
+      puts "\nOops, you haven't left any notes yet!!"
+    end
+  end
+
+  def select_and_print_specific_movie_with_notes
+    # Asks user to select a movie from print_movies_compact
+    sleep(0.5)
+    if self.class.user.notes.empty?
+      puts "\nOops, you haven't left any notes yet!!"
+    else
+      puts ""
+      movie_url = self.class.prompt.select(
+        "Select a movie: ", self.class.user.movies_with_notes_titles, enum: ")"
+      )
+      WorldTopMovies::DB::Movie.all.find { |m| m.url == movie_url }.print_movie_details
+    end
+  end
+
+  def delete_notes
+    sleep(0.5)
+    if self.class.user.movies.empty?
+      puts "\nOops, you haven't left any notes yet!!"
+    else
+      note_ids = self.class.prompt.multi_select(
+        "\nSelect notes: ", self.class.user.notes_titles, enum: ")",
+      )
+      note_ids.each do |note_id|
+        WorldTopMovies::DB::UserNote.delete_note_record_from_user(user: self.class.user, note_id: note_id)
+        WorldTopMovies::DB::Note.delete_note_instance_from_user(user: self.class.user, note_id: note_id)
+      end
+      note_ids.size > 0 ? puts("\nThe note(s) have been successfully deleted") : puts("\nNo notes were selected.")
+    end
+  end
+
+  def select_action_movies_with_notes
+    puts ""
+    if self.class.user.notes.empty?
+      puts "Oops, you haven't left any notes yet, let's change that!!"
+      scrape_and_print_movies
+      select_next_action
+    else
+      sleep(0.5)
+      options = [
+        "See all my notes",
+        "See all your movies with notes",
+        "Open specific movie with notes",
+        "Delete any of your notes",
+        "Take me to the top movies lookup",
+        "Exit app",
+      ]
+
+      next_action = self.class.prompt.select(
+        "What would you like to do now?", options
+      )
+      if next_action == options[0]
+        print_all_notes
+        select_action_movies_with_notes
+      elsif next_action == options[1]
+        print_movies_with_notes
+        select_action_movies_with_notes
+      elsif next_action == options[2]
+        select_and_print_specific_movie_with_notes
+        select_action_movies_with_notes
+      elsif next_action == options[3]
+        delete_notes
+        select_action_movies_with_notes
+      elsif next_action == options[4]
+        scrape_and_print_movies
+        select_next_action
+      else
+        close_app
+      end
+    end
+  end
+
+  def close_app
+    puts "\nOk #{self.class.user.username}, hope you enjoyed your time with me!"
+    exit!
+  end
+end

data/lib/world_top_movies/models/movie.rb

@@ -0,0 +1,63 @@
+class WorldTopMovies::DB::Movie < ActiveRecord::Base
+  has_many :user_movies
+  has_many :users, through: :user_movies
+  has_many :notes
+
+  def self.generate_attributes_from_url(movie_url)
+    fav_movie = WorldTopMovies::Movie.find_by_url(movie_url)
+    attributes = {
+      title: fav_movie.title,
+      year: fav_movie.year,
+      duration: fav_movie.duration,
+      genres: fav_movie.genres.join(" - "),
+      user_rating: fav_movie.user_rating,
+      metascore: fav_movie.metascore,
+      description: fav_movie.description,
+      director: fav_movie.director,
+      stars: fav_movie.stars.join(" - "),
+      votes: fav_movie.votes,
+      gross_revenue: fav_movie.gross_revenue,
+      url: fav_movie.url,
+    }
+  end
+
+  def self.add_movies(user:, movie_urls:)
+    # Finds or creates new Favourite movie instances and adds them to the given user
+    movie_urls.class != Array && movie_urls = movie_urls.split()
+    movie_urls.each do |movie_url|
+      if user.movies.none? { |m| m.url == movie_url }
+        attributes = self.generate_attributes_from_url(movie_url)
+        user.movies << self.find_or_create_by(attributes)
+      end
+    end
+  end
+
+  def print_movie_details
+    attributes = {
+      title: self.title,
+      year: self.year,
+      duration: self.duration,
+      genres: self.genres,
+      user_rating: self.user_rating,
+      metascore: self.metascore.to_s,
+      description: self.description,
+      director: self.director,
+      stars: self.stars,
+      votes: self.votes,
+      gross_revenue: self.gross_revenue,
+      url: self.url,
+      database: true,
+    }
+    movie = WorldTopMovies::Movie.new(attributes)
+    movie.scrape_and_print_movie
+    print_movie_notes
+  end
+
+  def print_movie_notes
+    logged_user = WorldTopMovies::CLI.user
+    notes = self.notes.select { |n| n.user && n.user.username == logged_user.username }
+    puts "\n----------------#{"My Own notes".bold}------------------"
+    notes.empty? ? puts("No notes left") : notes.each { |n| puts "\n-#{n.note_message}- on #{n.created_at.localtime}" }
+    puts "----------------------------------------------"
+  end
+end

data/lib/world_top_movies/models/note.rb

@@ -0,0 +1,21 @@
+class WorldTopMovies::DB::Note < ActiveRecord::Base
+  has_one :user_note, dependent: :destroy
+  has_one :user, through: :user_note
+  belongs_to :movie
+
+  def self.create_note(movie_url:, note_message:, user:)
+    #Creates a note to a movie that is created if it's not in the database, and appends it to the user
+    attributes = WorldTopMovies::DB::Movie.generate_attributes_from_url(movie_url)
+    if !WorldTopMovies::DB::Movie.find_by(url: movie_url)
+      movie_record = WorldTopMovies::DB::Movie.create(attributes)
+    else
+      movie_record = WorldTopMovies::DB::Movie.find_by(url: movie_url)
+    end
+    note_record = self.create(note_message: note_message, movie_id: movie_record.id)
+    user.notes << note_record
+  end
+
+  def self.delete_note_instance_from_user(user:, note_id:)
+    user.notes.delete(user.find_note_from_id(note_id))
+  end
+end

data/lib/world_top_movies/models/user.rb

@@ -0,0 +1,67 @@
+class WorldTopMovies::DB::User < ActiveRecord::Base
+  has_many :user_movies, dependent: :destroy
+  has_many :movies, through: :user_movies
+  has_many :user_notes, dependent: :destroy
+  has_many :notes, through: :user_notes
+
+  def print_all_favourite_movie_titles
+    puts "\nOk! Your favourite movies are:\n\n"
+    sleep(1.5)
+    self.movies.sort_by { |m| m.title }.each_with_index do |m, i|
+      sleep(0.01)
+      WorldTopMovies::Movie.print_movie_compact(m, i)
+    end
+  end
+
+  def favourite_movie_titles
+    # returns a hash with key=title, value=url of all fav movies
+    result = {}
+    self.movies.sort_by { |m| m.title }.each { |m| result[m.title] = m.url }
+    result
+  end
+
+  def find_movie_from_url(movie_url)
+    self.movies.find { |m| m.url == movie_url }
+  end
+
+  def print_movies_with_notes
+    puts "\nOk! Your movies with notes are:\n\n"
+    sleep(1.5)
+    self.movies_with_notes_arr.sort_by { |m| m.title }.each_with_index do |m, i|
+      sleep(0.01)
+      WorldTopMovies::Movie.print_movie_compact(m, i)
+    end
+  end
+
+  def movies_with_notes_titles
+    result = {}
+    self.movies_with_notes_arr.sort_by { |m| m.title }.each { |m| result[m.title] = m.url }
+    result
+  end
+
+  def movies_with_notes_arr
+    self.notes.map { |note| note.movie }.uniq
+  end
+
+  def print_all_notes
+    puts "\nPrinting #{self.notes.count} note(s):\n\n"
+    sleep(1.5)
+    self.notes.each_with_index do |n, i|
+      sleep(0.01)
+      puts "--------------------------------------------------------------"
+      puts "\n#{i + 1}. #{n.note_message.colorize(:color => :green).italic}, \
+Movie: #{n.movie.title.colorize(:color => :light_blue).bold}, \
+Date: #{n.created_at.localtime.to_s.colorize(:color => :red).bold} \n"
+    end
+  end
+
+  def notes_titles
+    result = {}
+    self.notes.each { |n| result["#{n.note_message}, #{n.movie.title}, #{n.created_at.localtime.to_s}"] = n.id }
+    result
+  end
+
+  def find_note_from_id(note_id)
+    self.notes.find { |n| n.id == note_id }
+  end
+end

data/lib/world_top_movies/models/user_movie.rb

@@ -0,0 +1,9 @@
+class WorldTopMovies::DB::UserMovie < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :movie
+
+  def self.delete_movie_record_from_user(user:, movie_url:)
+    self.joins(:user, :movie)
+      .where("movies.url" => movie_url, "users.username" => user.username).destroy_all
+  end
+end

data/lib/world_top_movies/models/user_note.rb

@@ -0,0 +1,9 @@
+class WorldTopMovies::DB::UserNote < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :note
+
+  def self.delete_note_record_from_user(user:, note_id:)
+    self.joins(:user, :note)
+      .where("notes.id" => note_id, "users.username" => user.username).destroy_all
+  end
+end

data/lib/world_top_movies/movie.rb

@@ -0,0 +1,179 @@
+class WorldTopMovies::Movie
+  attr_reader :award, :storyline, :languages, :official_site, :countries_of_orig
+
+  @@all = []
+
+  def initialize(attributes)
+    #Utilises metaprogramming to create new instances
+    attributes.each do |key, value|
+      self.class.attr_accessor(key)
+      self.send(("#{key}="), value)
+    end
+    # Add instance to @all only if it's not already there
+    self.class.all << self if self.class.all.none? { |m| m.url == self.url } && !self.database
+  end
+
+  def self.new_from_page(m)
+    # Creates new instance with the attributes from general page
+    self.new({
+      title: m.css("h3 a").text,
+      year: m.css("h3 span.lister-item-year").text[1...-1].scan(/[0-9]/).join(),
+      duration: m.css("span.runtime").text,
+      genres: m.css("span.genre").text.strip.split(", "),
+      user_rating: m.css("div strong").text.to_f,
+      metascore: m.css("div span.metascore").text.strip.to_i,
+      description: m.css("p.text-muted")[1].text.strip,
+      director: m.css("div.lister-item-content p a")[0].text.strip,
+      stars: m.css("div.lister-item-content p a").slice(1..-1).map { |s| s.text },
+      votes: m.css("p.sort-num_votes-visible span")[1].text.gsub(",", "").to_i,
+      gross_revenue: m.css("p.sort-num_votes-visible span")[-1].text,
+      url: "https://imdb.com" + m.css("h3 a").attribute("href").value,
+      database: false,
+    })
+  end
+
+  def self.all
+    @@all
+  end
+
+  def self.all_top_general
+    # Filters out the movies with rating >= 8.4
+    self.all.select { |m| m.user_rating >= 8.4 }.sort_by { |m| m.user_rating }.reverse
+  end
+
+  def self.all_by_genre(genre)
+    # Filters all movies from a given genre, if no genre, return general movies
+    return self.all_top_general if !genre
+    self.all.select { |m| m.genres.include?(genre) }
+  end
+
+  def self.reset_all
+    self.all.clear
+  end
+
+  def self.all_titles_and_links_hash
+    # returns a hash with key=title, value=url of all movie instances
+    result = {}
+    self.all.each do |m|
+      result[m.title] = m.url
+    end
+    result
+  end
+
+  def self.all_titles_and_links_hash_by_genre(genre)
+    # returns a hash with key=title, value=url of all movie instances from given genre
+    result = {}
+    counter = 1
+    self.all_by_genre(genre).each do |m|
+      if result.keys.none? { |key| key == m.title }
+        result[m.title] = m.url
+      else
+        result[m.title + "(#{counter + 1})"] = m.url
+      end
+    end
+
+    result
+  end
+
+  def self.find_by_url(url)
+    self.all.find { |m| m.url == url }
+  end
+
+  def self.delete_movie_instance_from_user(user:, movie_url:)
+    user.movies.delete(user.find_movie_from_url(movie_url))
+  end
+
+  def self.scrape_and_print_movies_compact(genre = nil)
+    # Looks for the movies to print depending on the arg and prints title, rating, year
+    if genre == "all"
+      movies = self.all.sort_by { |m| m.user_rating }.reverse
+    else
+      WorldTopMovies::Scraper.make_movies(genre)
+      movies = genre == nil ? self.all_top_general : self.all_by_genre(genre)
+    end
+    puts "I'll give you #{movies.size} top movies!"
+    sleep(1.5)
+    movies.each_with_index do |movie, index|
+      sleep(0.01)
+      self.print_movie_compact(movie, index)
+    end
+  end
+
+  def self.print_movie_compact(movie, index)
+    puts "--------------------------------------------------------------"
+    puts "\n#{index + 1}. #{movie.title.colorize(:color => :green, :mode => :bold)}, \
+Rating: #{movie.user_rating.to_s.colorize(:color => :light_blue, :mode => :bold)}, \
+Year: #{movie.year.colorize(:color => :red)} \n"
+  end
+
+  def get_awards_count
+    target = doc.css("li span.ipc-metadata-list-item__list-content-item")[0].text
+    @award || (@award = target if target.include?("nomination") || target.include?("win"))
+  end
+
+  def storyline
+    @storyline ||
+    @storyline = doc.css(
+      ".Storyline__StorylineWrapper-sc-1b58ttw-0 div.ipc-html-content.ipc-html-content--base div"
+    )[0].text
+  end
+
+  def languages
+    @languages ||
+    @languages = doc.css(
+      "div[data-testid=title-details-section] li[data-testid=title-details-languages]"
+    )
+      .children[1].children[0].children.map { |l| l.text }.join(" - ")
+  end
+
+  def official_site
+    target = doc.css(
+      "div[data-testid=title-details-section] li[data-testid=title-details-officialsites]"
+    )
+      .children
+    if @official_site
+      @official_site
+    else
+      if target.children[0] && target.children[0].text.include?("site")
+        @official_site = target.children[1].children[0].children[0].attribute("href").value
+      end
+    end
+  end
+
+  def countries_of_origin
+    @countries_of_origin ||
+    @countries_of_origin = doc.css("div[data-testid=title-details-section] li[data-testid=title-details-origin]")
+      .children[1].children[0].children.map { |c| c.text }.join(" - ")
+  end
+
+  def scrape_and_print_movie
+    # Prints detailed info of a selected movie from select_specific_movie, after scraping it.
+    description = self.description
+    storyline = self.storyline
+    puts "\n----------------------------------------------"
+    puts "         #{self.title.upcase} - #{self.year}         ".colorize(:background => :green, :color => :black).bold
+    puts "----------------------------------------------"
+    puts "\n#{"Genres:".bold}       #{self.genres.class == Array && self.genres.join(" - ").green.italic || self.genres.green.italic}"
+    puts "#{"Duration:".bold}     #{self.duration.green.italic}"
+    puts "#{"Stars:".bold}        #{self.stars.class == Array && self.stars.join(" - ").green.italic || self.stars.green.italic}"
+    puts "#{"Rating:".bold}       #{"#{self.user_rating} from #{self.votes} votes".green.italic}"
+    puts "#{"Metascore:".bold}    #{self.metascore && self.metascore.to_s.green.italic || "N/A"}"
+    puts "#{"Directed by:".bold}  #{self.director && self.director.green.italic}"
+    puts "#{"Total Awards:".bold} #{self.get_awards_count && self.get_awards_count.green.italic || "N/A"}"
+    puts "\n-----------------#{"Description".bold}-------------------"
+    puts "\n#{description.green.italic || "N/A"}\n"
+    puts "\n#{"Storyline:".bold}\n\n#{self.storyline && self.storyline.green.italic || "N/A"}\n"
+    puts "\n----------------#{"Other Details".bold}------------------"
+    puts "\n#{"Countries:".bold}    #{self.countries_of_origin && self.countries_of_origin.green.italic || "N/A"}"
+    puts "#{"Languages:".bold}    #{self.languages && self.languages.green.italic || "N/A"}"
+    puts "#{"IMDB URL:".bold}     #{self.url.green.italic}"
+    puts "#{"Website:".bold}      #{self.official_site && self.official_site.green.italic || "N/A"}"
+    puts "\nThis movie has a gross revenue of #{self.gross_revenue}".green.bold
+  end
+
+  private
+
+  def doc
+    @doc || @doc = WorldTopMovies::Scraper.get_movie_details_page(self.url)
+  end
+end