host 0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/.rvmrc

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional.
+environment_id="ruby-1.9.3-p0@host"
+
+#
+# Uncomment following line if you want options to be set only for given project.
+#
+# PROJECT_JRUBY_OPTS=( --1.9 )
+
+#
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+#
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+
+  if [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]]
+  then
+    . "${rvm_path:-$HOME/.rvm}/hooks/after_use"
+  fi
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  if ! rvm --create  "$environment_id"
+  then
+    echo "Failed to create RVM environment '${environment_id}'."
+    exit 1
+  fi
+fi
+
+#
+# If you use an RVM gemset file to install a list of gems (*.gems), you can have
+# it be automatically loaded. Uncomment the following and adjust the filename if
+# necessary.
+#
+# filename=".gems"
+# if [[ -s "$filename" ]]
+# then
+#   rvm gemset import "$filename" | grep -v already | grep -v listed | grep -v complete | sed '/^$/d'
+# fi
+
+# If you use bundler, this might be useful to you:
+# if command -v bundle && [[ -s Gemfile ]]
+# then
+#   bundle install
+# fi
+
+

data/Gemfile

@@ -0,0 +1,8 @@
+source "http://rubygems.org"
+
+group :development do
+  gem "rspec"
+  gem "guard-rspec"
+  gem "bundler"
+  gem "jeweler"
+end

data/Gemfile.lock

@@ -0,0 +1,32 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    git (1.2.5)
+    guard (0.8.4)
+      thor (~> 0.14.6)
+    guard-rspec (0.5.0)
+      guard (>= 0.8.4)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    thor (0.14.6)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler
+  guard-rspec
+  jeweler
+  rspec

data/Guardfile

@@ -0,0 +1,7 @@
+guard 'rspec', :cli => '--color --format doc' do
+  watch(%r{^spec/.+_spec\.rb$})
+
+  watch(%r{^lib/host/(.+)\.rb$}) { |m| "spec/host/#{m[1]}_spec.rb" } 
+  watch(%r{^lib/host/(.+)/(.+)\.rb$}) { |m| "spec/host/#{m[1]}/#{m[2]}_spec.rb" }
+  watch("spec/spec_helper.rb") { "spec" }
+end

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Renato Mascarenhas
+
+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.rdoc

