steam_mist 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9a5179398426a0232c5d3a8c68654c467594b1bb
+  data.tar.gz: bc17eacb58ff02a732c157d66b7ea8998b498184
+SHA512:
+  metadata.gz: b751537ee70d925a7bb5a658810aabf6d1b2fd762eedc6e87b6e2d332df2c8d68d0999ac346ce6fb9f40e396cfc2448276b3ee1a42255a20abfb50d4bc3bd760
+  data.tar.gz: 77f86e721378b036199be3ce101d03ec0bdecd0c46d8c12da60084416dea406287994064bf170bb8bf69c70cd0020dc4d3434536ddfbe3b044a85af913cac0d5

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2013 Jeremy Rodi
+
+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,29 @@
+# SteamMist [![Build Status](https://travis-ci.org/redjazz96/steam-mist.png?branch=master)](https://travis-ci.org/redjazz96/steam-mist) [![Code Climate](https://codeclimate.com/github/redjazz96/steam-mist.png)](https://codeclimate.com/github/redjazz96/steam-mist)
+Steam Mist (for the lack of a better name) is a library for interfacing with
+the Steam Web API.  It handles the HTTP requests for you while providing a
+nice API for you to use.
+
+Have some code samples:
+
+```Ruby
+require 'steam_mist'
+session = SteamMist::Session.new SteamMist::Connectors::LazyConnector
+session.default_arguments.merge! :key => "XXXXXXXXXXXXXXXXXXX", :format => :json
+method = session.player_service.get_recently_played_games.with_version(1) \
+	.with_arguments(:steamid => "76561198025418738")
+
+method.request_uri # => 
+	# http://api.steampowered.com/IPlayerService/GetRecentlyPlayedGames/v0001/
+	# 	?key=XXXXXXXXXXXXXXXXX&steamid=76561197960434622&format=json
+# It's a URI object so #inspect doesn't include the quotes ;)
+method.get # => #<SteamMist::Connectors::LazyConnector>
+method.get.data # => our json data
+```
+
+```Ruby
+rcon = SteamMist::Rcon.new("localhost")
+rcon.auth("password") # => true
+rcon.send(:data => "echo hello") # =>
+	# [..., #<SteamMist::Rcon::Packet @body="hello\n", @type=0>, ...]
+rcon.close
+```

data/lib/steam_mist/connector.rb

@@ -0,0 +1,167 @@
+require 'open-uri'
+require 'time'
+require 'fileutils'
+
+module SteamMist
+
+  # @abstract Subclass and implement {#[], #each} to create a connector usable 
+  #   by SteamMist.
+  # @todo Test caching.
+  class Connector
+
+    include Enumerable
+
+    # This is the data that the connector received from Steam.  It may be null
+    # if the connector is lazy (in terms of when it grabs data).
+    #
+    # @return [Hash, nil]
+    attr_reader :data
+
+    # This is the request that the connector used to grab information from the
+    # steam api.
+    #
+    # @return [RequestUri]
+    attr_reader :request_uri
+
+    # Whether or not the connector has made the request to the API.
+    #
+    # @return [Boolean]
+    attr_reader :made_request
+
+    # This is a hash of headers that will be sent upon request.
+    #
+    # @return [Hash]
+    attr_reader :headers
+
+    # This initializes the connector.
+    #
+    # @param request_uri [RequestUri] the request uri to connect to.
+    def initialize(request_uri)
+      @request_uri = request_uri
+      @headers = {}
+      @cache = false
+    end
+
+    # Retrieve data from #data.  This is normally used to force the connector
+    # (if it's lazy) to grab data.
+    #
+    # @param _ [Object] the key for data access.
+    # @raise NotImplementedError if the subclass hasn't implemented the method.
+    # @return [Object]
+    def [](_)
+      raise NotImplementedError
+    end
+
+    # This loops through the data.  It should be implented for enumerable
+    # access.
+    #
+    # @raise NotImplementedError if the subclass hasn't implemented the method.
+    # @return [void]
+    def each
+      raise NotImplementedError
+    end
+
+    # If the connector is lazy, this should force the connector to make the
+    # request to Steam.
+    #
+    # @param force [Boolean] whether or not to force the request to
+    #   return fresh data.
+    # @return [Hash] the data from the request to steam.
+    def force_request!(force = false)
+      @data = with_cache(force) { Oj.load(request, :mode => :strict) }
+    end
+
+    # Enables caching on this connector.
+    #
+    # @param path [String] the path to the cache file.
+    # @return [Object]
+    def enable_caching(path)
+      @cache = path
+    end
+
+    # Whether or not this connector will cache the response.
+    #
+    # @return [Boolean]
+    def cache?
+      !!@cache
+    end
+
+    # Disables caching on this connector.
+    #
+    # @return [false]
+    def disable_caching
+      @cache = false
+    end
+
+    protected
+
+    # The request used for retrieving information from Steam.
+    #
+    # @return [IO]
+    def request
+      @_request ||= open(request_uri, headers)
+    end
+
+    # This handles caching the file, if it was requested.  Accepts a
+    # single block, which it yields to only when the cache data wasn't
+    # there.
+    #
+    # @return [Hash] the data.
+    def with_cache(force = false)
+      if cache
+        headers['If-Modified-Since'] = cache[:last_modified].utc.rfc2822
+      end
+
+      if force || !cache
+        write_cache yield
+      else
+        cache[:data]
+      end
+
+    rescue OpenURI::HTTPError => ex
+      if ex.message =~ /\A304 Not Modified\z/
+        return cache[:data]
+      else
+        raise ex
+      end
+    end
+
+    # Loads the data from the cache file.
+    #
+    # @param force [Boolean] whether or not to force loading from the
+    #   file again.
+    def cache(force = false)
+      return nil unless cache? && File.exists?(@cache)
+
+      @_cache = if force || !@_cache
+        File.open(@cache) { |f| Oj.load(f) }[request_uri.to_s]
+      else
+        @_cache
+      end
+    end
+
+    # Writes the cache data to the file, and forces a reload of the
+    # cache data in memory.
+    #
+    # @param data [Object] the data to store.
+    # @return [Object] the data stored.
+    def write_cache(data)
+      return data unless cache?
+      write_data = {
+        request_uri.to_s => {
+          :data => data,
+          :last_modified => Time.now
+        }
+      }
+
+      FileUtils.mkdir_p File.dirname(@cache)
+      File.open(@cache, "w") do |f|
+        f.write Oj.dump(write_data, :time_format => :ruby)
+      end
+
+      cache(true)
+      data
+    end
+    
+  end
+end

