clearbooks 0.16.3

data/lib/clearbooks/interface/rake/helpers.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+
+# System
+require 'shellwords'
+require 'fileutils'
+
+require 'date'
+require 'ostruct'
+
+
+
+### Actions
+
+desc "Look for TODO and FIXME tags in the code" # {{{
+task :todo do
+    egrep /(FIXME|TODO|TBD|FIXME1|FIXME2|FIXME3)/
+end # }}}
+
+desc "Git Tag number of this repo" # {{{
+task :version do |t|
+  # sh 'git describe --abbrev=0 --tags'
+  sh 'git describe --tags'
+end # }}}
+
+
+# vim:ts=2:tw=100:wm=100:syntax=ruby

data/lib/clearbooks/interface/rake/library.rb

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+
+
+# System
+require 'shellwords'
+require 'fileutils'
+
+require 'date'
+require 'ostruct'
+
+
+### Helper Functions
+
+# @fn       def egrep(pattern) # {{{
+# @brief    Searches for a given regular expression among all ruby files
+#
+# @param    [Regexp]  pattern     Regular Expression pattern class
+def egrep( pattern )
+
+  Dir[ "**/*.{rb,thor,rake}" ].each do |fn|
+    count = 0
+    open(fn) do |f|
+
+      while line = f.gets
+        count += 1
+        STDOUT.puts "#{fn}:#{count}:#{line}" if line =~ pattern
+      end
+
+    end # end of open
+  end # end of Dir.each
+
+end # }}}
+
+# @fn       def clean target # {{{
+# @brief    Clean output from folder
+#
+# @param    [String]      target      Target folder to clean
+def clean target
+
+  files = Dir.glob( File.join( target, "*" ) )
+
+  files.each do |file|
+    print "(--) "
+    sh "rm -vrf #{file.to_s}" if( File.exists?( "#{file.to_s}" ) )
+  end
+
+end # }}}
+
+  # @fn       def colorize color, message {{{
+  # @brief    The function colorize takes a message and wraps it into standard color commands such as for bash.
+  #
+  # @param    [String]      color       The colorname in plain english. e.g. "LightGray", "Gray", "Red", "BrightRed"
+  # @param    [String]      message     The message which should be wrapped
+  #
+  # @return   [String]      Colorized message string
+  #
+  # @warning  Might not work for your terminal
+  #
+  # FIXME: Implement bold behavior
+  # FIXME: This method is currently b0rked
+  def colorize color, message
+
+    # Black       0;30     Dark Gray     1;30
+    # Blue        0;34     Light Blue    1;34
+    # Green       0;32     Light Green   1;32
+    # Cyan        0;36     Light Cyan    1;36
+    # Red         0;31     Light Red     1;31
+    # Purple      0;35     Light Purple  1;35
+    # Brown       0;33     Yellow        1;33
+    # Light Gray  0;37     White         1;37
+
+    colors  = { 
+      "Gray"        => "\e[1;30m",
+      "LightGray"   => "\e[0;37m",
+      "Cyan"        => "\e[0;36m",
+      "LightCyan"   => "\e[1;36m",
+      "Blue"        => "\e[0;34m",
+      "LightBlue"   => "\e[1;34m",
+      "Green"       => "\e[0;32m",
+      "LightGreen"  => "\e[1;32m",
+      "Red"         => "\e[0;31m",
+      "LightRed"    => "\e[1;31m",
+      "LightRedBlink"    => "\e[5;31m",
+      "Purple"      => "\e[0;35m",
+      "LightPurple" => "\e[1;35m",
+      "Brown"       => "\e[0;33m",
+      "Yellow"      => "\e[1;33m",
+      "White"       => "\e[1;37m"
+    }
+    nocolor    = "\e[0m"
+
+    colors[ color ] + message + nocolor
+  end # of def colorize }}}
+
+  # @fn       def message level, msg {{{
+  # @brief    The function message will take a message as argument as well as a level (e.g. "info", "ok", "error", "question", "debug") which then would print 
+  #           ( "(--) msg..", "(II) msg..", "(EE) msg..", "(??) msg..")
+  #
+  # @param    [Symbol]        level         Can either be :info, :success, :error or :question
+  # @param    [String]        msg           Represents the message you want to send to stdout (info, ok, question) stderr (error)
+  #
+  # Helpers: colorize
+  def message level, msg
+
+    symbols = {
+      :info      => [ "(--)", "Brown"       ],
+      :success   => [ "(II)", "LightGreen"  ],
+      :error     => [ "(EE)", "LightRed"    ],
+      :question  => [ "(??)", "LightCyan"   ],
+      :debug     => [ "(++)", "LightBlue"   ],
+      :warning   => [ "(WW)", "Yellow"      ]
+    }
+
+    raise ArugmentError, "Can't find the corresponding symbol for this message level (#{level.to_s}) - is the spelling wrong?" unless( symbols.key?( level )  )
+
+    if( level == :error )
+      STDERR.puts colorize( symbols[ level.to_sym ].last, "#{symbols[ level.to_sym ].first.to_s} #{msg.to_s}" )
+    else
+      STDOUT.puts colorize( symbols[ level.to_sym ].last, "#{symbols[ level.to_sym ].first.to_s} #{msg.to_s}" )
+    end
+
+  end # of def message }}}
+
+
+
+# vim:ts=2:tw=100:wm=100:syntax=ruby

