Soleone-gamefaqs 0.0.2

data/README.textile

@@ -0,0 +1,65 @@
+h1. GameFAQs Library
+
+Access information about all games (any platform) from GameFAQs.
+
+You can search for games by title and platform, and then view _Reviews_, _FAQs_, _Cheats_ for it.
+
+h2. Installation
+
+@gem install soleone-gamefaqs --source=http://gems.github.com@
+
+h2. Usage
+
+<pre>
+<code>
+require 'gamefaqs'
+
+# and for convenience:
+include GameFaqs
+</code>
+</pre>
+
+h2. Examples
+
+h3. Find games and platforms
+
+<pre>
+<code>
+  # Search for a game containing two words on the Nintendo DS
+  game = GameFaqs::Search.game("Castlevania Ecclesia", "DS")
+  
+  # You can also search starting from the platform
+  snes = GameFaqs::Platform.find("snes")
+  game = snes.find("super mario land")
+</code>
+</pre>
+
+h3. Reviews
+
+<pre>
+<code>
+  # Get the average score from all reviews
+  game.average_score
+  # Get the average score from only detailed reviews (there are :detailed, :full and :quick)
+  game.average_score(:detailed)
+
+  # Get all reviews for this game
+  reviews = game.reviews
+  # Get only quick reviews for this game
+  reviews = game.reviews(:quick)
+  
+  # Get the first review in the list
+  review = reviews.first
+  
+  # Score in the format 9/10
+  review.score
+  
+  # Get the full text of the review (original html stripped/converted)
+  review.text
+  
+  # Other information
+  review.title
+  review.created_at
+  review.author
+</code>
+</pre>