data/lib/steam_mist/connectors/eager_connector.rb

@@ -0,0 +1,24 @@
+module SteamMist
+  module Connectors
+
+    # An eager connector that forces the request on initialization.
+    class EagerConnector < Connector
+
+      extend Forwardable
+
+      # Calls `super` and then {#force_request!}.
+      def initialize(_)
+        super
+
+        @data = force_request!
+      end
+
+      # Implements the {#[]} method.
+      def_delegator :@data, :[]
+
+      # Implements the {#each} method.
+      def_delegator :@data, :each
+      
+    end
+  end
+end

data/lib/steam_mist/connectors/lazy_connector.rb

@@ -0,0 +1,33 @@
+module SteamMist
+  module Connectors
+
+    # Lazily loads the data from Steam, which means the request is made only
+    # when or if the data is accessed.
+    class LazyConnector < Connector
+
+      extend Forwardable
+
+    	# Provides access to the data.
+    	#
+    	# @return [Object]
+      def [](name)
+        data[name]
+      end
+
+      # This provides access to {#each} on the data.
+      #
+      # @see {Hash#each}.
+      def_delegator :data, :each
+
+      # This makes sure that the data was requested before it was used by
+      # checking if data is full (and if it isn't, fill it with the data from
+      # {#force_request!}).
+      #
+      # @return [Hash] the data.
+      def data
+      	@data ||= force_request!
+      end
+
+    end
+  end
+end

data/lib/steam_mist/connectors.rb

@@ -0,0 +1,11 @@
+module SteamMist
+
+  # The connectors that will be used by SteamMist.
+  module Connectors
+
+    autoload :LazyConnector, "steam_mist/connectors/lazy_connector"
+
+    autoload :EagerConnector, "steam_mist/connectors/eager_connector"
+
+  end
+end

data/lib/steam_mist/pseudo_interface/pseudo_method.rb

