rsteamshot 0.1.1

data/lib/rsteamshot/screenshot.rb

@@ -0,0 +1,224 @@
+module Rsteamshot
+  # Public: Represents an image that has been uploaded to Steam of a screenshot taken
+  # in a Steam app.
+  class Screenshot
+    # Public: Returns a String of how the user described this screenshot, or nil.
+    attr_reader :title
+
+    # Public: Returns String URL to the Steam page that shows details about this screenshot.
+    attr_reader :details_url
+
+    # Public: Returns String URL to the full-size image.
+    attr_reader :full_size_url
+
+    # Public: Returns String URL to a medium-size version of the image.
+    attr_reader :medium_url
+
+    # Public: Returns String name of the Steam user who uploaded the screenshot.
+    attr_reader :user_name
+
+    # Public: Returns String URL to the profile of the Steam user who uploaded the screenshot.
+    attr_reader :user_url
+
+    # Public: Returns the DateTime when this screenshot was uploaded.
+    attr_reader :date
+
+    # Public: Returns a String describing how large the screenshot is, e.g., 0.547 MB.
+    attr_reader :file_size
+
+    # Public: Returns Integer pixel width of the screenshot.
+    attr_reader :width
+
+    # Public: Returns Integer pixel height of the screenshot.
+    attr_reader :height
+
+    # Public: Returns Integer count of how many people have voted for this screenshot.
+    attr_reader :like_count
+
+    # Public: Returns Integer count of how many comments people have left on this screenshot.
+    attr_reader :comment_count
+
+    # Public: Initialize a screenshot with the given attributes.
+    #
+    # attrs - the Hash of attributes for this screenshot
+    #         :title - how the user described this screenshot
+    #         :details_url - URL to the Steam page that shows details about this screenshot
+    #         :full_size_url - URL to the full-size image
+    #         :medium_url - URL to a medium-size version of the image
+    #         :user_name - name of the Steam user who uploaded the screenshot
+    #         :user_url - URL to the profile of the Steam user who uploaded the screenshot
+    #         :date - the date and time when this screenshot was uploaded
+    #         :file_size - describes how large the screenshot is, e.g., 0.547 MB
+    #         :width - pixel width of the screenshot
+    #         :height - pixel height of the screenshot
+    #         :like_count - number of likes this screenshot has on Steam
+    #         :comment_count - number of comments this screenshot has received on Steam
+    def initialize(attrs = {})
+      attrs.each { |key, value| instance_variable_set("@#{key}", value) }
+
+      fetch_details unless has_details?
+    end
+
+    # Public: Get a hash representation of this screenshot.
+    #
+    # Returns a Hash.
+    def to_h
+      result = { details_url: details_url }
+      result[:title] = title if title
+      result[:full_size_url] = full_size_url if full_size_url
+      result[:medium_url] = medium_url if medium_url
+      result[:user_name] = user_name if user_name
+      result[:user_url] = user_url if user_url
+      result[:date] = date if date
+      result[:file_size] = file_size if file_size
+      result[:width] = width if width
+      result[:height] = height if height
+      result[:like_count] = like_count if like_count
+      result[:comment_count] = comment_count if comment_count
+      result
+    end
+
+    # Public: Get a JSON representation of this screenshot.
+    #
+    # Returns a String.
+    def to_json
+      JSON.pretty_generate(to_h)
+    end
+
+    # Public: A detailed representation of this screenshot.
+    #
+    # Returns a String.
+    def inspect
+      self.class.name + '<' + JSON.generate(to_h) + '>'
+    end
+
+    private
+
+    def has_details?
+      !full_size_url.nil? && !medium_url.nil?
+    end
+
+    def fetch_details
+      return unless details_url
+
+      Mechanize.new.get(details_url) do |page|
+        link = page.at('.actualmediactn a')
+        @full_size_url = link['href'] if link
+
+        @medium_url = medium_url_from(page)
+        @like_count = like_count_from(page)
+        @comment_count = comment_count_from(page)
+
+        author = page.at('.creatorsBlock')
+        @user_name = user_name_from(author)
+        @user_url = user_url_from(author)
+
+        details_block = details_block_from(page)
+        if details_block
+          labels_container = details_block.at('.detailsStatsContainerLeft')
+          if labels_container
+            label_els = labels_container.search('.detailsStatLeft')
+            labels = label_els.map { |el| el.text.strip.gsub(/[[:space:]]\z/, '') }
+          end
+
+          values_container = details_block.at('.detailsStatsContainerRight')
+          if values_container
+            value_els = values_container.search('.detailsStatRight')
+            values = value_els.map { |el| el.text.strip.gsub(/[[:space:]]\z/, '') }
+          end
+
+          labelled_values = labels.zip(values).to_h
+          @file_size = labelled_values['File Size']
+          @date = date_from(labelled_values['Posted'])
+          @width, @height = dimensions_from(labelled_values['Size'])
+        end
+      end
+    end
+
+    def details_block_from(page)
+      details_blocks = page.search('.rightDetailsBlock')
+      details_blocks.detect do |details_block|
+        labels_container = details_block.at('.detailsStatsContainerLeft')
+        !labels_container.nil?
+      end
+    end
+
+    def medium_url_from(page)
+      img = page.at('img#ActualMedia')
+      return unless img
+
+      img['src']
+    end
+
+    def like_count_from(page)
+      rate_el = page.at('.rateUpCount')
+      return 0 unless rate_el
+
+      text = rate_el.text.strip.gsub(/[[:space:]]\z/, '')
+      if text.length > 0
+        text.to_i
+      else
+        0
+      end
+    end
+
+    def comment_count_from(page)
+      header_el = page.at('.commentthread_count_label')
+      return 0 unless header_el
+
+      span = header_el.at('span')
+      return 0 unless span
+
+      text = span.text.strip.gsub(/[[:space:]]\z/, '')
+      if text.length > 0
+        text.to_i
+      else
+        0
+      end
+    end
+
+    def user_name_from(author)
+      container = author.at('.friendBlockContent')
+      return unless container
+
+      all_text = container.text
+      online_status = container.at('.friendSmallText')
+      return all_text.strip.gsub(/[[:space:]]\z/, '') unless online_status
+
+      status_text = online_status.text
+      index = all_text.index(status_text)
+
+      user_name_text = if index
+        all_text.slice(0, index)
+      else
+        all_text
+      end
+
+      user_name_text.strip.gsub(/[[:space:]]\z/, '')
+    end
+
+    def user_url_from(author)
+      author_link = author.at('.friendBlockLinkOverlay')
+      return unless author_link
+
+      author_link['href']
+    end
+
+    def date_from(raw_date_str)
+      format = if raw_date_str.include?(',')
+        '%b %d, %Y @ %l:%M%P'
+      else
+        '%b %d @ %l:%M%P'
+      end
+      DateTime.strptime(raw_date_str, format)
+    end
+
+    def dimensions_from(dimension_str)
+      if dimension_str
+        dimension_str.split(' x ').map { |str| str.to_i }
+      else
+        []
+      end
+    end
+  end
+end

