fox 0.0.2 → 0.4.0

data/lib/fox/interface/thor/mixin/history.rb

@@ -0,0 +1,12 @@
+require 'data_mapper' 
+
+# @class      class History
+# @brief      mapper for History table, save information about commands
+class History
+  include DataMapper::Resource
+
+  property :id,          Serial
+  property :command,     String
+  property :arguments,   String      
+end # of class History
+

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

@@ -6,7 +6,7 @@ require 'thor'
 require 'andand'
 
 # Custom includes
-# require File.expand_path( File.dirname( __FILE__ ) + '/../../../library/logger' )
+require File.expand_path( File.dirname( __FILE__ ) + '/../../../library/logger' )
 
 
 # @module       module Mixin
@@ -24,7 +24,7 @@ module Mixin
     def initialize *args
       super
 
-      @logger           = ::Fox::Logger.instance
+      @logger           = ::ClothesNetwork::Logger.instance
 
       @logger.color     = options[ :colorize ]
       @logger.silent    = options[ :silent ]

data/lib/fox/interface/thor/mixin/model.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+# System
+require 'data_mapper'
+
+
+# @class      class Model
+# @brief      mapper for Model table, save information about all created Models
+class Model
+
+  include DataMapper::Resource
+
+  property :id,          Serial
+  property :name,        String
+  property :version,     String
+  property :uuid,        String
+
+end # of class Model
+

data/lib/fox/interface/thor/new.thor

@@ -0,0 +1,74 @@
+#!/usr/bin/env ruby
+
+
+# System includes
+require 'ostruct'
+require 'andand'
+require 'tempfile'
+require 'os'
+
+# Custom includes
+require File.expand_path( File.dirname( __FILE__ ) + '/mixin/logger' )
+require File.expand_path( File.dirname( __FILE__ ) + '/../../library/project_builder' )
+
+
+# @class  New command class
+# @brief  Forks new paper projects
+class New < Thor
+
+  # Include various partials
+  include Thor::Actions
+  include ::Mixin::Logger
+
+  class_option :'ieee-icra',  :type => :boolean, :desc => "IEEE Robotics & Automation Society (ICRA)", :default => false
+
+
+  # @fn       def new projectname {{{
+  # @brief    Generates new project with given PROJECTNAME
+  desc "generate PROJECTNAME", "Creates new project PROJECTNAME"
+  def generate projectname
+
+    @logger.message :info, "Generating project '#{projectname.to_s}' in folder './#{projectname.to_s}'"
+
+    type      = select_type
+    @logger.message :info, "Using #{type.to_s} type"
+
+    template  = File.expand_path( File.dirname(__FILE__) + '/../../template/document/' + type.to_s + "/" + type.to_s + ".fox" )
+    ProjectBuilder.load( projectname.to_s, template )
+
+  end # }}}
+
+
+  private
+
+  no_tasks do
+
+    # @fn     def select_type {{{
+    # @brief  Checks selected type with user and returns value for further processing
+    def select_type
+
+      # Default containers
+      type    = ""
+
+      # Set if default switch given
+      type    = "ieee-icra" if( options[:'ieee-icra'] )
+
+      if type.empty?
+        type  = ( yes?( "Use IEEE Robotics & Automation Society (ICRA) Template? [y/n]" ) ) ? ( 'ieee-icra' ) : ( '' )
+      end
+
+      # Post-condition check
+      if type.empty?
+        @logger.message :error, "Could not determine the type of document you want to generate"
+        abort
+      end
+
+      return type
+    end # }}}
+
+  end # of no_tasks do
+
+end # of Class New
+
+
+# vim:ts=2:tw=100:wm=100:syntax=ruby

data/lib/fox/interface/thor/version.rb