@@ -0,0 +1,187 @@
+module SteamMist
+  class PseudoInterface
+
+    # A representation of a Steam Web API method.
+    class PseudoMethod
+
+      # The version of the method.  Used for {RequestUri}.
+      #
+      # @return [Numeric] the version.
+      attr_reader :version
+
+      # The name of the method.
+      #
+      # @return [Symbol] the name.
+      attr_reader :name
+
+      # The interface that this method is a part of.
+      #
+      # @return [PseudoInterface] the interface.
+      attr_reader :interface
+
+      # The arguments passed along with the method.
+      #
+      # @return [Hash] the arguments.
+      attr_reader :arguments
+
+      # Whether or not the connector is going to implement caching.
+      #
+      # @return [Boolean]
+      attr_reader :cached
+
+      # Initialize the method.
+      #
+      # @param interface [PseudoInterface] the interface this method is a part
+      #   of.  Used to help build the {RequestUri}.
+      # @param method [Symbol] the name of the method.  See {#api_name} on how
+      #   it's used.
+      # @param version [Numeric] the version of the method.  Can be found on
+      #   the steam web api wiki.
+      def initialize(interface, method, version=1)
+        @interface   = interface
+        @name        = method
+        @version     = version
+        @arguments   = {}
+        @cached      = false
+      end
+
+      # This merges the passed hash with the arguments.
+      #
+      # @param new_arguments [Hash] the arguments to be added.
+      # @return [PseudoMethod] a {PseudoMethod} with the new arguments.
+      def with_arguments(new_arguments)
+        dup.with_arguments! new_arguments
+      end
+
+      # This merges the current arguments with the passed arguments.  This
+      # modifies the instance it is called on.   Invalidates the current
+      # connector.
+      #
+      # @param new_arguments [Hash] the arguments to merge with.
+      # @return [self]
+      def with_arguments!(new_arguments)
+        @arguments.merge!(new_arguments)
+        reset_connector
+      end
+
+      # This sets the version.
+      #
+      # @param new_version [Numeric] the version number to use.
+      # @return [PseudoMethod] a {PseudoMethod} with the version set to the
+      #   new version.
+      def with_version(new_version)
+        dup.with_version!(new_version)
+      end
+
+      # Sets the version of the current method.  This modifies the instance it
+      # is called on.  Invalidates the current connector.
+      #
+      # @param new_version [Numeric] the version to set to.
+      # @return [self]
+      def with_version!(new_version)
+        @version = new_version
+        reset_connector
+      end
+
+      # This makes sure the connector is set up to cache its results.  Does not
+      # modify the connector until {#get} is called.
+      #
+      # @param path [String] the path of the cache file.
+      # @return [PseudoMethod] a {PseudoMethod} with caching.
+      def with_caching(path)
+        dup.with_caching!(path)
+      end
+
+      # This modifies the current method to make sure the connector is set up
+      # to cache its results.  Invalidates the current connector.
+      #
+      # @param path [String] the path of the cache file.
+      # @return [self]
+      def with_caching!(path)
+        @cached = path
+        reset_connector
+      end
+
+      # This makes sure the connector is set up to not cache its results.
+      #
+      # @return [PseudoMethod] a {PseudoMethod} without caching.
+      def without_caching
+        dup.without_caching!
+      end
+
+      # This modifies the current method to make sure the connector is set up
+      # to not cache its results.  Invalidates the current connector.
+      #
+      # @return [self]
+      def without_caching!
+        @cached = false
+        reset_connector
+      end
+
+      # Open up a connector for use.  This is cached with this method.
+      #
+      # @return [Connector] the connector that will grab data.
+      def get
+        @_connector ||= begin
+          connector = interface.session.connector.new(request_uri)
+
+          if @cached
+            connector.enable_caching @cached
+          end
+
+          connector
+        end
+      end
+
+      # Turns the method name into the name the Steam Web API uses.  It turns
+      # the method name from snake case to camel case if the first character
+      # isn't uppercase.  Otherwise, it uses the string form of it.
+      #
+      # @return [String] the Steam Web API compatible method name.
+      def api_name
+        @_api_name ||= begin
+          str = name.to_s
+
+          if str[0] =~ /[A-Z]/
+            str
+          else
+            str.gsub!(/_[a-z]/) { |m| m[1].upcase }
+            str[0] = str[0].upcase
+            str
+          end
+        end
+      end
+
+      # This turns the method into its corresponding {RequestUri}.  It uses
+      # {#api_name} and {PseudoInterface#api_name} to help create the uri.
+      #
+      # @return [RequestUri]
+      def request_uri
+        @_request_uri ||= RequestUri.new :interface => interface.api_name,
+          :method    => api_name,
+          :arguments => interface.session.default_arguments.dup.merge(arguments),
+          :version   => version
+      end
+
+      # Pretty inspection.
+      #
+      # @return [String]
+      def inspect
+        "#<SteamMist::PseudoInterface::PseudoMethod #{interface.name}/#{name}>"
+      end
+
+      private
+
+      # This is used to show that the connector is out of date; it forces the
+      # method to use a seperate connector.
+      #
+      # @return [self]
+      def reset_connector
+        @_connector = nil
+        @_request_uri = nil
+        self
+      end
+
+    end
+  end
+end

data/lib/steam_mist/pseudo_interface.rb

