dock_driver 0.2.1 → 0.3.1

data/lib/dock_driver/i3.rb

@@ -4,24 +4,33 @@ require 'pathname'
 require 'json'
 
 module DockDriver
-    # A class to provide IPC communication with i3wm.
+
+    ### A class to provide IPC communication with i3wm.
     class I3
-        COMMAND        = 0
-        GET_WORKSPACES = 1
-        SUBSCRIBE      = 2
-        GET_OUTPUTS    = 3
-        MAGIC          = 'i3-ipc'
-
-        # ripped from include/i3/ipc.h
-        #
-        EVENT_MASK      = (1 << 31)
-        EVENT_WORKSPACE = (EVENT_MASK | 0)
-
-        def initialize( socket='~/.i3/ipc.sock' )
-            @ipc = UNIXSocket.open( Pathname( socket ).expand_path )
-        end
 
-        attr_reader :ipc
+        extend Loggability
+        log_to :dock_driver
+
+        COMMAND        = 0 #:nodoc:
+        GET_WORKSPACES = 1 #:nodoc:
+        SUBSCRIBE      = 2 #:nodoc:
+        GET_OUTPUTS    = 3 #:nodoc:
+        MAGIC          = 'i3-ipc' #:nodoc:
+
+        EVENT_MASK      = (1 << 31) #:nodoc:
+        EVENT_WORKSPACE = (EVENT_MASK | 0) #:nodoc:
+
+        ### The IPC socket object.
+        attr_accessor :ipc
+
+        ### The IPC socket path.
+        attr_accessor :path
+
+        ### A constructor OF DOOM!
+        def initialize( socket = '~/.i3/ipc.sock' )
+            @path = Pathname( socket ).expand_path.to_s 
+            @ipc = UNIXSocket.open( @path )
+        end
 
         ### Send a command to i3.
         def command( cmd )
@@ -42,13 +51,9 @@ module DockDriver
         end
 
         ### Do a blocking select, yielding an event when one is seen.
-        def wait_for_event( type=nil, timeout=nil )
-            ready = select( [self.ipc], nil, nil, timeout )
-            return if ready.nil? # timeout
-
-            msg = self.read_data( type )
-            return if msg.nil? && ! type.nil?
-
+        def wait_for_event( type, timeout=nil )
+            sock = select( [self.ipc], nil, nil, timeout )
+            return nil unless sock and type and msg = self.read_data( type )
             yield msg if block_given?
             return msg
         end
@@ -67,14 +72,19 @@ module DockDriver
         end
 
         ### Receive a message payload from i3, returning it as a data structure.
-        ### Returns nil if a +type+ is specified, and the message doesn't match.
+        ### Returns nil if a message wasn't successfully read (closed socket,
+        ### etc.) or if a +type+ is specified and didn't match the message's
+        ### type.
         def read_data( expected_type=nil )
             buf = self.ipc.read( MAGIC.bytes.count + 4 + 4 )
+            return nil unless buf
             len, type = buf[6..-1].unpack( 'LL' )
             msg = self.ipc.read( len )
 
             return nil if ! expected_type.nil? && expected_type != type
             return JSON.parse( msg )
         end
+
     end
-end
+
+end

data/lib/dock_driver/template.rb

@@ -0,0 +1,58 @@
+
+require 'erb'
+require 'ostruct'
+
+module DockDriver
+
+    # This class provides a binding/namespace for ERB templating.
+    class Template < OpenStruct
+
+        # A factory method to render the template, given a string, and a
+        # list of objects that respond to +:to_s+.
+        #
+        # Returns the result of the template.
+        #
+        # Example:
+        # 
+        #    my_tmpl = "<%= date %>"
+        #    DockDriver::Template.render( my_tmpl, [] ) => '2012-10-05 11:30:22'
+        #
+        def self::render( tmpl, items )
+            tmpl = ERB.new( tmpl )
+            result = tmpl.result( self.new( items ).instance_eval { binding } )
+            return result.gsub( /\s+/, ' ' )
+        end
+
+        # Handle missing methods gracefully, by returning a red ! instead.
+        def method_missing( sym, *args, &block )
+            return '^fg(red)!^fg()'
+        end
+
+        #####################################################################
+        ### D S L 
+        #####################################################################
+
+        # Get the workspace pager as a string. See WorkspacePager.
+        # Example:
+        #
+        #    <%= pager %>
+        #
+        def pager
+            return DockDriver::pager.to_s
+        end
+
+        require 'dock_driver/template/dates_and_times'
+        require 'dock_driver/template/environment'
+        require 'dock_driver/template/network'
+        require 'dock_driver/template/dzen2'
+        require 'dock_driver/template/linux'
+
+        include DatesAndTimes
+        include Environment
+        include Network
+        include Dzen2
+        include Linux
+
+    end
+
+end