data/lib/rsteamshot/screenshot_page.rb

@@ -0,0 +1,62 @@
+module Rsteamshot
+  # Public: Represents a page of screenshots on Steam.
+  class ScreenshotPage
+    # Public: Returns the Integer number of this page.
+    attr_reader :number
+
+    # Public: Returns the Integer count of how many screenshots to fetch per page.
+    attr_reader :per_page
+
+    # Public: Returns an Array of the Rsteamshot::Screenshots found on this page.
+    attr_reader :screenshots
+
+    # Public: Construct a new ScreenshotPage with the given page number.
+    #
+    # number - the page number; Integer
+    # per_page - how many screenshots are shown on the Steam page
+    def initialize(number, per_page)
+      @number = number
+      @per_page = per_page
+    end
+
+    # Public: Check if the nth screenshot would be on this page on Steam.
+    #
+    # screenshot_number - the index of the screenshot you want to check
+    #
+    # Returns a Boolean.
+    def includes_screenshot?(screenshot_number)
+      range.cover?(screenshot_number)
+    end
+
+    # Public: Fetch the contents of this page from Steam.
+    #
+    # Returns a Mechanize::Page.
+    def fetch(base_url)
+      return if @screenshots # already fetched
+
+      url = with_steam_page_param(base_url)
+      Mechanize.new.get(url) do |html|
+        @screenshots = yield(html)
+      end
+    end
+
+    private
+
+    def min_screenshot
+      (number - 1) * per_page
+    end
+
+    def max_screenshot
+      min_screenshot + per_page
+    end
+
+    def range
+      min_screenshot...max_screenshot
+    end
+
+    def with_steam_page_param(base_url)
+      joiner = base_url.include?('?') ? '&' : '?'
+      "#{base_url}#{joiner}p=#{number}"
+    end
+  end
+end

