angry_mob 0.1.0

data/lib/angry_mob/target/notify.rb

@@ -0,0 +1,57 @@
+class AngryMob
+  class Target
+    class Notify
+      attr_reader :target, :args, :actions
+      def nickname; @target end
+
+      def initialize(act)
+        @act = act
+
+        @target = nil
+        @args = AngryHash.new
+
+        @actions = []
+
+        @backtrace = caller
+      end
+
+      def inject_actions(args)
+        args.actions = @actions
+      end
+
+      def call(mob)
+        raise "not used anymore"
+        args = Arguments.parse(@args)
+        inject_actions(args)
+        
+        # localise to save into closure
+        target = @target
+
+        # this block is instance_eval'd
+        @act.in_sub_act do
+          send(target, args)
+        end
+      end
+
+      def method_missing(method,*args,&blk)
+        if ! @target
+          @target = method.to_s
+          @args = AngryHash.__convert_without_dup( args.first ) if args.first
+        end
+
+        if method == :now
+          raise "notify.now is no longer supported"
+
+        else
+          @actions << method.to_s
+        end
+
+        return self
+      end
+
+      def inspect
+        "#<AM::T::Notify target=#{@target} actions=#{@actions.inspect}>"
+      end
+    end
+  end
+end

data/lib/angry_mob/target/tracking.rb

@@ -0,0 +1,96 @@
+class AngryMob
+  class Target
+    module Tracking
+      class << self
+        def included(base) #:nodoc:
+          base.send :extend,  ClassMethods
+        end
+
+        # Returns the classes that inherit from AngryMob::Target
+        def subclasses
+          @subclasses ||= {}
+        end
+
+        # Returns the files where the subclasses are kept.
+        def subclass_files
+          @subclass_files ||= Hash.new{ |h,k| h[k] = [] }
+        end
+
+        # Whenever a class inherits from AngryMob::Target, we should track the
+        # class and the file on AngryMob::Target::Tracking. This is the method responsable for it.
+        #
+        def register_klass_file(klass) #:nodoc:
+          file = caller[1].match(/(.*):\d+/)[1]
+
+          nickname = klass.nickname.to_s
+          AngryMob::Target::Tracking.subclasses[nickname] = klass unless AngryMob::Target::Tracking.subclasses.key?(nickname)
+
+          file_subclasses = AngryMob::Target::Tracking.subclass_files[File.expand_path(file)]
+          file_subclasses << klass unless file_subclasses.include?(klass)
+        end
+      end
+
+      module ClassMethods
+        # Everytime someone inherits from a AngryMob::Target class, register the klass
+        # and file into baseclass.
+        def inherited(klass)
+          AngryMob::Target::Tracking.register_klass_file(klass)
+        end
+
+        # Fire this callback whenever a method is added. Added methods are
+        # tracked as tasks by invoking the create_task method.
+        def method_added(meth)
+          meth = meth.to_s
+
+          if meth == "initialize"
+            initialize_added
+            return
+          end
+
+          # Return if it's not a public instance method
+          return unless public_instance_methods.include?(meth) ||
+                        public_instance_methods.include?(meth.to_sym)
+
+          return unless create_action(meth)
+
+          #is_thor_reserved_word?(meth, :task)
+          AngryMob::Target::Tracking.register_klass_file(self)
+        end
+
+        def nickname(name=nil)
+          if name
+            @nickname = name
+            AngryMob::Target::Tracking.register_klass_file(self)
+          else
+            if @nickname
+              @nickname
+            else
+              Util.snake_case(to_s)
+            end
+          end
+        end
+
+        protected
+
+        # Retrieves a value from superclass. If it reaches the baseclass,
+        # returns default.
+        def from_superclass(method, default=nil)
+          if self == baseclass || !superclass.respond_to?(method, true)
+            default
+          else
+            value = superclass.send(method)
+            value.dup if value
+          end
+        end
+
+
+        def create_action(meth)
+        end
+
+        def initialize_added
+        end
+
+      end
+    end
+  end
+end

data/lib/angry_mob/ui.rb