@@ -0,0 +1,19 @@
+= host
+
+Description goes here.
+
+== Contributing to host
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Renato Mascarenhas. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require File.expand_path('lib/host/version')
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  gem.name = "host"
+  gem.version = Host::VERSION
+  gem.homepage = "http://github.com/rmascarenhas/host"
+  gem.license = "MIT"
+
+  gem.summary = %Q{Host provides a simple way to get useful information about
+                   your system}
+
+  gem.description = <<-END
+    Host is a symple library for accessing your host system information in runtime.
+    It allows you to get CPU and memory usage, the load average and more.
+    Different data is provided for different operating systems. Checkout the 
+    documentation on the Github page and help us support a wider range of
+    operating systems.    
+  END
+
+  gem.email = "haze-gem@googlegroups.com"
+  gem.authors = ["Fabio de Lima Pereira", "Rafael Regis do Prado", "Renato Mascarenhas"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "host #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/host.rb

@@ -0,0 +1,44 @@
+# lib/host.rb
+
+module Host
+
+  extend self
+
+  def linux?
+    check_platform('linux')
+  end
+
+  def macosx?
+    check_platform('darwin')
+  end
+
+  def self.os
+    return :linux if linux?
+    return :macosx if macosx?
+  end
+
+private
+
+  # Takes a string and returns a method name for that,
+  # using snake_case (instead of camelCase).
+  def methodize(name)
+    name.split(/([[:lower:]][[:upper:]]*)/).delete_if(&:empty?).each(&:downcase!).join('_')
+  end
+
+  # Checks if +RUBY_PLATFORM+ matches the given name
+  def check_platform(name)
+    !(RUBY_PLATFORM =~ Regexp.new(name)).nil?
+  end
+
+end
+
+require_relative 'host/hashifier'
+
+case Host.os
+when :linux then require_relative 'host/linux'
+end
+
+require_relative 'host/processor'
+require_relative 'host/memory'
+require_relative 'host/load_average'
+require_relative 'host/version'

data/lib/host/hashifier.rb

@@ -0,0 +1,47 @@
+# lib/host/hashifier.rb
+
+module Host
+
+  # Module for parse a string containing data into a hash of values.
+  # Given a string and regular expression that parses and saves key and
+  # value, this module returns the built hash.
+  #
+  # Used mainly to parse +/proc/cpuinfo+ and +/proc/meminfo+ files
+  # (and similars)
+  module Hashifier
+
+    # Builds an array of hashes with the data passed, since duplicate keys
+    # cause another entry to be stored in the array returned (as it was a
+    # representation of many resources of the same type).
+    #
+    # Note: the way it is implemented, you can pass not only a Ruby Array,
+    # but any object that responds to +<<+
+    #
+    # Example:
+    #   cpu = File.read('/proc/cpuinfo')
+    #   hashify(cpu, :regexp => /your regexp here/, :into => @cpu_info)
+    def hashify(data, options)
+      regexp = options[:regexp]
+      dest   = options[:into]
+
+      info = {}
+
+      data.each_line { |line|
+        matches = line.match(regexp)
+        next if matches.nil?
+
+        if info.has_key?(matches[1].strip.to_sym)
+          dest << info
+          info = {}
+        else
+          info[matches[1].strip.to_sym] = matches[2]
+        end
+      }
+
+      dest << info
+      
+    end
+
+  end
+
+end 

data/lib/host/linux.rb

@@ -0,0 +1,13 @@
+# lib/host/linux/linux.rb
+
+module Host
+
+ module Linux
+
+   require_relative 'linux/processor'
+   require_relative 'linux/memory'
+   require_relative 'linux/load_average'
+
+ end
+
+end 

data/lib/host/linux/load_average.rb

@@ -0,0 +1,59 @@
+# lib/hot/load_average.rb
+
+module Host
+
+  module Linux
+
+    # Implements the recovering of load average information on Linux systems
+    module LoadAverage
+
+      LAST_MINUTE, LAST_5_MINUTES, LAST_15_MINUTES = 0, 1, 2
+      RUNNING_PROCESSES = 3
+      TOTAL_PROCESSES = 4
+
+      # Returns the load average in the last +minutes+. If the parameter
+      # passed is neither 1, 5 or 15, then the value returned is the load
+      # average on the nearest time.
+      #
+      # For instance, Host::LoadAverage.on_last(4) will return the same as
+      # Host::LoadAverage.on_last(5).
+      def on_last(minutes)
+        @info[nearest(minutes)]
+      end
+
+      # Returns the number of currently running processes on the system.
+      def running_processes
+        @info[RUNNING_PROCESSES]
+      end
+
+      # Returns total number of processes on the system.
+      def total_processes
+        @info[TOTAL_PROCESSES]
+      end
+
+
+    private
+
+      # Retrieves information about load average on a Linux system,
+      # gathering the indices for the last minute, last 5 minutes
+      # and last 15 minutes.
+      def get_loadinfo 
+        loadavg = File.read('/proc/loadavg')
+        averages = loadavg.gsub(/\d+\.\d+/)
+
+        load_info
+
+        @info[LAST_MINUTE]      = averages.next.to_f
+        @info[LAST_5_MINUTES]   = averages.next.to_f
+        @info[LAST_15_MINUTES]  = averages.next.to_f
+
+        processes = loadavg.gsub(/\d+\/\d+/).first.split('/')
+
+        @info[RUNNING_PROCESSES] = processes[0].to_i
+        @info[TOTAL_PROCESSES]   = processes[1].to_i
+      end
+
+    end
+  end
+
+end

data/lib/host/linux/memory.rb

@@ -0,0 +1,66 @@
+# lib/host/linux/memory.rb
+
+module Host
+
+  module Linux
+
+    # Implements the retrieving of memory information on Linux systems.
+    module Memory
+
+      include Host::Hashifier
+
+      # Just sugar. Equivalent to Host::Memory.get('MemTotal') with
+      # implicit transformation to integer (in kB)
+      def total
+        as_integer @info[:MemTotal]
+      end
+
+      # Sugar. Equivalent to Host::Memory.get('MemFree') with implicit
+      # transformation to integer (in kB)
+      def free
+        as_integer @info[:MemFree]
+      end
+
+      # Sugar. Equivalent to Host::Memory.get('Buffers') with implicit
+      # transformation to integer (in kB)
+      def buffers
+        as_integer @info[:Buffers]
+      end
+
+      # Retrieves specific information for the given key (as some exotic
+      # information in +/proc/meminfo+, for instance).
+      def get(key)
+        @info[key.to_sym]
+      end
+
+        
+    private
+
+      # Returns the integer representation of the string, removing blank speces
+      # and kB unit
+      def as_integer(string)
+        string.gsub(/\s*|kB/, '').to_i
+      end
+
+      # Acts differently dependending on the operating systems.
+      # Raises +NotSupportedOperatingSystem+ if we cannot recognize the OS. 
+      def parse_meminfo
+        case Host.os
+        when :linux then parse_meminfo_linux
+        # other os...
+        end
+      end
+
+      # Opens +/proc/meminfo+ and parses it, storing the information in a 
+      # key-value manner.
+      def get_meminfo 
+        matcher   = /(.*):\s*(.*)$/
+        mem_info  = File.read('/proc/meminfo')
+
+        hashify mem_info, :regexp => matcher, :into => memory_info
+        @info = @info.first # we do not have multiple keys for memory information
+      end
+    end
+  end
+
+end

data/lib/host/linux/processor.rb

@@ -0,0 +1,78 @@
+# lib/host/linux/processor.rb
+
+module Host
+
+  module Linux
+
+    # Implements the gathering of processor information on a Linux system.
+    module Processor
+      include Host::Hashifier
+
+      # Returns the number of cores identified on the system 
+      def cores
+        @info.size
+      end
+
+      # returns an object containing the information of the core
+      # with the given +id+ (as in +/proc/cpuinfo+ for example). You can then
+      # get specific data on the returned object.
+      #
+      # Example:
+      #   p = Host::Processor.core(1)
+      #   p.model_name #=> "GenuineIntel"
+      def core(id)
+        @current_core = @info[id]
+        self
+      end
+
+      # Lets you iterate over the processor cores and get specific information.
+      # Similar to iterate on +cores+, using Host::Processor.core
+      def each_core
+        @info.each { |processor|
+          @current_core = processor
+          yield self
+        }
+      end
+
+      def model_name
+        @current_core && @current_core[:model_name]
+      end
+
+      # Returns an array of flags for the processor
+      def flags
+        if @current_core && @current_core.has_key?(:flags)
+          @current_core[:flags].split
+        else
+          []
+        end
+      end
+
+      # Retrieves a specific data stored on +/proc/cpuinfo+ for the
+      # given key.
+      def get(key)
+        @current_core && @current_core[key.to_sym]
+      end
+
+      private
+        
+      # Opens +/proc/cpuinfo+ and parses it, filling the info hash
+      # with all the information in that file
+      def get_cpuinfo
+        matcher = /(.*):\s*(.*)$/
+        cpu_info = File.read '/proc/cpuinfo'
+
+        hashify cpu_info, :regexp => matcher, :into => processor_info
+
+        @info.each do |processor|
+          processor.keys.each { |key|
+            processor[key.to_s.gsub(' ', '_').to_sym] = processor.delete(key)
+          } 
+        end
+      end
+
+
+    end
+
+  end
+
+end

data/lib/host/load_average.rb

@@ -0,0 +1,60 @@
+# lib/host/load_average.rb
+
+module Host
+
+  # Can provide the information on load average in the last 1 minute, 5 minutes
+  # and 15 minutes, as in +/proc/loadavg+ on Linux systems.
+  #
+  # Also, different information can be provided, depending on your operating system.
+  # On Linux, this class can also retrieve the number of running process (and the
+  # total number of processes).
+  #
+  # Help us support your operating system as well!
+  #
+  # Usage:
+  #   
+  #   # Supposing we are in a Linux box:
+  #   Host::LoadAverage.on_last(1)  #=> 0.2
+  #   Host::LoadAverage.on_last(5)  #=> 0.1
+  #   Host::LoadAverage.on_last(15) #=> 0.5
+  #
+  #   Host::LoadAverage.running_processes #=> 4
+  #   Host::LoadAverage.total_processes   #=> 312
+  class LoadAverage
+
+    class << self
+
+      def load_info
+        @info ||= []
+      end
+
+    private
+
+      # Returns the most recent known load average for the given number of
+      # minutes.
+      def nearest(minutes)
+        diff_1  = (minutes - 1).abs
+        diff_5  = (minutes - 5).abs
+        diff_15 = (minutes - 15).abs
+
+        diffs = [diff_1, diff_5, diff_15]
+        min = diffs.min
+
+        diffs.index(min)
+      end
+
+      # Takes a different action depending on the OS
+      def extend_loadavg 
+        case Host.os
+        when :linux then extend Linux::LoadAverage
+        # other os...
+        end
+      end
+    end
+
+    extend_loadavg
+    get_loadinfo
+
+  end
+
+end

data/lib/host/memory.rb

@@ -0,0 +1,47 @@
+# lib/host/memory.rb
+
+module Host
+
+  # Class representing memory in a system. As Host::Processor, this class
+  # is also operating system dependent, which means that different information
+  # is provided depending on your OS.
+  #
+  # The minimum information provided for the supported operating systems is:
+  # * total memory
+  # * free memory
+  #
+  # Other information can be retrieved via the Host::Processor.get method which
+  # returns the information associated with the given key (depending on your OS).
+  #
+  # Example usage:
+  #
+  #   Host::Memory.total    #=> "4023256 kB"
+  #   Host::Memory.free     #=> "2115874 kB"
+  #   # For specific information (as in +/proc/meminfo+ for instance), 
+  #   # you can use the +get+ method
+  #   Host::Memory.get('KernelStack') #=> "1080 kB"
+  class Memory
+
+    class << self
+
+      def memory_info
+        @info ||= []
+      end
+
+      # Acts differently dependending on the operating systems.
+      # Raises +NotSupportedOperatingSystem+ if we cannot recognize the OS. 
+      def extend_memory 
+        case Host.os
+        when :linux then extend Linux::Memory 
+        # other os...
+        end
+      end
+
+    end
+    
+    extend_memory
+    get_meminfo
+
+  end
+
+end

data/lib/host/processor.rb

@@ -0,0 +1,48 @@
+# lib/host/processor.rb
+
+
+module Host
+
+  # Class used to hold information about the system processor.
+  # Gathers information acording to the operating system and provides
+  # an easy way to access them.
+  # Important: the information that this class can retrieve depends on
+  # the host operating system. Linux is the better choice if you want
+  # a wide amount of information (as in /proc/cpuinfo). Other systems
+  # are also supported, such as OSX and FreBSD, but not as many
+  # informaiton cane be provided. Help us to enhance our support for
+  # many different operating systems!
+  #
+  # The minimum functionality provided is:
+  # * get the number of cores
+  # * get information about a specific core
+  # * iterate over cores
+  # * get the model name
+  class Processor
+    class << self
+
+      def processor_info 
+        @info ||= []
+      end
+
+    private
+
+     # Depending on the operating system, a different action is taken here,
+     # since there is no "one size fits them all" way of getting such
+     # information.
+      def extend_processor
+        puts Host.os
+        case Host.os
+        when :linux then extend Linux::Processor 
+        # other OS..
+        end
+      end
+
+    end
+
+    extend_processor
+    get_cpuinfo
+
+  end
+
+end

data/lib/host/version.rb

@@ -0,0 +1,7 @@
+# lib/host/version.rb
+
+module Host
+
+  VERSION = "0.1"
+
+end

data/spec/host/linux/load_average_spec.rb

@@ -0,0 +1,32 @@
+require_relative '../../spec_helper'
+
+describe Host::LoadAverage do
+
+  if Host.linux?
+    it 'should retrieve the load average on the last minute' do 
+      Host::LoadAverage.on_last(1).should be_kind_of Float
+    end
+
+    it 'should get the load average on the last 5 minutes' do 
+      Host::LoadAverage.on_last(5).should be_kind_of Float
+    end
+
+    it 'should get the load average on the last 15 minutes' do 
+      Host::LoadAverage.on_last(15).should be_kind_of Float
+    end
+
+    it 'should retrieve load average on the most recent known time' do
+      Host::LoadAverage.on_last(2).should == Host::LoadAverage.on_last(1)
+    end
+
+    it 'should get the number of currently running processes' do
+      Host::LoadAverage.running_processes.should > 0
+    end
+
+    it 'should get the total number of processes on the system' do
+      Host::LoadAverage.total_processes.should > 0
+    end
+
+  end
+
+end

data/spec/host/linux/memory_spec.rb

@@ -0,0 +1,24 @@
+require_relative '../../spec_helper'
+
+describe Host::Memory do
+
+  if Host.linux?
+    it 'should get the total memory' do 
+      Host::Memory.total.should > 0
+    end
+
+    it 'should get the available free memory' do
+      Host::Memory.free.should > 0
+    end
+
+    it 'should return nil when trying to get invalid information' do
+      Host::Memory.get('ZOMG').should be_nil
+    end
+
+    it 'should retrieve specific information, such as KernelStack' do
+      Host::Memory.get('KernelStack').should be_kind_of String
+    end
+
+  end
+
+end

data/spec/host/linux/processor_spec.rb

@@ -0,0 +1,24 @@
+require_relative '../../spec_helper'
+
+describe Host::Linux::Processor do
+    
+  if Host.linux?
+    it 'should get the number of cores' do
+      Host::Processor.cores.should > 0
+    end
+
+    it 'should get the model name via a method' do
+      Host::Processor.core(0).model_name.should be_kind_of String
+    end
+
+    it 'should iterate over the cores' do
+      Host::Processor.each_core { |core|
+        core.get(:core_id).should be_kind_of String 
+      }
+    end 
+
+    it 'should retrieve the processor flags' do
+      Host::Processor.core(0).flags.should be_kind_of Array
+    end
+  end
+end

data/spec/host/load_average_spec.rb

@@ -0,0 +1,5 @@
+require_relative '../spec_helper'
+
+describe Host::LoadAverage do
+
+end

data/spec/host/memory_spec.rb

@@ -0,0 +1,5 @@
+require_relative '../spec_helper'
+
+describe Host::Memory do
+
+end

data/spec/host/processor_spec.rb

@@ -0,0 +1,5 @@
+require_relative '../spec_helper'
+
+describe Host::Processor do
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'host'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: host
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- Fabio de Lima Pereira
+- Rafael Regis do Prado
+- Renato Mascarenhas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &3194300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *3194300
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &3192320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *3192320
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &3190380 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *3190380
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &3188920 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *3188920
+description: ! "    Host is a symple library for accessing your host system information
+  in runtime.\n    It allows you to get CPU and memory usage, the load average and
+  more.\n    Different data is provided for different operating systems. Checkout
+  the \n    documentation on the Github page and help us support a wider range of\n
+  \   operating systems.    \n"
+email: haze-gem@googlegroups.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- .rvmrc
+- Gemfile
+- Gemfile.lock
+- Guardfile
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- lib/host.rb
+- lib/host/hashifier.rb
+- lib/host/linux.rb
+- lib/host/linux/load_average.rb
+- lib/host/linux/memory.rb
+- lib/host/linux/processor.rb
+- lib/host/load_average.rb
+- lib/host/memory.rb
+- lib/host/processor.rb
+- lib/host/version.rb
+- spec/host/linux/load_average_spec.rb
+- spec/host/linux/memory_spec.rb
+- spec/host/linux/processor_spec.rb
+- spec/host/load_average_spec.rb
+- spec/host/memory_spec.rb
+- spec/host/processor_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/rmascarenhas/host
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3682824794771593770
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Host provides a simple way to get useful information about your system
+test_files: []