data/lib/rsteamshot/screenshot_paginator.rb

@@ -0,0 +1,77 @@
+module Rsteamshot
+  # Public: Use to paginate screenshots fetched from Steam in chunks of fewer than
+  # 50 per page.
+  class ScreenshotPaginator
+    # Public: Construct a new ScreenshotPaginator that will process a page of HTML
+    # using the given lambda.
+    #
+    # process_html - a lambda that will take a Mechanize::Page and return a list of
+    #                Rsteamshot::Screenshot instances found in that page
+    # max_per_page - the most screenshots that can be returned in a page, based on how many
+    #                screenshots can be shown on the Steam page
+    # per_page - how many screenshots you want returned; Integer; should be less than or
+    #            equal to max_per_page
+    # steam_per_page - how many screenshots will actually be on the Steam page; Integer; should be
+    #                  less than or equal to max_per_page
+    def initialize(process_html, max_per_page:, per_page: 10, steam_per_page:)
+      @process_html = process_html
+      @screenshot_pages = []
+      @max_per_page = max_per_page
+      @raw_per_page = per_page
+      @steam_per_page = normalize_per_page(steam_per_page)
+    end
+
+    # Public: Returns the Integer count of screenshots per page.
+    def per_page
+      @per_page = normalize_per_page(@raw_per_page)
+    end
+
+    # Public: Get the specified number of screenshots from the given Steam URL.
+    #
+    # page - which page of results to fetch; Integer; defaults to 1
+    # url - URL to a Steam page with screenshots, should not include a page parameter; String
+    #
+    # Returns an Array of Rsteamshot::Screenshots.
+    def screenshots(page: 1, url:)
+      offset = get_offset(page)
+      fetch_screenshots(offset, url).drop(offset).take(per_page)
+    end
+
+    private
+
+    def get_offset(page)
+      page = [page.to_i, 1].max
+      (page - 1) * per_page
+    end
+
+    def fetch_screenshots(offset, base_url)
+      screenshot_page = @screenshot_pages.detect { |page| page.includes_screenshot?(offset) }
+      fetch_necessary_screenshots(offset, base_url) unless screenshot_page
+      @screenshot_pages.flat_map(&:screenshots)
+    end
+
+    def fetch_necessary_screenshots(offset, base_url)
+      screenshot_page = ScreenshotPage.new(next_page_number, @steam_per_page)
+      screenshot_page.fetch(base_url) { |html| @process_html.(html) }
+      @screenshot_pages << screenshot_page
+
+      while !screenshot_page.includes_screenshot?(offset)
+        screenshot_page = ScreenshotPage.new(screenshot_page.number + 1, @steam_per_page)
+        screenshot_page.fetch(base_url) { |html| @process_html.(html) }
+        @screenshot_pages << screenshot_page
+      end
+    end
+
+    def next_page_number
+      last_page = @screenshot_pages.last
+      last_page ? last_page.number : 1
+    end
+
+    def normalize_per_page(raw_value)
+      value = raw_value.to_i
+      value = 1 if value < 1
+      value = @max_per_page if value > @max_per_page
+      value
+    end
+  end
+end

data/lib/rsteamshot/user.rb