data/lib/dock_driver/template/dates_and_times.rb

@@ -0,0 +1,57 @@
+
+# Adds date and time related methods to the DockDriver::Template DSL.
+module DockDriver::Template::DatesAndTimes
+
+    # Returns a formatted date.
+    # Examples:
+    #
+    #    <%= date %>      => 2012-03-04 17:35:33
+    #    <%= time %>      => 2012-03-04 17:35:33
+    #    <%= date "%A" %> => Wednesday
+    #
+    def date( fmt = "%F %T" )
+        return Time.now.strftime( fmt )
+    end
+
+    alias_method :time, :date
+
+    # Returns a formatted date in GMT.
+    # Examples:
+    #
+    #    <%= gmdate %>      => 2012-03-04 17:35:33
+    #    <%= gmtime %>      => 2012-03-04 17:35:33
+    #    <%= gmdate "%A" %> => Tuesday
+    #
+    def gmdate( fmt = "%F %T" )
+        return Time.now.gmtime.strftime( fmt )
+    end
+
+    alias_method :gmtime, :gmdate
+
+    # Internet Time with a fractional part.
+    # Examples:
+    #
+    #    <%= centibeats %>         => @203.44
+    #    <%= centibeats "%0.1f" %> => 203.4
+    #
+    def centibeats( fmt = "@%0.2f" )
+        # UTC+1 is the time base for Interet Time.
+        now = Time.now.utc + 3600
+        base = Time.gm( now.year, now.month, now.day, 1 )
+        return fmt % [(now.to_f - base.to_f) * 0.01157407407]
+    end
+
+    # Internet Time
+    # Examlpes:
+    #
+    #    <%= beats %>         => @203
+    #    <%= internet_time %> => @203
+    #    <%= beats "%0.1f" %> => 203.0
+    #
+    def beats( fmt = "@%0.0f")
+        return self.centibeats( fmt )
+    end
+
+    alias_method :internet_time, :beats
+
+end

data/lib/dock_driver/template/dzen2.rb

@@ -0,0 +1,153 @@
+
+# Adds DZen2 related methods to the DockDriver::Template DSL.
+module DockDriver::Template::Dzen2
+
+    # Return a string pointing to an XPM in this gem's datadir.
+    #
+    # There's a library of 420 glyphicons haflings converted to xpm
+    # there for use. For now there are gray icons. To list the available names:
+    #
+    #     dock_driver --list-icons
+    #
+    # Example:
+    #
+    #    <%= icon( 'cogwheel' ) %>
+    # 
+    def icon( name )
+        return "^i(%s/icons/gray/%s.xpm)" % [DockDriver::DATADIR, name]
+    end
+
+    # Colorize a string.
+    #
+    # Takes a string or/containing a float or integer and hash of
+    # thresholds. The hash must be keyed by Numeric values and each
+    # value must be a color name. The hash must also have a color name
+    # associated with nil, which will be used for values greater than
+    # any threshold. For example: 
+    #
+    #     { 50 => 'green', 70 => 'yellow', nil => 'red' }
+    #
+    # Returns the original value if it cannot be assigned a color.
+    # Example:
+    #
+    #    <%= colsorize item, { 1 => 'green', 5 => 'yellow', nil => 'red' } %> 
+    # 
+    def colorize( value, colors = {} )
+        # I'm lazy. Force conversion.
+        v = value.to_s.to_f
+
+        t = colors.keys.compact.sort.select do |i|
+            next false unless i.is_a? Numeric
+            i > v
+        end
+        color = colors[t.first]
+        
+        return value if color.nil?
+        return "^fg(%s)%s^fg()" % [color,value]
+    rescue Exception
+        return value
+    end
+
+    # Colorize a temperature reading in Celcius. Default thresholds are
+    # a conservative guess at maximum junction temperatures for most
+    # CPUs or GPUs. Takes a string or/containing a float or integer.
+    # Example:
+    #
+    #    <%= color_deg_c my_temp_probe %>
+    #
+    def color_deg_c( value, colors = nil )
+        colors ||= {
+            0 =>  'blue',
+            20 => 'cyan',
+            60 => 'green',
+            70 => 'yellow',
+            90 => 'orange',
+            nil => 'red'
+        }
+        return colorize( value, colors )
+    end
+
+    # Colorize a temperature reading in degrees Fahrenheit. Default
+    # thresholds are a conservative guess at maximum junction
+    # temperatures for most CPUs or GPUs. Takes a string or/containing a
+    # float or integer.
+    # Example:
+    #
+    #    <%= color_deg_f my_temp_probe %>
+    #
+    def color_deg_f( value, colors = nil )
+        colors ||= {
+            32  =>  'blue',
+            68  => 'cyan',
+            140 => 'green',
+            158 => 'yellow',
+            194 => 'orange',
+            nil => 'red'
+        }
+        return colorize( value, colors )
+    end
+
+    # Colorize a system load number.
+    # Example:
+    #
+    #    <%= color_load( loadavg_one ) %>
+    #
+    def color_load( value, cores = 1.0, colors = nil )
+        colors ||= {
+            0.1 => 'gray50',
+            0.5 => 'gray80',
+            0.7 => 'white',
+            0.9 => 'green',
+            1.2 => 'yellow',
+            nil => 'red'
+        }
+
+        v = value.to_s.to_f / cores.to_f
+        t = colors.keys.compact.sort.select do |i|
+            next false unless i.is_a? Numeric
+            i > v
+        end
+        color = colors[t.first]
+        
+        return value if color.nil?
+        return "^fg(%s)%s^fg()" % [color,value]
+    rescue Exception
+        return value
+    end
+
+    # Create a clickable icon.
+    # The following creates a clickable magic-wand icon that restarts i3:
+    #
+    #     <%= i3_button( 'restart', 'magic' ) %>
+    #
+    def i3_button( cmd, icon_name = 'cogwheel' )
+        return "^ca(1,i3-msg '%s')%s^ca()" % [cmd, icon( icon_name )]
+    end
+
+    # Create a clickable icon.
+    # The following creates a clickable globe icon that starts firefox:
+    #
+    #     <%= i3_button( 'firefox', 'globe' ) %>
+    #
+    def button( cmd, icon_name = 'cogwheel' )
+        return "^ca(1,i3-msg exec '%s')%s^ca()" % [cmd, icon( icon_name )]
+    end
+
+    # Methods to add to the including class.
+    module ClassMethods
+        # Returns a list of available icon names, derived from the
+        # files available in the datadir of this gem.
+        def list_icons
+            pattern = DockDriver::DATADIR + "icons/gray/*.xpm"
+            return Dir.glob( pattern ).map do |icon|
+                icon[/\w+.xpm/].sub(/.xpm/, '')
+            end.sort.uniq
+        end
+    end
+
+    # Extend the including object with ClassMethods
+    def self::included( klass ) #:nodoc:
+        klass.extend ClassMethods
+    end
+
+end