@@ -0,0 +1,247 @@
+
+class AngryMob
+  class UI
+    # Embed in a String to clear all previous ANSI sequences.
+    CLEAR      = "\e[0m"
+    # The start of an ANSI bold sequence.
+    BOLD       = "\e[1m"
+
+    # Set the terminal's foreground ANSI color to black.
+    BLACK      = "\e[30m"
+    # Set the terminal's foreground ANSI color to red.
+    RED        = "\e[31m"
+    # Set the terminal's foreground ANSI color to green.
+    GREEN      = "\e[32m"
+    # Set the terminal's foreground ANSI color to yellow.
+    YELLOW     = "\e[33m"
+    # Set the terminal's foreground ANSI color to blue.
+    BLUE       = "\e[34m"
+    # Set the terminal's foreground ANSI color to magenta.
+    MAGENTA    = "\e[35m"
+    # Set the terminal's foreground ANSI color to cyan.
+    CYAN       = "\e[36m"
+    # Set the terminal's foreground ANSI color to white.
+    WHITE      = "\e[37m"
+
+    GRAY      = "#{BOLD}#{BLACK}"
+
+    BRIGHT_WHITE = "#{BOLD}#{WHITE}"
+
+    # Set the terminal's background ANSI color to black.
+    ON_BLACK   = "\e[40m"
+    # Set the terminal's background ANSI color to red.
+    ON_RED     = "\e[41m"
+    # Set the terminal's background ANSI color to green.
+    ON_GREEN   = "\e[42m"
+    # Set the terminal's background ANSI color to yellow.
+    ON_YELLOW  = "\e[43m"
+    # Set the terminal's background ANSI color to blue.
+    ON_BLUE    = "\e[44m"
+    # Set the terminal's background ANSI color to magenta.
+    ON_MAGENTA = "\e[45m"
+    # Set the terminal's background ANSI color to cyan.
+    ON_CYAN    = "\e[46m"
+    # Set the terminal's background ANSI color to white.
+    ON_WHITE   = "\e[47m"
+    
+    attr_reader :level, :result, :message, :stack
+
+    def initialize(options={}, min_level=0, stack=[])
+      @options = options
+      @stack = stack
+      @min_level = @level = min_level
+      @colour = CLEAR
+    end
+
+    #def self.stack; @stack ||= [] end
+    #def stack; self.class.stack end
+    def current
+      stack.last || self
+    end
+
+    def colourise(string, colour, bold=false)
+      color = self.class.const_get(colour.to_s.upcase) if colour.is_a?(Symbol)
+      bold  = bold ? BOLD : ""
+      "#{bold}#{color}#{string}#{CLEAR}"
+    end
+
+    def recolourize(colour)
+      $stdout.print("\e[s\e[1G#{RED}\e[u")
+    end
+
+    def say(message="", colour=nil, force_new_line=(message.to_s !~ /( |\t)$/))
+      return if self.class.silence?
+
+      message  = message.to_s
+      message  = colourise(message, colour) if colour
+
+      if force_new_line
+        $stdout.puts(message)
+      else
+        $stdout.print(message)
+        $stdout.flush
+      end
+    end
+
+    def isay(message, colour=nil, force_new_line=(message.to_s !~ /( |\t)$/))
+      say spaces+message, colour, force_new_line
+    end
+
+    def newline
+      $stdout.puts "\n" unless self.class.silence?
+    end
+
+    def spaces
+      "  " * @level
+    end
+
+    def indent
+      @level += 1
+    end
+
+    def outdent
+      @level -= 1
+      @level = @min_level if @level < @min_level
+    end
+
+    def self.silence(&block)
+      old_silence,@silence = @silence,true
+      yield
+    ensure
+      @silence = old_silence
+    end
+    def self.silence?
+      @silence
+    end
+    def silence(&block)
+      self.class.silence(&block)
+    end
+    def silence(&block)
+      self.class.silence(&block)
+    end
+
+    def info(message)
+      say spaces+message, :bright_white
+    end
+
+    def good(message)
+      say spaces+message, :green
+    end
+
+    def task(message)
+      isay ">> ", :blue
+      say message
+    end
+
+    def log(message)
+      say spaces+indent_string(message, @level+1), :white
+    end
+
+    def point(message)
+      say spaces+"● #{message}", :blue
+    end
+
+    def error(message)
+      say spaces+message, :red
+    end
+    alias_method :bad, :error
+
+    def debug?
+      @debug ||= !(FalseClass === @options[:debug])
+    end
+    def debug(message)
+      say spaces+message, :gray if debug?
+    end
+
+    def benchmark?
+      @benchmark ||= !(FalseClass === @options[:benchmark])
+    end
+
+    def warn(message)
+      say spaces+message, :yellow
+    end
+
+    def push(message,opts={},&block)
+      start_time = Time.now
+      start! message
+      subui = self.class.new(@options, @level+1,stack)
+
+      stack.push subui
+
+      begin
+        yield
+      rescue Object
+        if opts[:bubble]
+          raise $!
+        else
+          subui.exception!($!)
+        end
+      end
+    ensure
+      stack.pop
+
+      say spaces+'}', :yellow, false
+
+      colour = nil
+
+      case subui.result
+      when :ok
+        colour = :green
+        say " ✓ #{message}", :green, false
+        say " (#{subui.message})", :green, false if subui.message
+
+      when :skip
+        colour = :blue
+        say " ● #{message}", :blue, false
+        say " (#{subui.message})", :blue, false if subui.message
+
+      when Exception
+        colour = :red
+        say " ☠ #{message}", :red, false
+        say " (#{subui.message})", :red, false if subui.message
+        newline
+        raise subui.result
+
+      else
+        colour = :gray
+        say " #{message}", :gray, false
+      end
+
+      say(" (#{Time.now-start_time}s)", colour, false) if benchmark?
+
+      newline
+      newline
+    end
+
+    def start!(banner)
+      say spaces+">> ", :blue
+      say banner, :white, false
+      say " {", :yellow
+    end
+
+    def exception!(ex)
+      msg = "[#{ex.class}] - #{ex.message}"
+      say spaces+msg, :red
+      # backtrace
+
+      @result = ex
+      @message = msg
+    end
+
+    def ok!(message=nil)
+      @result = :ok
+      @message = message
+    end
+    alias_method :changed!, :ok!
+
+    def skipped!(message)
+      @result = :skip
+      @message = message
+    end
+
+    protected
+    def indent_string(string,level=@level)
+      string.chomp.gsub(/\n/,"\n#{'  ' * level}")
+    end
+  end
+end

