ruby-dzen 0.0.1

data/LICENSE

@@ -0,0 +1,21 @@
+(The MIT License)
+
+Copyright (c) Tom Preston-Werner, Rick Olson
+
+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,128 @@
+# ruby-dzen
+
+A small wrapper for [dzen2][dzen]'s in-text formatting
+
+You can define what dzen2 displays by using pure ruby code.
+
+The DSL is heavily inspired by [Sinatra][].
+
+## Simple DSL
+There are just 4 methods you need to know: `app`, `configure`, `before_run` and `order`
+
+The simplest way to use ruby-dzen is to define a simple app:
+
+    app :clock do
+      Time.now.strftime("%d.%m.%Y %H:%M")
+    end
+
+Each of these `app` blocks must return a string to be displayed.
+
+You can easily configure the output:
+
+    configure do |c|
+      c.interval = 3 
+    end
+
+There are several options configurable. See [dzen/base.rb][base.rb] for the defaults. ruby-dzen comes with two pre-defined option sets: 
+
+* One for real dzen2-formatted text including colors and delimiters. This is used by default.
+* One for simple text console output using escape sequences to display colors. Just define TERMINAL in your code or via commandline. (I will change this to a more ruby-ish way, soon)
+
+You can define a handler to be run beforehand, for example to display a short loading message:
+
+    before_run do
+      "--- Loading ---"
+    end
+
+The output order will either be in the order as the apps are defined in your app file or you can sort them using the `order` method:
+
+    order :clock, :loadavg
+
+If you define an app but you don't define it in your order list, it won't be displayed at all.
+
+See the [example file][example] for a already working script.
+
+## Run it!
+
+As I'm to lazy for now to create a proper gem, just clone my repo and write your own small app collection.
+
+Then run it with
+
+    ruby -Ipath/to/ruby-dzen/lib yourscript.rb | dzen2
+
+Make sure you have the svn-Version of dzen2, as it has some extra things which are not in the released packages:
+
+    svn checkout http://dzen.googlecode.com/svn/trunk/ dzen
+
+You can then set dzen2's output by its commandline options. For example change the used font with:
+
+    ... | dzen2 -fn "-*-terminus-medium-r-normal--14-120-75-75-C-70-iso8859-1"
+
+See [dzen2's documentation][dzen] for all possible options.
+
+If you want to use the text console output (for debugging or whatever) run it as:
+
+    TERMINAL=1 ruby -Ipath/to/ruby-dzen/lib yourscript.rb
+
+This will change soon to a more ruby-ish way, I hope.
+
+## Helpers
+
+As it is all pure ruby code, just define a method in your code and call it within your app module.
+
+I already wrote 2 small helper functions: `_color` and `color_critical`.
+
+`_color` colorizes a given string using the callbacks defined by DZEN::Base (or its subclass).
+
+`color_critical` colorizes a number value based on wether it's below a critical value or not.
+
+See the docu for their arguments in [dzen/helpers.rb][helpers.rb].
+
+To use them in your code just do the following in your script:
+
+    include DZEN::Helpers
+
+and use them in your apps.
+
+## New outputs
+
+To define a new output class, just subclass DZEN::Base and make sure your class defines the `Config` constant overwriting the existent config keys.
+
+This is exactly the way DZEN::Default and DZEN::Terminal are defined. See [dzen/base.rb][base.rb].
+
+## ToDo
+
+* gemify it!
+* caching of apps (nearly finished, just need a proper API)
+* more ruby-ish way to switch output class
+
+Feel free to implement what you need and let me know about your changes.
+
+## License
+
+The code is released under the MIT license. See [LICENSE][].
+
+## Contribute
+
+If you'd like to hack on ruby-dzen, start by forking my repo on GitHub:
+
+http://github.com/badboy/ruby-dzen
+
+ruby-dzen has no external dependencies other than dzen2 itself.
+
+1. Clone down your fork
+1. Create a thoughtfully named topic branch to contain your change
+1. Hack away
+1. Add tests and make sure everything still passes by running `rake`
+1. If you are adding new functionality, document it in the README
+1. Do not change the version number, I will do that on my end
+1. If necessary, rebase your commits into logical chunks, without errors
+1. Push the branch up to GitHub
+1. Send me (badboy) a pull request for your branch
+
+[dzen]: http://dzen.geekmode.org/dwiki/doku.php
+[base.rb]: http://github.com/badboy/ruby-dzen/blob/master/lib/dzen/base.rb
+[helpers.rb]: http://github.com/badboy/ruby-dzen/blob/master/lib/dzen/helpers.rb
+[sinatra]: http://www.sinatrarb.com/
+[LICENSE]: http://github.com/badboy/ruby-dzen/blob/master/LICENSE
+[example]: http://github.com/badboy/ruby-dzen/blob/master/example/sample.rb

data/Rakefile

@@ -0,0 +1,16 @@
+require 'rake/testtask'
+begin
+  require 'mg'
+rescue LoadError
+  abort "Please `gem install mg`"
+end
+
+MG.new("ruby-dzen.gemspec")
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/lib/dzen.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+
+require 'dzen/helpers'
+require 'dzen/macros'
+require 'dzen/base'
+
+module DZEN
+  VERSION = '0.0.1'
+
+  @@app_file = lambda do
+    ignore = [
+      /lib\/dzen.*\.rb/,   # Library
+      /\(.*\)/,            # Generated code
+      /custom_require\.rb/ # RubyGems require
+    ]
+
+    path = caller.map { |line| line.split(/:\d/, 2).first }.find do |file|
+      next if ignore.any? { |pattern| file =~ pattern }
+      file
+    end
+
+    path || $0
+  end.call
+
+  #
+  # File name of the application file. Inspired by Sinatra
+  #
+  def self.app_file
+    @@app_file
+  end
+
+  #
+  # Runs application if application file is the script being executed
+  #
+  def self.run?
+    self.app_file == $0
+  end
+end

data/lib/dzen/base.rb

@@ -0,0 +1,170 @@
+# encoding: utf-8
+
+require 'ostruct'
+
+module DZEN
+  # Subclass this and define own options
+  # to implement a different output
+  class Base
+    Config = {
+      :delimiter => '',
+      :ending => '',
+      :interval => 3,
+      :output => $stdout,
+      :output_method => :puts,
+      :color => {
+        :start => nil,
+        :end => nil
+      }
+    }
+
+    # Gets the actual used config
+    attr_reader :config
+
+    # Public: Initialize a new dzen2 output instance
+    #
+    # config - A Hash containing the config keys
+    #
+    # Returns a newly initialized DZEN::Base instance
+    def initialize(config={})
+      @config = OpenStruct.new(self.class::Config.merge(config))
+
+      @before_run_handler = []
+      @apps = []
+      @order = []
+    end
+
+    # Public: Configure the instance.
+    #
+    # The block will be yielded the current configuration.
+    #
+    # Returns the config
+    def configure
+      yield @config
+      @config
+    end
+
+    # Public: Add before_run handler.
+    #
+    #  It's possible to define more than one before_run handler.
+    #
+    # blk - The block to be run when starting
+    def add_before_run(&blk)
+      @before_run_handler << blk
+    end
+
+    # Public: Set the order of apps.
+    #
+    # apps - Array of app names in sorted order.
+    #
+    # Returns the passed order array.
+    def order=(apps)
+      @order = apps
+    end
+
+    # Public: Add new handler for an app.
+    #
+    # name   - Name of the app.
+    # option - Some options [not used yet].
+    # blk    - The actual handler block.
+    def add_handler(name, options, &blk)
+      @apps << [name, options||{}, blk]
+    end
+
+    # Sort the apps as defined by @order
+    # Any not-listed app is not added to the actual output array
+    def sort_apps!
+      return if @order.empty?
+      @apps = @order.map do |app|
+        @apps.find { |e| e.first == app }
+      end
+    end
+
+    # Public: Run the instance in an endless loop
+    #
+    # These endless loop may be stopped by sending it a SIGINT
+    # It runs the before_run handler first, then executes the
+    # defined app modules each interval
+    def run!
+      trap(:INT) { @output.puts; exit 0; }
+
+      sort_apps!
+
+      @before_run_handler.each do |handler|
+        @config.output.puts handler.call
+      end
+
+      loop do
+        normal_text = @apps.map { |(name, options, callback)|
+          if options[:cache]
+            # TODO: implement the cache
+            callback.call
+          else
+            callback.call
+          end
+        }.join(@config.delimiter)
+
+        @config.output.send(@config.output_method, @config.start) if @config.start
+        @config.output.print(normal_text)
+        @config.output.send(@config.output_method, @config.ending) if @config.ending
+        @config.output.flush
+        sleep @config.interval
+      end
+    rescue Errno::EPIPE
+    exit 0
+  end
+  end
+
+  # Default Dzen2 output
+  # The in-text formating commands are used as defined at
+  # http://dzen.geekmode.org/dwiki/doku.php?id=dzen:command-and-option-list
+  class Default < Base
+    Config = {
+      :delimiter => "^fg(#333333)^p(5;-2)^ro(2)^p()^fg()^p(5)",
+      :ending => "^p(6)\n",
+      :interval => 3,
+      :output => $stdout,
+      :output_method => :puts,
+      :color => {
+        :start => proc{|c| "^fg(#{c})"},
+        :end => proc{|c| "^fg()" }
+      }
+    }
+  end
+
+  # Simple Terminal-aware output.
+  # May be used within a simple "watch" command
+  # Maybe integration in screen is possible
+  class Terminal < Base
+    Colors = {
+      :black => 30,
+      :red => 31,
+      :green => 32,
+      :yellow => 33,
+      :blue => 34,
+      :magenta => 35,
+      :cyan => 36,
+      :white => 37
+    }
+
+    Config = {
+      :delimiter => " | ",
+      :start => "\r",
+      :interval => 3,
+      :output => $stdout,
+      :output_method => :print,
+      :color => {
+        :start => proc{|c|
+          Colors[c] && "\e[#{Colors[c]}m"
+        },
+        :end => proc{|c| Colors[c] && "\e[0m" }
+      }
+    }
+  end
+end
+
+# Expose DSL
+include DZEN::Macros
+
+# Run DZEN instance if any
+at_exit { @@dzen.run! if $!.nil? && run? }

data/lib/dzen/helpers.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+
+module DZEN
+  # Some small helpers used in app module outputs.
+  #
+  # You have to
+  #   include DZEN::Helpers
+  # in your app file to actually use them.
+  module Helpers
+
+    # Public: Colorize a given string using the callbacks
+    #         defined by DZEN::Base (or its subclass).
+    #
+    # c    - The color string, like "red" or "#ff0000"
+    #        Make sure the implementation of config.color callbacks
+    #        can interpret this colors.
+    # text - The text to be colored.
+    #
+    # Returns the colored string.
+    def _color(c, text)
+      config = dzen.config.color
+      %|#{config[:start].call(c)}#{text}#{config[:end].call(c)}|
+    end
+
+    # Public: Colorize a number based on wether it's
+    #         below a critical value or not.
+    #
+    # n        - The number to colorize.
+    # critical - The critical value.
+    # options  - A Hash of colors for the different colors
+    #            :normal   - for the value equal or below `critical`
+    #            :critical - for the value above `critical`
+    #
+    # Returns the colored string.
+    def color_critical(n, critical, options = {})
+      options = { :normal => "#ff8700", :critical => "red" }.merge(options)
+      if n.to_i == 0
+        n.to_s
+      elsif n.to_i < critical
+        _color(options[:normal], n.to_i)
+      else
+        _color(options[:critical], n.to_i)
+      end
+    end
+  end
+end

data/lib/dzen/macros.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+
+module DZEN
+  module Macros
+    def self.included(mod)
+      @@dzen = nil
+    end
+
+    # Public: Configure the instance.
+    #
+    # The block will be yielded the current configuration.
+    #
+    # Example:
+    #   configure do |c|
+    #     c.interval = 3
+    #   end
+    #
+    # Returns the config
+    def configure(&blk)
+      dzen.configure(&blk)
+    end
+
+    # Public: Set the order of apps.
+    #
+    # apps - App names in sorted order.
+    #
+    # Returns the passed order array.
+    def order(*apps)
+      dzen.order = apps
+    end
+
+    # Public: Add before_run handler.
+    #
+    # blk - The block to be run when starting
+    def before_run(&blk)
+      dzen.add_before_run(&blk)
+    end
+
+    # Public: Add new handler for an app.
+    #
+    # name   - Name of the app.
+    # option - Some options [not used yet].
+    # blk    - The actual handler block.
+    def app(name, options=nil, &blk)
+      dzen.add_handler(name, options, &blk)
+    end
+
+    # Public: Gets the current DZEN instance.
+    #
+    # Define TERMINAL or ENV['TERMINAL'] to use DZEN::Terminal
+    # instead of DZEN::Default.
+    #
+    # Returns a newly created or currently existing DZEN instance.
+    def dzen
+      return @@dzen unless @@dzen.nil?
+
+      @@dzen = DZEN::Terminal.new if defined?(::TERMINAL) || !!ENV['TERMINAL']
+      @@dzen = DZEN::Default.new unless @@dzen
+
+      @@dzen
+    end
+
+    # Public: Gets wether to run the DZEN output at exit or not.
+    #
+    # Returns a boolean.
+    def run?
+      !!@@dzen
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,38 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'fileutils'
+
+dir = File.dirname(File.expand_path(__FILE__))
+$LOAD_PATH.unshift(File.join(dir, '..', 'lib'))
+$LOAD_PATH.unshift(dir)
+
+require 'dzen'
+
+# Make sure we're in the test dir, the tests expect that to be the current
+# directory.
+TEST_DIR = File.join(File.dirname(__FILE__), *%w[.])
+
+def testpath(path)
+  File.join(TEST_DIR, path)
+end
+
+# test/spec/mini 3
+# http://gist.github.com/25455
+# chris@ozmm.org
+# file:lib/test/spec/mini.rb
+def context(*args, &block)
+  return super unless (name = args.first) && block
+  require 'test/unit'
+  klass = Class.new(defined?(ActiveSupport::TestCase) ? ActiveSupport::TestCase : Test::Unit::TestCase) do
+    def self.test(name, &block)
+      define_method("test_#{name.gsub(/\W/,'_')}", &block) if block
+    end
+    def self.xtest(*args) end
+    def self.setup(&block) define_method(:setup, &block) end
+    def self.teardown(&block) define_method(:teardown, &block) end
+  end
+  (class << klass; self end).send(:define_method, :name) { name.gsub(/\W/,'_') }
+  klass.class_eval &block
+end

data/test/test_base.rb

@@ -0,0 +1,74 @@
+require 'helper'
+
+context "Base" do
+  setup do
+    @base = DZEN::Base.new
+  end
+
+  test "configure" do
+    @base.configure { |c| c.interval = 42 }
+    assert_equal 42, @base.config.interval
+  end
+
+  test "add before_run handler" do
+    @base.add_before_run { 42 }
+    assert @base.instance_eval{@before_run_handler}
+    assert_equal 1, @base.instance_eval{@before_run_handler}.length
+    assert_equal 42, @base.instance_eval{@before_run_handler}.first.call
+  end
+
+  test "set order" do
+    @base.order = [:cpu, :load, :clock]
+    assert_equal [:cpu, :load, :clock], @base.instance_eval{@order}
+  end
+
+  test "add app handler" do
+    @base.add_handler(:cpu, {}) { }
+    assert_equal 1, @base.instance_eval{@apps}.size
+    @base.add_handler(:load, {}) { }
+    assert_equal 2, @base.instance_eval{@apps}.size
+  end
+
+  test "sort apps" do
+    @base.add_handler(:load, {}) { }
+    @base.add_handler(:cpu, {}) { }
+    assert_equal [:load, :cpu], @base.instance_eval{@apps}.map{|a|a.first}
+    @base.order = [:cpu, :load]
+    @base.sort_apps!
+    assert_equal [:cpu, :load], @base.instance_eval{@apps}.map{|a|a.first}
+  end
+
+  class OutputHandler
+    attr_accessor :output
+    def initialize
+      @output = ''
+    end
+
+    def to_s
+      @output.to_s
+    end
+
+    def puts(msg)
+      @output << msg << "\n"
+    end
+
+    def print(msg)
+      @output << msg
+    end
+  end
+
+  test "run it" do
+    output = OutputHandler.new
+    @base.configure do |c|
+      c.interval = 0.1
+      c.delimiter = '|'
+      c.output = output
+    end
+    @base.add_handler(:one, {}) { "1" }
+    @base.add_handler(:two, {}) { "2" }
+    t = Thread.new { @base.run! }
+    sleep @base.config.interval*2
+    t.kill
+    assert_equal "1|2\n", output.to_s
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,33 @@
+require 'helper'
+require 'ostruct'
+
+context "Base" do
+  class TestClass
+    include DZEN::Helpers
+
+    def dzen
+      OpenStruct.new({
+        :config => OpenStruct.new({:color => {
+                     :start => proc{|c|"<c(#{c})>"},
+                     :end   => proc{|c|"</c(#{c})>"}
+                     }
+                   })
+      })
+    end
+  end
+
+  setup do
+    @test = TestClass.new
+  end
+
+  test "_color" do
+    assert_equal %|<c(red)>foo</c(red)>|, @test._color('red', 'foo')
+  end
+
+  test "color_critical" do
+    colors = { :normal => 'white', :critical => 'red' }
+    assert_equal %|0|, @test.color_critical(0, 0, colors)
+    assert_equal %|<c(white)>5</c(white)>|, @test.color_critical(5, 6, colors)
+    assert_equal %|<c(red)>7</c(red)>|, @test.color_critical(7, 6, colors)
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-dzen
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- badboy
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-18 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: "  ruby-dzen is a small wrapper for dzen2's in-text formatting\n  With its simple DSL you can define what dzen2 display by using pure ruby code.\n\n  Just define your app modules in a file, execute it and pipe the output to dzen.\n\n  The simplest example is the following:\n    app :hello do\n      \"hello\"\n    end\n"
+email: badboy@archlinux.us
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- Rakefile
+- LICENSE
+- lib/dzen.rb
+- lib/dzen/macros.rb
+- lib/dzen/base.rb
+- lib/dzen/helpers.rb
+- test/test_helper.rb
+- test/helper.rb
+- test/test_base.rb
+has_rdoc: true
+homepage: http://github.com/badboy/ruby-dzen
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A small wrapper DSL for dzen2's in-text formatting
+test_files: []
+