data/lib/dock_driver/template/environment.rb

@@ -0,0 +1,27 @@
+
+# Adds Unix environment related methods to the DockDriver::Template DSL.
+module DockDriver::Template::Environment
+
+    # Returns the current value of an environment variable.
+    # Example:
+    #
+    #    <%= env 'USER' %> => mike
+    #
+    def env( key )
+        return ENV[key]
+    end
+
+    # Returns the current value of ENV['USER'].
+    # Example:
+    #
+    #    <%= user %>     => mike
+    #    <%= username %> => mike
+    #
+    def username
+        return self.env('USER')
+    end
+
+    alias_method :user, :username
+
+end
+

data/lib/dock_driver/template/linux.rb

@@ -0,0 +1,62 @@
+
+# Adds network-related methods to the DockDriver::Template DSL.
+#
+# Since I'm using a bit of metaprogramming, here's a list of DSL methods that
+# this module brings to the template:
+#
+# [\loadavg_one]
+#    1 minute load average
+# [\loadavg_five]
+#    minute load average
+# [\loadavg_fifteen]
+#    15 minute load average
+# [\loadavg_running]
+#    otal number of running processes
+# [\loadavg_total]
+#    total number of processes
+# [\loadavg_last_pid]
+#     last running process id
+#
+# Example:
+#
+#    <%= loadavg_one %> => 1.61
+#
+module DockDriver::Template::Linux
+
+    # Path to load stats. (procfs)
+    LOADAVG_PATH = '/proc/loadavg'
+
+    # Map of column names for the load stats.
+    LOADAVG_KEYS = [
+        :one,
+        :five,
+        :fifteen,
+        :running,
+        :total,
+        :last_pid
+    ]
+
+    # Define methods for each key in LOADAVG_KEYS.
+    LOADAVG_KEYS.each do |key|
+        name = ("loadavg_%s" % [key]).to_sym
+        define_method( name ) do
+            return loadavg()[key]
+        end
+    end
+
+    #######
+    private
+    #######
+
+    # Parse the contents of LOADAVG_PATH and return a hash of values found.
+    def loadavg
+        loadavg = File.read( LOADAVG_PATH ).strip
+        items = loadavg.split( ' ' )
+        items[3] = items[3].split('/')
+        items.flatten!
+        return Hash[LOADAVG_KEYS.zip( items )]
+    rescue Exception
+        return Hash.new
+    end
+
+end