data/lib/angry_mob/util.rb

@@ -0,0 +1,11 @@
+class AngryMob
+  class Util
+    class << self
+      def snake_case(str)
+        return str.downcase if str =~ /^[A-Z_]+$/
+        str.gsub(/\B[A-Z]/, '_\&').squeeze('_') =~ /_*(.*)/
+        return $+.downcase
+      end
+    end
+  end
+end

data/lib/angry_mob/vendored.rb

@@ -0,0 +1,8 @@
+require 'pathname'
+Root = Pathname(__FILE__).dirname.join('../..').expand_path
+
+
+%w{json thor angry_hash}.each do |lib|
+  root = Root+'vendor'+lib
+  $LOAD_PATH << (root+'lib')
+end

data/lib/angry_mob/version.rb

@@ -0,0 +1,3 @@
+module AngryMob
+  VERSION = '0.1.0'
+end

data/vendor/angry_hash/Rakefile

@@ -0,0 +1,17 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "angry_hash"
+    gemspec.summary = "A stabler mash with different emphases."
+    gemspec.description = "A stabler mash with different emphases. Used in plus2 projects AngryMob and Igor."
+    gemspec.email = "lachie@plus2.com.au"
+    gemspec.homepage = "http://github.com/plus2/angry_hash"
+    gemspec.authors = ["Lachie Cox"]
+    gemspec.test_files = []
+    gemspec.executables = []
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+

data/vendor/angry_hash/VERSION

@@ -0,0 +1 @@
+0.1.0