data/lib/gamefaqs.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+# gems
+require 'hpricot'
+
+require 'open-uri'
+require 'date'
+
+# load all source files
+lib = %w[caching platform game search list review]
+lib.each { |file| require File.join(File.dirname(__FILE__), 'gamefaqs', file) }
+
+
+module GameFaqs
+  BASE_URL = "http://www.gamefaqs.com"
+  SEARCH_URL = "#{BASE_URL}/search/index.html"
+
+protected  
+  def self.extract_id(url, with_html=true)
+    url.match(/\/([\da-zA-Z]+)#{'\.html' if with_html}$/)
+    $1
+  end
+  
+  # 1. convert <br> to \n
+  # 2. convert <b> to * (textile)
+  # 3. convert <i> to _ (textile)
+  # 4. strip all other tags
+  def self.strip_html(string)
+    string.gsub(/<br ?\/?>/, "\n").gsub(/<b>(.+)<\/b>/i, "*\\1*").gsub(/<i>(.+)<\/i>/i, "_\\1_").gsub(/<\/?(\d|\w)+>/i, "")
+  end
+end

data/lib/gamefaqs/caching.rb

@@ -0,0 +1,16 @@
+module GameFaqs
+  module Caching
+    
+  protected
+    # perform the block only when the name isn't filled already
+    def cached_value(name, object=nil, force=false)
+      @@cache ||= {}
+      if force || @@cache[name].nil?
+        @@cache[name] = object
+        return_value = yield object
+        @@cache[name] = return_value if object.nil?
+      end
+      @@cache[name] 
+    end
+  end
+end

data/lib/gamefaqs/faq.rb

@@ -0,0 +1,23 @@
+module GameFaqs
+  class FAQ
+    attr_reader :game, :id, :type, :title, :created_at, :author, :version, :size
+    
+    def initialize(options={})
+      raise ArgumentError.new("Need at least the game and the faq id") unless options[:game] && options[:id]
+      @game, @id, @type, @title, @created_at, @author, @version, @size = options[:game], options[:id], options[:type], options[:title], options[:created_at], options[:author], options[:size]
+    end
+    
+    def homepage(refresh=false)
+      cached_value("review-#{@id}-#{@game}", [], refresh) do |homepage|
+        url = "#{@game.homepage.gsub(/game/, 'file').gsub('.html', '')}/#{@id}"
+        doc = Hpricot(open(url))
+        doc.search("a[text()='View/Download Original File'") do |a|
+          puts a.inner_html
+          puts a['href']
+          homepage << a['href']
+        end
+      end.first      
+    end
+    
+  end
+end

data/lib/gamefaqs/game.rb

@@ -0,0 +1,31 @@
+module GameFaqs  
+  class Game
+
+    attr_reader :name, :platform, :homepage, :faqs, :codes
+    
+    def initialize(name, platform, id)
+      @name = name
+      @platform = platform
+      @id = id
+      @homepage = "#{@platform.homepage}home/#{@id}.html"
+    end
+
+    def name
+      "#{@name} (#{@platform})"
+    end
+    
+    def to_s
+      "#{@name} [#{platform}]"
+    end
+    
+    def reviews(review_type=nil)
+      List.reviews(self, review_type)
+    end
+    
+    def average_score(review_type=nil)
+      sum = reviews(review_type).map{|r| r.score_to_i}.inject{|memo, score| memo + score}
+      sum / reviews(review_type).size.to_f
+    end
+    
+  end
+end

data/lib/gamefaqs/list.rb

@@ -0,0 +1,124 @@
+module GameFaqs
+  module List
+    extend Caching
+    
+    PLATFORMS_PATH    = "//ul.systems/li/a"
+    PLATFORMS_ID_PATH = "//form#search/select[@name=platform]/option"
+    GAMES_PATH        = "//div.body/table/tr/td/a"
+
+    class << self
+      def platforms(refresh=false)
+        cached_value("platforms", [], refresh) do |platforms|
+          systems_doc = Hpricot(open("#{GameFaqs::BASE_URL}/systems.html"))
+          systems_doc.search(PLATFORMS_PATH).each do |link|
+            name = link.inner_html
+            platforms << Platform.new({:name => name, :homepage => link['href'], :id => platform_ids[name]})
+          end
+        end
+      end
+    
+      # find all games (very expensive)
+      def games(platform, refresh=false)
+        cached_value("games", []) do |games|
+          letters = ('a'..'z').to_a << '0'
+          letters.each do |letter|
+            doc = Hpricot(open("#{platform.homepage}list_#{letter}.html"))
+            doc.search(GAMES_PATH).each do |link|
+              name = link.inner_html
+              games << Game.new(name, platform, GameFaqs.extract_id(link['href']))
+            end
+          end
+        end
+      end
+  
+      def reviews(game, type=nil, refresh=false)
+        reviews = cached_value("reviews-#{game.to_s}", [], refresh) do |reviews|
+          url = game.homepage.sub(/\/home\//, "/review/")
+          doc = Hpricot(open(url))
+          doc.search("//div.head/h1") do |h1|
+            header = h1.inner_html
+
+            if header =~ /Reviews/
+              h1.search("../../div.body/table/tr") do |tr|
+                review = {}
+                review[:type] = Review.review_type(header)
+                tr.search("td:eq(0)") do |td|
+                  td.search("a") do |a|
+                    review[:id] = GameFaqs.extract_id(a['href'])
+                    review[:title] = a.inner_html.strip
+                  end
+                end
+                tr.search("td:eq(1)") do |td|
+                  td.search("a") do |a|
+                    review[:author] = a.inner_html.strip
+                  end
+                end
+                tr.search("td:eq(2)") do |td|
+                  review[:score] = td.inner_html.strip
+                end
+                review[:game] = game   
+                reviews << Review.new(review)
+              end
+            end
+          end
+        end
+        if type
+          types = Review::REVIEW_TYPES
+          raise ArgumentError.new("Type must be one of #{types.join(', ')}") unless types.include?(type.to_sym)
+          reviews.reject { |review| review.type != type.to_sym}
+        else
+          reviews
+        end
+      end
+
+      def faqs(game, type=nil, refresh=false)
+        faqs = cached_value("faqs-#{game.to_s}", [], refresh) do |faqs|
+          url = game.homepage.sub(/\/home\//, "/game/")
+          doc = Hpricot(open(url))
+          doc.search("//div.head/h1") do |h1|
+            header = h1.inner_html
+
+            h1.search("../../div.body/table/tr") do |tr|
+              faq = {}
+              faq[:type] = header
+              tr.search("td:eq(0)") do |td|
+                td.search("a") do |a|
+                  review[:id] = GameFaqs.extract_id(a['href'])
+                  review[:title] = a.inner_html.strip
+                end
+              end
+              tr.search("td:eq(1)") do |td|
+                td.search("a") do |a|
+                  review[:author] = a.inner_html.strip
+                end
+              end
+              tr.search("td:eq(2)") do |td|
+                review[:score] = td.inner_html.strip
+              end
+              review[:game] = game   
+              reviews << Review.new(review)
+            end
+          end
+        end
+        if type
+          types = FAQ::FAQ_TYPES
+          raise ArgumentError.new("Type must be one of #{types.join(', ')}") unless types.include?(type.to_sym)
+          faqs.reject { |faq| faq.type != type.to_sym}
+        else
+          faqs
+        end
+      end
+
+      # find all IDs for every platform (cached, do only once)
+      def platform_ids(refresh=false)
+        cached_value("game_ids", {}, refresh) do |ids|
+          search_doc = Hpricot(open(SEARCH_URL))
+          search_doc.search(PLATFORMS_ID_PATH).each do |option|
+            ids[option['label']] = option['value']
+          end
+        end
+      end
+      
+    end # class < self
+  end
+end

data/lib/gamefaqs/platform.rb

@@ -0,0 +1,39 @@
+# coupled to List
+module GameFaqs
+  class Platform
+    attr_reader :name, :homepage, :id
+    
+    def initialize(params={})
+      raise ArgumentError("Need at least the name, homepage, and id of the platform!") unless params[:name] && params[:homepage] && params[:id]
+      @name = params[:name]
+      @homepage = "#{GameFaqs::BASE_URL}#{params[:homepage]}"
+      @id = params[:id] if params[:id]
+    end
+    
+    def to_s
+      @name
+    end
+    
+    def self.all
+      List.platforms
+    end
+  
+    def self.all_ids
+      List.platform_ids
+    end
+    
+    def self.all_games
+      List.games(self)
+    end
+    
+    def find(game, refresh=false)
+      Search.game(game, self, refresh)
+    end
+    
+    # create case insensitive
+    def self.find(platform_name)
+      Search.platform(platform_name)
+    end
+      
+  end
+end

data/lib/gamefaqs/review.rb

@@ -0,0 +1,60 @@
+module GameFaqs
+  class Review
+    include Caching
+    
+    REVIEW_TYPES = [:detailed, :full, :quick]
+    
+    attr_reader :game, :id, :score, :author, :title, :type
+    
+    def initialize(options={})
+      raise ArgumentError.new("Need at least the game and the review id") unless options[:game] && options[:id]
+      @game, @id, @score, @author, @title, @type = options[:game], options[:id], options[:score], options[:author], options[:title], options[:type]
+    end
+    
+    def to_s
+      "#{@game}: #{@score} by #{author} (#{@title} [#{@type}])"
+    end
+
+    def score_to_i
+      actual, max = @score.split("/")
+      factor = 10 / max.to_i
+      actual.to_i * factor
+    end
+
+    def text
+      @text ||= parse_review[:text]
+    end
+    
+    def created_at
+      @created_at ||= Date.parse(parse_review[:created_at], "%m/%d/%y")
+    end
+    
+    def self.all_for(game)
+      List.reviews(game)
+    end
+    
+    def self.review_type(string)
+      REVIEW_TYPES.each do |type|
+        return type if string =~ /#{type}/i
+      end
+    end 
+    
+  private
+    def parse_review(refresh=false)
+      cached_value("review-#{@id}-#{@game.platform}", {}, refresh) do |review|
+        url = "#{@game.platform.homepage}review/#{@id}.html"
+        doc = Hpricot(open(url))
+        doc.search("//div.review/div.details") do |div|
+          div.search("p:eq(0)") do |p|
+            review[:text] = GameFaqs.strip_html(p.inner_html)
+          end
+          div.search("p:eq(1)") do |p|
+            date = p.inner_html
+            date.match(/Originally Posted:.*(\d\d\/\d\d\/\d?\d?\d\d)/)
+            review[:created_at] = $1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/gamefaqs/search.rb

@@ -0,0 +1,61 @@
+module GameFaqs
+  module Search
+    extend Caching
+    class SearchException < Exception; end
+
+    # throws a SearchError when no exact match is found
+    def self.game(game_name, platform, refresh=false)
+      cached_value("search-#{game_name}-#{platform}", nil, refresh) do
+        platform = Platform.find(platform) unless platform.is_a?(Platform)
+        games = []
+        doc = Hpricot(open("#{SEARCH_URL}#{add_params(game_name, platform)}"))
+        doc.search("//div.head/h1") do |h1|
+          if h1.inner_html =~ /Best Matches/
+            h1.search("../../div.body/table") do |table|
+              table.search("tr/td/a") do |a|
+                if a.inner_html =~ /#{game_name.split(' ').join('.*')}/i
+                  games << Game.new(a.inner_html.strip, platform, GameFaqs.extract_id(a['href']))
+                end
+              end
+            end
+          end
+        end
+        
+        case games.size
+        when 1
+          games.first
+        when 0
+          raise SearchException.new("Could not find a game containing the string \"#{game_name}\" on platform \"#{platform}\"!")
+        else
+          raise SearchException.new("Found more than one game containing the string \"#{game_name}\": #{games.join(', ')}")
+        end
+      end
+    end
+    
+    class << self  
+      
+      def platform(platform_name)
+        # get by full name (case insensitive)
+        names = List.platforms.select { |p| p.name.downcase == platform_name.downcase }
+        # find other similar if not found exactly one before
+        if names.size != 1
+          names = List.platforms.select{|p| p.name.downcase =~ /#{platform_name.split(' ').join('.*')}/i}
+        end
+
+        case names.size
+        when 1
+          names.first
+        when 0
+          raise SearchException.new("Could not find a platform containing the string \"#{platform_name}\"!")
+        else
+          raise SearchException.new("Found more than one platform containing the string \"#{platform_name}\": #{names.join(', ')}")
+        end
+      end
+      
+    private  
+      def add_params(keywords, platform)
+        "?game=#{keywords.gsub(/ /, '+')}" << "&platform=#{platform.id}"
+      end
+    end
+  end
+end