@@ -0,0 +1,59 @@
+#!/usr/bin/env ruby
+
+# Custom includes
+require File.expand_path( File.dirname(__FILE__) + '../../../version' )
+require File.expand_path( File.dirname( __FILE__ ) + '/mixin/logger' )
+require File.expand_path( File.dirname( __FILE__ ) + '/mixin/database' )
+
+# @class  Server command class
+# @brief  Implements the server command
+class Version < Thor
+
+  default_task :show
+
+  include ::Mixin::Logger
+  include ::Mixin::Database
+
+  ## API
+
+  # @fn       def show {{{
+  # @brief    Show version string of app
+  desc 'show', 'Show version of this app'
+  def show
+    version = Fox::VERSION
+    puts version
+  end # }}}
+
+
+  # @fn       def set version {{{ 
+  # @brief    Set Version for default Model
+  desc 'set VERSION', 'Set Version for default Model'
+  def set version
+
+    @logger.message :info, "Running Fox Version #set for #{version}"
+
+    abort("Default model not defined! Run `fox default <ModelName>` for set default model") if !default_model_defined? 
+
+    current_default_model = get_default_model
+
+    if ! ( check_if_version_available_for_model current_default_model.name, version )
+      available_versions = all_models.find_all do |model|
+        model.name == current_default_model.name
+      end.map(&:version).join("\n")  
+      abort("Not Found #{version} for #{current_default_model.name}. Available Versions for #{current_default_model.name}:\n#{available_versions}")
+    end
+
+    set_default_model_version version
+    @logger.message :info, "Set Default Version #{version} for #{current_default_model.name}"
+  end # end of set }}}
+
+  no_tasks do
+
+    ## Actions
+
+  end # of no_tasks do
+
+end # of Class Version
+
+
+# vim:ts=2:tw=100:wm=100:syntax=ruby

data/lib/fox/library/choice.rb

@@ -0,0 +1,160 @@
+#!/usr/bin/env ruby
+
+
+# Custom includes
+# require_relative 'logger'
+
+
+class Choice
+
+  # @fn       def initialize # {{{
+  # @brief    Default constructor
+  def initialize
+    # 0 = most dislike  ; 5 = most like
+    # This scale may have an statistical bias
+    @likert_scale             = [
+                                    "Strongly dislike",
+                                    "Dislike",
+                                    "Neither like nor dislike",
+                                    "Like",
+                                    "Strongly like"
+                                ]
+
+    @phrase_completion_scale  = [
+                                    "Definition of not xxxxx",
+                                    "Strongly not xxxxx",
+                                    "Stupid",
+                                    "Not xxxxx at all",
+                                    "Not so xxxxx",
+                                    "Neutral",
+                                    "A little bit xxxxx",
+                                    "Rather xxxxx",
+                                    "Really xxxxx",
+                                    "Hilarious",
+                                    "The most xxxxx ever",
+                                ]
+
+    @percent_scale            = [ 0, 100 ]
+
+  end # of def initialize # }}}
+
+  # @fn       def get_choice_from_bipolar question, allowed_answers = %w[ y n ] # {{{
+  # @brief    The function ask will take a simple string query it on the CMD and wait for an answer e.g. "y" (or enter)
+  #
+  # @param    [String]   question          String, representing the question you want to query.
+  # @param    [Array]    allowed_answers   Array, representing the allowed answers
+  # @returns  [Boolean]                    Boolean, true for yes, false for no
+  def get_choice_from_bipolar question, allowed_answers = %w[ y n ]
+    print "#{question.to_s} [#{allowed_answers.join(", ")}] : "
+    answer = STDIN.gets.to_s.chop
+    return true  if( answer =~ %r{y}i )
+    return false if( answer =~ %r{n}i )
+  end # of def get_choice_from_bipolar question, allowed_answers = %w[ y n ] # }}}
+
+  # @fn       def get_choice_from_listing question, data # {{{
+  # @brief    The function get_choice_from_listing asks the user to answer a according to a given listing sequence
+  #
+  # @param    [String]        question    String, representing the question which the user should be asked together with this listing.
+  # @param    [Array]         data        Array, consisting of values, [ value, ... ]
+  #
+  # @returns  [Integer]                   Integer, representing the choice the user entered
+  def get_choice_from_listing question, data
+
+    selection = nil
+
+    while( selection.nil? )
+
+      print "#{question.to_s} : \n"
+
+      data.each_with_index do |d, i|
+        printf( "(%-2i) %s\n", i, d )
+      end
+
+      print "\n>> "
+      selection                  = ( ( STDIN.gets ).chomp )
+
+    end
+
+    selection
+  end # of def get_choice_from_listing }}}
+
+  # @fn       def get_choice_from_range question, from = @percent_scale.first, to = @percent_scale.last # {{{
+  # @brief    The function takes a numerical range argument and asks the user to select from it
+  #
+  # @param    [String]        question    String, representing the question which the user should be asked together with this listing.
+  # @param    [Integer]       from        Integer, representing the start of the numerical range
+  # @param    [Integer]       to          Integer, representing the end of the numerical range
+  # @returns  [Integer]                   Integer, representing the desired percentage
+  def get_choice_from_range question, from = @percent_scale.first, to = @percent_scale.last
+    selection = nil
+    finished  = false
+
+    while( not finished )
+
+      print "#{question.to_s} "
+
+      printf( "(%i-%i) : ", from, to )
+      STDOUT.flush
+      selection                  = ( ( STDIN.gets ).chomp )
+
+      if( selection == "" )
+        # puts "The selection needs to be of type integer!"
+        finished = true
+      else
+        if( selection.tr( "0-9", "" ) == "" )
+          selection = selection.to_i
+          if( selection >= from and selection <= to )
+            finished = true
+          else
+            puts "The selection needs to be inside the range from #{from.to_s} to #{to.to_s}!"
+          end
+        else
+          puts "The input can only be of type integer"
+        end
+      end
+
+    end # of while
+
+    selection
+  end # of def get_choice_from_range }}}
+
+  # @fn       def ask question, type # {{{
+  # @brief    The ask function takes a question and a type argument of the desired question type (e.g. :likert, :phrase, :percent)
+  #
+  # @param    [String]        question    String, representing the question which the user should be asked together with this listing.
+  # @param    [Symbol]        type        Symbol, one of either: :likert, :phrase, :percent, :bipolar
+  def ask question, type
+
+    allowed = [:bipolar, :likert, :phrase, :percent]
+    answer  = nil
+
+    # Pre-condition check # {{{
+    raise ArgumentError, "The type (#{type.to_s}) is not among the allowed types (#{allowed.join(", ")})" unless( allowed.include?( type ) )
+    raise ArgumentError, "The question needs to be of type string but is (#{question.class.to_s})" unless( question.is_a?(String) )
+    # }}}
+
+    # Main
+    case type
+      when :bipolar
+        answer = get_choice_from_bipolar( question )
+      when :likert
+        answer = get_choice_from_listing( question, @likert_scale )
+      when :phrase
+        answer = get_choice_from_listing( question, @phrase_completion_scale )
+      when :percent
+        answer = get_choice_from_range( question )
+    end
+
+    # Post condition check
+
+    answer
+  end # }}}
+
+end # of class Choice
+
+
+# Direct Invocation
+if __FILE__ == $0
+end # of if __FILE__ == $0
+
+# vim:ts=2:tw=100:wm=100