data/lib/clearbooks/interface/rake/metric.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+
+
+namespace :metric do
+
+  desc "Run metric fu for project" # {{{
+  task :metric do |t|
+    puts "(--) Running metric fu"
+    system "metric_fu"
+  end # }}}
+
+end # of namespace :metric
+
+# vim:ts=2:tw=100:wm=100:syntax=ruby

data/lib/clearbooks/interface/rake/rspec.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+
+## Handle RSpec 1.x and 2.x branches # {{{
+#
+# dm-redis-adapter and others maybe need 1.x while we want 2.x is possible.
+begin
+
+  require 'rspec/core/rake_task'
+
+  desc "RSpec Core Tasks" # {{{
+  RSpec::Core::RakeTask.new(:spec) do |t|
+    t.rspec_opts = '--format NyanCatFormatter --color --fail-fast --order random'
+  end # }}}
+
+rescue LoadError
+
+  puts "(WW) Could not load RSpec 2.x branch, falling back to 1.x."
+
+  require 'spec/rake/spectask'
+
+  desc "Run specs" # {{{
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_files = FileList['spec/**/*_spec.rb']
+    t.spec_opts = %w(-fs --color)
+  end # }}}
+
+end # }}}
+
+
+# vim:ts=2:tw=100:wm=100:syntax=ruby

data/lib/clearbooks/interface/thor/info.thor