@@ -0,0 +1,75 @@
+require 'steam_mist/pseudo_interface/pseudo_method'
+
+module SteamMist
+  # This basically represents an interface for the Web API.
+  class PseudoInterface
+
+    # The interface's name that this is representing.  This should be in
+    # underscore form.
+    # 
+    # @return [Symbol] the name of the interface.
+    attr_reader :name
+
+    # The session that the interface is running under.  This is used mainly for
+    # the connector.
+    #
+    # @return [Session]
+    attr_reader :session
+
+    # Initialize the pseudointerface with the interface name.  See {#api_name}
+    # for information about how this is handled.
+    #
+    # @param session [Session] the session the interface is a part of.
+    # @param interface_name [Symbol] the interface name.
+    def initialize(session, interface_name)
+      @name     = interface_name
+      @session  = session
+    end
+
+    # Grab a method from this interface.
+    #
+    # @param method_name [Symbol] the name of the method.
+    # @param version [Numeric] the version of the method.
+    # @return [PseudoMethod]
+    def get_method(method_name, version=1)
+      PseudoMethod.new(self, method_name, version)
+    end
+
+    # Turns the interface name into the corresponding api name.  If the
+    # interface starts with an `I`, it makes no modifications to it (other than
+    # turning it into a string).  If it doesn't, however, it turns it from
+    # snake case to camel case (i.e. `some_interface` to `SomeInterface`).
+    # It then adds an `I` to the front of it.
+    #
+    # @return [String] the API name used by the Steam Web API.
+    def api_name
+      @_api_name ||= begin
+        str = name.to_s
+
+        if str[0] == "I"
+          str
+        else
+          str.gsub!(/_([a-z])/) { |m| m[1].upcase }
+          str[0] = str[0].upcase
+          "I#{str}"
+        end
+      end
+    end
+
+    # Some {#method_missing} magic.  Sorry @charliesome!
+    #
+    # @see {#get_method}
+    def method_missing(method, *args)
+      super if args.length > 1 or block_given?
+      get_method method, *args
+    end
+
+    # Pretty inspection.
+    #
+    # @return [String]
+    def inspect
+      "#<SteamMist::PseudoInterface #{name}>"
+    end
+
+  end
+end

data/lib/steam_mist/rcon/listener.rb

@@ -0,0 +1,114 @@
+module SteamMist
+  class Rcon
+
+    # Listens on a TCP stream for packets.  This is completely synchronus.
+    class Listener
+
+      extend Forwardable
+
+      # The ip address this listener is bound to.
+      #
+      # @return [String]
+      attr_reader :ip
+
+      # The port the listener is bound to.
+      #
+      # @return [Numeric]
+      attr_reader :port
+
+      # The connection the listener is using.
+      #
+      # @return [TCPSocket]
+      attr_reader :connection
+      
+      # Initialize the listener.
+      #
+      # @param ip [String] the ip address to bind to.
+      # @param port [Numeric] the port to bind to.
+      def initialize(ip, port)
+        @ip     = ip
+        @port   = port
+        @closed = false
+      end
+
+      # Connect to the set port and ip address.
+      #
+      # @return [void]
+      def bind!
+        @connection = TCPSocket.new ip, port
+      end
+
+      # Sets the ip.
+      #
+      # @param new_ip [String]
+      # @raise [ArgumentError] if already connected.
+      # @return [void]
+      def ip=(new_ip)
+        raise ArgumentError, 
+          "Already connected; cannot change IP" if connection
+
+        @ip = new_ip
+      end
+
+      # Sets the port.
+      #
+      # @param new_port [Numeric]
+      # @raise [ArgumentError] if already connected.
+      # @return [void]
+      def port=(new_port)
+        raise ArgumentError,
+          "Already connected; cannot change port" if connection
+
+        @port = new_port
+      end
+
+      # Listens to the connection for any data; when there is some, it'll call
+      # the block and then return.
+      #
+      # @yieldparam socket [TCPSocket]
+      # @yieldreturn [void]
+      # @raise [TimeoutError] when select takes too long.
+      # @return [void]
+      def on_data
+        return false if closed?
+
+        result = IO.select [connection], [], [], 10
+
+        raise TimeoutError, "timeout" unless result
+
+        yield connection
+      end
+
+      # Closes the connection.
+      #
+      # @return [void]
+      def close
+        unless @closed
+          @closed = true
+          connection.close
+        end
+      end
+
+      # This returns true or false depending on whether or not the connection
+      # is closed.
+      #
+      # @return [Boolean]
+      def closed?
+        @closed
+      end
+
+      # This passes the write through to the connection if the connection isn't
+      # closed.
+      def write(*args, &block)
+        return false if closed?
+
+        puts "writing #{args[0]}"
+
+        connection.write(*args, &block)
+      end
+    end
+
+    # When {IO#select} takes too long to respond, this is raised.
+    class TimeoutError < IOError; end
+  end
+end