data/lib/fox/library/logger.rb

@@ -0,0 +1,175 @@
+#!/usr/bin/env ruby
+
+
+# System
+require 'ostruct'
+require 'singleton'
+
+# XMPP (jabber) support
+# require 'xmpp4r'
+# require 'xmpp4r-simple'
+# require 'xmpp4log'
+
+# AMQP support
+# equire 'amqp'
+
+
+module ClothesNetwork
+
+  class Logger
+
+    include Singleton
+
+    # @fn         def initialize options = nil # {{{
+    # @brief      Default constuctor
+    def initialize
+
+      @symbols = {
+        :unknown   => [ "(UU)", "LightBlue"   ],
+        :trace     => [ "(**)", "LightBlue"   ],
+        :debug     => [ "(++)", "LightBlue"   ],
+        :info      => [ "(--)", "Brown"       ],
+        :notice    => [ "(==)", "Brown"       ],
+        :warning   => [ "(WW)", "Yellow"      ],
+        :error     => [ "(EE)", "LightRed"    ],
+        :critical  => [ "(!!)", "LightRed"    ],
+        :alert     => [ "(!!)", "LightRed"    ],
+        :fatal     => [ "(!!)", "LightRed"    ],
+
+        :success   => [ "(II)", "LightGreen"  ],
+        :question  => [ "(??)", "LightCyan"   ]
+      }
+
+      @color    = true
+      @silent   = false
+
+      # # Determine what levels are relevant for XMPP based on @options.xmpp_message_level
+      # levels          = @symbols.keys.to_a
+      # @xmpp_relevant  = levels.slice( levels.index( @options.xmpp_message_level ), levels.length ) unless( @xmpp.nil? )
+
+      # # Handle XMPP Setup
+      # @xmpp     = nil
+
+      # if( @options.xmpp )
+      #   # FIXME: Re-write wrapper to a more proper form
+      #   # @xmpp         = XMPPLogger.new( @options.server_xmpp_id, @options.server_xmpp_password, @options.client_xmpp_ids )
+      #   # @xmpp.level   = Logger::ERROR # default level on which messages will be sent
+      #   # @xmpp.error "Houston, we have a problem"
+
+      #   @xmpp   = Jabber::Simple.new( @options.server_xmpp_id, @options.server_xmpp_password )
+      # end
+    end  # }}}
+
+    # @fn         def colorize color, message # {{{
+    # @brief      The function colorize takes a message and wraps it into standard color commands such as for baih.
+    #
+    # @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
+    #
+    # @note       This might not work for your terminal
+    #
+    # 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
+    #
+    def colorize color, message 
+
+      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",
+        "Purple"      => "\e[0;35m",
+        "LightPurple" => "\e[1;35m",
+        "Brown"       => "\e[0;33m",
+        "Yellow"      => "\e[1;33m",
+        "White"       => "\e[1;37m",
+        "NoColor"     => "\e[0m"
+      }
+
+      raise ArgumentError, "Function arguments cannot be nil" if( color.nil? or message.nil? )
+      raise ArgumentError, "Unknown color" unless( colors.keys.include?( color ) )
+
+      colors[ color ] + message + colors[ "NoColor" ]
+    end # of def colorize }}}
+
+    # @fn         def message level, msg, colorize = @options.colorize # {{{
+    # @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         Ruby symbol, can either be :info, :success, :error or :question
+    # @param      [String]      msg           String, which represents the message you want to send to stdout (info, ok, question) stderr (error)
+    #
+    # Helpers: colorize
+    #
+    def message level, msg #, colorize = @options.colorize, silent = @options.silent
+
+      # return if( silent )
+
+      raise ArugmentError, "Can't find the corresponding symbol for this message level (#{level.to_s}) - is the spelling wrong?" unless( @symbols.key?( level )  )
+
+      print = []
+
+      output = ( level == :error ) ? ( "STDERR.puts" ) : ( "STDOUT.puts" )
+      print << output
+      print << "colorize(" if( @color )
+      print << "\"" + @symbols[ level ].last + "\"," if( @color )
+      print << "\"#{@symbols[ level ].first.to_s} #{msg.to_s}\""
+      print << ")" if( @color )
+
+      print.clear if( @silent )
+
+      eval( print.join( " " ) )
+
+      # # Send messages also to XMPP clients if activated and in level of interest
+      # if( @options.xmpp )
+
+      #   @options.client_xmpp_ids.each do |address|
+      #     next unless( @xmpp_relevant.include?( level ) )
+
+      #     @xmpp.deliver( address, @symbols[level].first.to_s + " " + msg.to_s )
+      #   end
+      # end
+
+      # # Send messages also to AMQP queue if activated and in the level of interest
+      # if( @options.amqp )
+
+      #   EventMachine.next_tick do
+      #     AMQP.channel ||= AMQP::Channel.new(AMQP.connection)
+
+      #     # Durable -> http://rubydoc.info/github/ruby-amqp/amqp/master/AMQP/Channel
+      #     AMQP.channel.queue("#{@options.amqp_server_routing_key_base.to_s}.logger", :durable => true)
+
+      #     3.times do |i|
+      #       puts "[auth][after_fork/amqp] Publishing a warmup message ##{i}"
+
+      #       AMQP.channel.default_exchange.publish( @symbols[level].first.to_s + " " + msg.to_s, :routing_key => "#{@options.amqp_server_routing_key_base.to_s}.logger")
+      #     end # of 3.times
+      #   end # of EventMachine
+
+      # end # of if( @options.amqp )
+
+    end # of def message }}}
+
+    attr_accessor :color, :silent
+
+  end # of class Logger
+
+end # of module ClothesNetwork
+
+
+# vim:ts=2:tw=100:wm=100