@@ -0,0 +1,292 @@
+#!/usr/bin/env ruby
+
+
+# System includes
+require 'ostruct'
+require 'andand'
+require 'tempfile'
+require 'awesome_print'
+require 'os'
+
+# Custom includes
+require File.expand_path( File.dirname( __FILE__ ) + '/mixin/shell' )
+
+
+# @class  Info command class
+# @brief  Implements the info command
+class Info < Thor
+
+  include ::Mixin::Shell
+  # include ::Mixin::Command
+
+  default_task :info
+
+  class_option :'without-general',  :type => :boolean, :desc => "Print general system environment information"
+  class_option :'without-project',  :type => :boolean, :desc => "Print project environment information"
+  class_option :'without-ruby',     :type => :boolean, :desc => "Print ruby environment information"
+
+  class_option :pretty,             :type => :boolean, :desc => "Pretty print"
+
+
+  ## API
+
+  # @fn       def info {{{
+  # @brief    Main info task entry point
+  desc "overview", "Shows system overview"
+  def overview
+
+    # Default symbol action list to find info for
+    default = %i(
+                  general
+                  project
+                  ruby 
+                )
+
+    # Make sure if we have a --without-* opts to skip work
+    options.each_pair do |option, skip|
+      next unless( skip )
+      default.delete_if { |item| option =~ %r{#{item.to_s}}i }
+    end
+
+    # Execute scan & print
+    default.each do |item|
+      data = scan_for item
+      next if data.andand.broken.nil?
+
+      self.send :pretty_print, data
+    end # of default.each
+
+  end # }}}
+
+
+  private
+
+  no_tasks do
+
+    ## Actions
+
+    # @fn       def scan_for what # {{{
+    # @brief    When executed will run "what" method scanner and print relevant information
+    #
+    # @param    [Symbol]        what        Symbol of scanner method to run, e.g. :general, :java, :ruby etc.
+    def scan_for what
+      result            = nil
+
+      begin
+        result          = self.send what
+      rescue Exception => e
+        say "(EE) " + e.message, :red
+        result          = OpenStruct.new
+        result.broken   = true
+      end
+
+      return result
+    end # }}}
+
+    # @fn       def pretty_print information, playful = options[:pretty] # {{{
+    # @brief    Pretty prints given data to stdout
+    #
+    # @param    [OpenStruct]    information       Information gathered from other scanning methods, e.g. :ruby
+    # @param    [Boolean]       playful           Prints some curses like lines if true
+    def pretty_print information, playful = options[:pretty]
+      begin
+        puts ""
+        say information.title, :yellow
+
+        if( playful )
+          puts "-"*26
+          puts " "*26 + "\\"
+        else
+          puts ""
+        end
+
+        values = information.send :table
+        raise ArgumentError, "Information openstruct is malformed" if( values[ :broken ] )
+
+        values.each do |key, value|
+
+          # Skip :broken, :title
+          next if( %i(title broken).include?( key.to_sym ) )
+
+          # Make sure value is a string
+          value = value.to_s
+
+          # Remove pre- and post-padding
+          value.strip!
+
+          # Turn key into a nice printable value
+          # e.g. :current_directory => Current directory
+          description = key.to_s
+          description.gsub!( "_", " " )
+          description.capitalize!
+
+
+          # Check if value is multi-line, if so, format accordingly
+          output = []
+
+          if( value =~ %r{\n} )
+            lines     = value.split( "\n" )
+            output    << sprintf( "%-25s | %s", description, lines.shift )
+            lines.each { |line| output << sprintf( "%-25s | %s", "", line ) }
+          else
+            output    << sprintf( "%-25s | %s", description, value )
+          end
+
+          output.each { |something| say something }
+        end
+
+        if( playful )
+          puts " "*26 + "\\"
+          puts " "*27 + "-"*80
+        end
+
+        puts ""
+
+      rescue Exception => e
+        say "(EE) " + e.message, :red
+      end
+    end # }}}
+
+
+    ## Specific Scanners
+
+    # @fn       def general {{{
+    # @brief    Returns information collected from the general system
+    #
+    # @return   [OpenStruct]      Returns openstruct with gathered information
+    def general
+      result                  = nil
+
+      begin
+        result                = OpenStruct.new
+        result.broken         = false
+
+        os                    = os_report
+
+        result.title          = "System Information"
+        result.system         = os.host
+        result.cpus           = OS.cpu_count
+        result.architecture   = OS.bits
+        result.current_user   = `whoami`.chomp
+
+      rescue Exception => e
+        result                = OpenStruct.new
+        result.broken         = true
+
+        say "(EE) " + e.message, :red
+      end
+
+      return result
+    end # }}}
+
+    # @fn       def project {{{
+    # @brief    Print project related information to stdout
+    #
+    # @return   [OpenStruct]      Returns openstruct with gathered information
+    def project
+      result                      = nil
+
+      begin
+        result                    = OpenStruct.new
+        result.broken             = false
+
+        result.title              = "Project information"
+
+        result.current_directory  = Dir.pwd
+        result.version            = `git describe --tags` || "unknown"
+
+      rescue Exception => e
+        result                    = OpenStruct.new
+        result.broken             = true
+
+        say "(EE) " + e.message, :red
+      end
+
+      return result
+    end # }}}
+
+    # @fn       def ruby {{{
+    # @brief    Prints ruby environment information to stdout
+    #
+    # @return   [OpenStruct]      Returns openstruct with gathered information
+    def ruby
+
+      result                  = nil
+
+      begin
+        result                = OpenStruct.new
+        result.broken         = false
+
+        result.title          = 'Ruby Information'
+
+        commands              = %w(ruby rvm rbenv rake gem)
+
+        commands.each do |command|
+          next unless( self.which( command ) )
+
+          result.send "#{command}=", self.version( command )
+        end
+
+      rescue Exception => e
+        result                = OpenStruct.new
+        result.broken         = true
+
+        say "(EE) " + e.message, :red
+      end
+
+      return result
+    end # }}}
+
+
+    ## Helpers
+
+    # @fn       def os_report {{{
+    # @brief    Get overview of the Operating System
+    #
+    # @return   [OpenStruct]      Returns a openstruct with various information, e.g.
+    #                             arch, target_os, target_vendor, target_cpu, target, host_os, host_vendor, host_cpu, host, RUBY_PLATFORM
+    def os_report
+      result    = nil
+
+      begin
+        yaml    = OS.report
+        hash    = YAML.load( yaml )
+        result  = hashes_to_ostruct( hash )
+      rescue Exception => e
+        $stderr.puts set_color "(EE) #{e.message}", :red
+      end
+
+      result
+    end # }}}
+
+    # @fn       def hashes_to_ostruct object # {{{
+    # @brief    This function turns a nested hash into a nested open struct
+    #
+    # @author   Dave Dribin
+    #           Reference: http://www.dribin.org/dave/blog/archives/2006/11/17/hashes_to_ostruct/
+    #
+    # @param    [Object]    object    Value can either be of type Hash or Array, if other then it is returned and not changed
+    #
+    # @return   [OStruct]             Returns nested open structs
+    def hashes_to_ostruct object
+
+      return case object
+      when Hash
+        object = object.clone
+        object.each { |key, value| object[key] = hashes_to_ostruct(value) }
+        OpenStruct.new( object )
+      when Array
+        object = object.clone
+        object.map! { |i| hashes_to_ostruct(i) }
+      else
+        object
+      end
+
+    end # of def hashes_to_ostruct }}}
+
+  end # of no_tasks do
+
+end # of Class Info
+
+
+# vim:ts=2:tw=100:wm=100:syntax=ruby