geohash36 0.3.0

data/lib/geohash36/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/geohash36/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 thrift 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/geohash36/interface/rake/metric.rb

@@ -0,0 +1,13 @@
+#!/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/geohash36/interface/rake/rspec.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+
+require 'rspec/core/rake_task'
+
+desc "RSpec Core Tasks"
+RSpec::Core::RakeTask.new(:spec)
+
+

data/lib/geohash36/interface/thor/info.thor

@@ -0,0 +1,292 @@
+#!/usr/bin/env ruby
+
+
+# System includes
+require 'ostruct'
+require 'awesome_print'
+require 'andand'
+require 'tempfile'
+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

data/lib/geohash36/interface/thor/mixin/config_choice.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+# @module     module Mixin
+# @brief    Mixin module contains various functions to be used in other components
+module Mixin
+
+  # @module   ConfigChoice Module
+  # @brief    Module wrapper around ConfigChoice tasks
+  module ConfigChoice
+
+    def config_choice
+      defaults = YAML.load_file(File.expand_path( File.dirname( __FILE__ ) + '/../../../template/default_values.yml'))
+      defaults['jason'].each_key { |key| choice_option(defaults['jason'], key) }
+      defaults
+    end
+
+    private def choice_option(defaults, option)
+      print ("%s (%s): " % [option, defaults[option]])
+      value = STDIN.gets.chomp
+      defaults[option] = value unless value.empty?
+    end
+  end # of module ConfigChoice
+
+end # of module Mixin
+
+
+# vim:ts=2:tw=100:wm=100:syntax=ruby

data/lib/geohash36/interface/thor/mixin/configuration.rb

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+
+
+# @module       module Mixin
+# @brief        Mixin module contains various functions to be used in other components
+module Mixin
+
+  # @module     Configuration Module
+  # @brief      Module wrapper around tasks which demands config file
+  module Configuration
+
+    # @fn       def initialize *args {{{
+    # @brief    Default constructor
+    #
+    # @param    [Array]     args      Argument array
+    def initialize *args
+      super
+      unless File.exist?("~/.geohash36/config.yaml")
+          abort("Could not find configuration file in ~/geohash36/config.yaml. Please run 'geohash36 config:generate' to generate it.")
+      end
+    end # }}}
+
+  end # of module Configuration
+
+end # of module Mixin
+
+
+# vim:ts=2:tw=100:wm=100:syntax=ruby

data/lib/geohash36/interface/thor/mixin/default.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+
+
+# System includes
+require 'thor'
+require 'andand'
+
+
+# @module       module Mixin
+# @brief        Mixin module contains various functions to be used in other components
+module Mixin
+
+  # @module     Default Module
+  # @brief      Module wrapper around default tasks
+  module Default
+
+    # @fn       def initialize *args {{{
+    # @brief    Default constructor
+    #
+    # @param    [Array]     args      Argument array
+    def initialize *args
+      super
+    end # }}}
+
+  end # of module Default
+
+end # of module Mixin
+
+
+# vim:ts=2:tw=100:wm=100:syntax=ruby

data/lib/geohash36/interface/thor/mixin/default_config.rb

@@ -0,0 +1,31 @@
+#!/usr/bin/env ruby
+
+# Custom includes
+require File.expand_path( File.dirname( __FILE__ ) + '/config_choice' )
+
+# @module       module Mixin
+# @brief        Mixin module contains various functions to be used in other components
+module Mixin
+
+  # @module     DefaultConfig Module
+  # @brief      Module wrapper around default tasks
+  module DefaultConfig
+
+    # Include various partials
+    include ::Mixin::ConfigChoice
+
+    def defaults
+      config_path = File.expand_path( '~/.geohash36/config.yml' )
+      if File.exists?(config_path)
+        YAML.load_file(config_path)
+      else
+        FileUtils.mkdir_p( File.expand_path( '~/.geohash36' ) )
+        config_choice
+      end
+    end
+  end # of module DefaultConfig
+
+end # of module Mixin
+
+
+# vim:ts=2:tw=100:wm=100:syntax=ruby

data/lib/geohash36/interface/thor/mixin/guess.rb

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+
+# System includes
+require 'andand'
+
+
+# @module     module Mixin
+# @brief      Mixin module contains various functions to be used in other components
+module Mixin
+
+  # @module   Guess Module
+  # @brief    Module wrapper around guess tasks to extract version numbers etc
+  module Guess
+
+    # @fn       def initialize *args {{{
+    # @brief    Default constructor
+    #
+    # @param    [Array]     args      Argument array
+    def initialize *args
+      super
+    end # }}}
+
+    # @fn       def guess_version string {{{
+    # @brief    Guess version from full version string
+    #
+    # @example  e.g. "ruby 2.1.1p76 (2014-02-24 revision 45161) [i686-linux]"
+    #                   -> 2.1.1
+    #
+    #                "rake, version 10.1.1"
+    #                   -> 10.1.1
+    def guess_version string
+
+      result      = ""
+
+      begin
+
+        # Sanity
+        raise ArgumentError, "Version has to be of type string" unless( string.is_a?( String ) )
+        raise ArgumentError, "Version can't be empty" if( string.empty? )
+
+        result    = string.match( /\d+\.\d+\.\d+/ ).to_s # matches first only
+
+      rescue Exception => e
+        say "(EE) " + e.message, :red
+        result    = ""
+      end
+
+      return result
+    end # }}}
+
+  end # of Module Guess
+
+end # of module Mixin
+
+
+# vim:ts=2:tw=100:wm=100:syntax=ruby

data/lib/geohash36/interface/thor/mixin/logger.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/env ruby
+
+
+# System includes
+require 'thor'
+require 'andand'
+
+# Custom includes
+require File.expand_path( File.dirname( __FILE__ ) + '/../../../library/logger' )
+
+
+# @module       module Mixin
+# @brief        Mixin module contains various functions to be used in other components
+module Mixin
+
+  # @module     Logger Module
+  # @brief      Module wrapper around logger tasks
+  module Logger
+
+    # @fn       def initialize *args {{{
+    # @brief    Default constructor
+    #
+    # @param    [Array]     args      Argument array
+    def initialize *args
+      super
+
+      @logger           = ::ClothesNetwork::Logger.instance
+
+      @logger.color     = options[ :colorize ]
+      @logger.silent    = options[ :silent ]
+
+    end # }}}
+
+    Thor::class_option :colorize, :type => :boolean, :required => false, :default => true,  :desc => 'Colorize the output for easier reading'
+    Thor::class_option :logger,   :type => :boolean, :required => false, :default => true,  :desc => 'Use default project logger'
+    Thor::class_option :silent,   :type => :boolean, :required => false, :default => false, :desc => 'Turn off all logging'
+
+  end # of module Logger
+
+end # of module Mixin
+
+
+# vim:ts=2:tw=100:wm=100:syntax=ruby