@@ -0,0 +1,77 @@
+module Rsteamshot
+  # Public: Represents a Steam user. Used to fetch the user's screenshots they have
+  # uploaded to Steam.
+  class User
+    # Public: How to sort screenshots when they are being retrieved.
+    VALID_ORDERS = %w[newestfirst score oldestfirst].freeze
+
+    # Public: How many screenshots are shown on a user's profile per page.
+    STEAM_PER_PAGE = 50
+
+    # Public: Returns a String user name from a Steam user's public profile.
+    attr_reader :user_name
+
+    # Public: Initialize a Steam user with the given user name.
+    #
+    # user_name - a String
+    # per_page - how many screenshots to get in each page; defaults to 10; valid range: 1-50;
+    #            Integer
+    def initialize(user_name, per_page: 10)
+      @user_name = user_name
+
+      process_html = ->(html) do
+        links_from(html).map { |link| screenshot_from(link) }
+      end
+      @paginator = ScreenshotPaginator.new(process_html, max_per_page: STEAM_PER_PAGE,
+                                           per_page: per_page, steam_per_page: STEAM_PER_PAGE)
+    end
+
+    # Public: Fetch a list of the user's newest uploaded screenshots.
+    #
+    # order - String specifying which screenshots should be retrieved; choose from newestfirst,
+    #         score, and oldestfirst; defaults to newestfirst
+    # page - which page of results to fetch; defaults to 1; Integer
+    # app_id - optional Steam app ID as an Integer or String, to get screenshots from this user for
+    #          the specified app; defaults to including all apps
+    #
+    # Returns an Array of Rsteamshot::Screenshots.
+    def screenshots(order: nil, page: 1, app_id: 0)
+      return [] unless user_name
+
+      url = steam_url(order, app_id)
+      @paginator.screenshots(page: page, url: url)
+    end
+
+    private
+
+    def links_from(html)
+      html.search('#image_wall .imageWallRow .profile_media_item')
+    end
+
+    def screenshot_from(link)
+      details_url = link['href']
+      description = link.at('.imgWallHoverDescription')
+      title = description ? description.text.strip : nil
+      Screenshot.new(title: title, details_url: details_url)
+    end
+
+    def steam_url(order, app_id = 0)
+      params = [
+        "appid=#{URI.escape(app_id.to_s)}",
+        "sort=#{sort_param(order)}",
+        'browsefilter=myfiles',
+        'view=grid'
+      ]
+      user_param = URI.escape(user_name)
+      "http://steamcommunity.com/id/#{user_param}/screenshots/?" + params.join('&')
+    end
+
+    def sort_param(order)
+      if VALID_ORDERS.include?(order)
+        order
+      else
+        VALID_ORDERS.first
+      end
+    end
+  end
+end

data/lib/rsteamshot/version.rb

@@ -0,0 +1,4 @@
+module Rsteamshot
+  # Public: The current version of the Rsteamshot gem.
+  VERSION = '0.1.1'
+end

data/lib/rsteamshot.rb

@@ -0,0 +1,15 @@
+require 'json'
+require 'mechanize'
+require 'open-uri'
+require 'rsteamshot/app'
+require 'rsteamshot/screenshot'
+require 'rsteamshot/screenshot_page'
+require 'rsteamshot/screenshot_paginator'
+require 'rsteamshot/user'
+require 'rsteamshot/version'
+require 'uri'
+
+# Public: Contains classes for finding screenshots uploaded by users to Steam. Screenshots
+# are from Steam games (apps).
+module Rsteamshot
+end

data/rsteamshot.gemspec

@@ -0,0 +1,32 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rsteamshot/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rsteamshot'
+  spec.version       = Rsteamshot::VERSION
+  spec.authors       = ['Sarah Vessels']
+  spec.email         = ['cheshire137@gmail.com']
+
+  spec.summary       = %q{Get Steam screenshots for different games or users.}
+  spec.description   = %q{Find the latest screenshots a user has uploaded to Steam, as well as the latest screenshots for specific games.}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.15'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rdoc', '~> 5.1.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'vcr', '~> 3.0.3'
+  spec.add_development_dependency 'webmock', '~> 3.1.0'
+
+  spec.add_runtime_dependency 'mechanize', '~> 2.7.5'
+end