angry_mob 0.1.0

data/lib/angry_mob/action.rb

@@ -0,0 +1,11 @@
+class AngryMob
+  class Action
+    def initialize(name,default=false)
+      @default = default
+    end
+
+    def default?
+      !!@default
+    end
+  end
+end

data/lib/angry_mob/builder.rb

@@ -0,0 +1,115 @@
+require 'pathname'
+require 'tsort'
+
+class AngryMob
+  class Builder
+    include Log
+
+    def self.from_file(path)
+      path = Pathname(path)
+      new.from_file(path)
+    end
+
+    attr_reader :node_consolidation_block
+
+    def file
+      if @file
+        @file
+      else
+        '<no-file>'
+      end
+    end
+
+    # read and evaluate a file in builder context
+    def from_file(path)
+      @file = path
+      instance_eval path.read, path.to_s
+      @file = nil
+      self
+    end
+
+    def to_mob
+      mob = Mob.new
+
+      # pre-setup
+      mob.setup_node = lambda {|node,defaults|
+        node_setup_blocks.each {|blk| blk[node,defaults]}
+      }
+
+      # in-setup
+      mob.node_defaults = lambda {|node,defaults|
+        node_default_blocks.each {|blk| blk[node,defaults]}
+      }
+
+      # post-setup
+      mob.consolidate_node = @node_consolidation_block
+
+      # create and bind acts
+      acts.each do |name,(blk,file,multi)|
+        act = Act.new(name,multi,&blk)
+        act.extend helper_mod 
+        act.bind(mob,file)
+      end
+
+      mob
+    end
+
+    #### DSL API
+
+    # Defines an `act` block
+    def act(name, definition_file=nil, &blk)
+      definition_file ||= file
+      acts[name.to_sym] = [blk,definition_file.dup,false]
+    end
+
+    def multi_act(name, definition_file=nil, &blk)
+      definition_file ||= file
+      acts[name.to_sym] = [blk,definition_file.dup,true]
+    end
+
+    def act_helper(&blk)
+      helper_mod.module_eval(&blk)
+    end
+
+    def finalise(*act_names, &blk)
+      act_names.norm.each {|a| act("finalise/#{a}",&blk)}
+    end
+
+    def notifications_for(name,&blk)
+      act("notifications_for/#{name}") { notifications.for(name, :context => self, &blk) }
+    end
+
+    # A `setup_node` block allows the mob to set defaults, load resource locators and anything else you like.
+    def setup_node(&blk)
+      node_setup_blocks << blk
+    end
+
+    def consolidate_node(&blk)
+      @node_consolidation_block = blk
+    end
+
+    # Defaults
+    def node_defaults(&blk)
+      node_default_blocks << blk
+    end
+
+
+    protected
+    def node_setup_blocks
+      @node_setup_blocks ||= []
+    end
+
+    def node_default_blocks
+      @node_default_blocks ||= []
+    end
+
+    def acts
+      @acts ||= Dictionary.new
+    end
+
+    def helper_mod
+      @helper_mod ||= Module.new
+    end
+
+  end
+end

data/lib/angry_mob/extend.rb

@@ -0,0 +1,10 @@
+%w[
+  blank
+  dictionary
+  object
+  array
+  string
+  pathname
+  hash
+  blankslate
+].each {|lib| require "angry_mob/extend/#{lib}" }

data/lib/angry_mob/extend/array.rb

@@ -0,0 +1,30 @@
+class Array
+	def extract_options!
+		if Hash === last then pop else {} end
+	end
+	def extract_options
+		if Hash === last then last else {} end
+	end
+
+  def options
+    if Hash === last
+      self[-1] = AngryHash.__convert(last)
+    else
+      opts = AngryHash.new
+      push opts
+      opts
+    end
+  end
+
+  def norm
+    n = flatten
+    n.compact!
+    n
+  end
+
+  def norm!
+    flatten!
+    compact!
+    self
+  end
+end

data/lib/angry_mob/extend/blank.rb

@@ -0,0 +1,108 @@
+# from extlib
+class Object
+  ##
+  # Returns true if the object is nil or empty (if applicable)
+  #
+  #   [].blank?         #=>  true
+  #   [1].blank?        #=>  false
+  #   [nil].blank?      #=>  false
+  #
+  # @return [TrueClass, FalseClass]
+  #
+  # @api public
+  def blank?
+    nil? || (respond_to?(:empty?) && empty?)
+  end
+  def present?
+    ! blank?
+  end
+end # class Object
+
+class Numeric
+  ##
+  # Numerics are never blank
+  #
+  #   0.blank?          #=>  false
+  #   1.blank?          #=>  false
+  #   6.54321.blank?    #=>  false
+  #
+  # @return [FalseClass]
+  #
+  # @api public
+  def blank?
+    false
+  end
+  def present?
+    true
+  end
+end # class Numeric
+
+class NilClass
+  ##
+  # Nil is always blank
+  #
+  #   nil.blank?        #=>  true
+  #
+  # @return [TrueClass]
+  #
+  # @api public
+  def blank?
+    true
+  end
+  def present?
+    false
+  end
+end # class NilClass
+
+class TrueClass
+  ##
+  # True is never blank.
+  #
+  #   true.blank?       #=>  false
+  #
+  # @return [FalseClass]
+  #
+  # @api public
+  def blank?
+    false
+  end
+  def present?
+    true
+  end
+end # class TrueClass
+
+class FalseClass
+  ##
+  # False is always blank.
+  #
+  #   false.blank?      #=>  true
+  #
+  # @return [TrueClass]
+  #
+  # @api public
+  def blank?
+    true
+  end
+  def present?
+    false
+  end
+end # class FalseClass
+
+class String
+  ##
+  # Strips out whitespace then tests if the string is empty.
+  #
+  #   "".blank?         #=>  true
+  #   "     ".blank?    #=>  true
+  #   " hey ho ".blank? #=>  false
+  #
+  # @return [TrueClass, FalseClass]
+  #
+  # @api public
+  def blank?
+    strip.empty?
+  end
+  def present?
+    ! blank?
+  end
+end # class String

data/lib/angry_mob/extend/blankslate.rb

@@ -0,0 +1,109 @@
+#!/usr/bin/env ruby
+#--
+# Copyright 2004, 2006 by Jim Weirich (jim@weirichhouse.org).
+# All rights reserved.
+
+# Permission is granted for use, copying, modification, distribution,
+# and distribution of modified versions of this work as long as the
+# above copyright notice is included.
+#++
+
+######################################################################
+# BlankSlate provides an abstract base class with no predefined
+# methods (except for <tt>\_\_send__</tt> and <tt>\_\_id__</tt>).
+# BlankSlate is useful as a base class when writing classes that
+# depend upon <tt>method_missing</tt> (e.g. dynamic proxies).
+#
+class BlankSlate
+  class << self
+    
+    # Hide the method named +name+ in the BlankSlate class.  Don't
+    # hide +instance_eval+ or any method beginning with "__".
+    def hide(name)
+      if instance_methods.include?(name.to_s) and
+        name !~ /^(__|instance_eval|instance_exec)/
+        @hidden_methods ||= {}
+        @hidden_methods[name.to_sym] = instance_method(name)
+        undef_method name
+      end
+    end
+
+    def find_hidden_method(name)
+      @hidden_methods ||= {}
+      @hidden_methods[name] || superclass.find_hidden_method(name)
+    end
+
+    # Redefine a previously hidden method so that it may be called on a blank
+    # slate object.
+    def reveal(name)
+      hidden_method = find_hidden_method(name)
+      fail "Don't know how to reveal method '#{name}'" unless hidden_method
+      define_method(name, hidden_method)
+    end
+  end
+  
+  instance_methods.each { |m| hide(m) }
+end
+
+######################################################################
+# Since Ruby is very dynamic, methods added to the ancestors of
+# BlankSlate <em>after BlankSlate is defined</em> will show up in the
+# list of available BlankSlate methods.  We handle this by defining a
+# hook in the Object and Kernel classes that will hide any method
+# defined after BlankSlate has been loaded.
+#
+module Kernel
+  class << self
+    alias_method :blank_slate_method_added, :method_added
+
+    # Detect method additions to Kernel and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      result = blank_slate_method_added(name)
+      return result if self != Kernel
+      BlankSlate.hide(name)
+      result
+    end
+  end
+end
+
+######################################################################
+# Same as above, except in Object.
+#
+class Object
+  class << self
+    alias_method :blank_slate_method_added, :method_added
+
+    # Detect method additions to Object and remove them in the
+    # BlankSlate class.
+    def method_added(name)
+      result = blank_slate_method_added(name)
+      return result if self != Object
+      BlankSlate.hide(name)
+      result
+    end
+
+    def find_hidden_method(name)
+      nil
+    end
+  end
+end
+
+######################################################################
+# Also, modules included into Object need to be scanned and have their
+# instance methods removed from blank slate.  In theory, modules
+# included into Kernel would have to be removed as well, but a
+# "feature" of Ruby prevents late includes into modules from being
+# exposed in the first place.
+#
+class Module
+  alias blankslate_original_append_features append_features
+  def append_features(mod)
+    result = blankslate_original_append_features(mod)
+    return result if mod != Object
+    instance_methods.each do |name|
+      BlankSlate.hide(name)
+    end
+    result
+  end
+end

data/lib/angry_mob/extend/dictionary.rb

@@ -0,0 +1,140 @@
+
+# ** vendored from ActiveSupport 2.3.5 **
+# Hash is ordered in Ruby 1.9!
+if RUBY_VERSION >= '1.9'
+  Dictionary = ::Hash
+else
+  class Dictionary < Hash #:nodoc:
+    def initialize(*args, &block)
+      super
+      @keys = []
+    end
+
+    def self.[](*args)
+      ordered_hash = new
+
+      if (args.length == 1 && args.first.is_a?(Array))
+        args.first.each do |key_value_pair|
+          next unless (key_value_pair.is_a?(Array))
+          ordered_hash[key_value_pair[0]] = key_value_pair[1]
+        end
+
+        return ordered_hash
+      end
+
+      unless (args.size % 2 == 0)
+        raise ArgumentError.new("odd number of arguments for Hash")
+      end
+
+      args.each_with_index do |val, ind|
+        next if (ind % 2 != 0)
+        ordered_hash[val] = args[ind + 1]
+      end
+
+      ordered_hash
+    end
+
+    def initialize_copy(other)
+      super
+      # make a deep copy of keys
+      @keys = other.keys
+    end
+
+    def []=(key, value)
+      @keys << key if !has_key?(key)
+      super
+    end
+
+    def delete(key)
+      if has_key? key
+        index = @keys.index(key)
+        @keys.delete_at index
+      end
+      super
+    end
+
+    def delete_if
+      super
+      sync_keys!
+      self
+    end
+
+    def reject!
+      super
+      sync_keys!
+      self
+    end
+
+    def reject(&block)
+      dup.reject!(&block)
+    end
+
+    def keys
+      @keys.dup
+    end
+
+    def values
+      @keys.collect { |key| self[key] }
+    end
+
+    def to_hash
+      self
+    end
+
+    def to_a
+      @keys.map { |key| [ key, self[key] ] }
+    end
+
+    def each_key
+      @keys.each { |key| yield key }
+    end
+
+    def each_value
+      @keys.each { |key| yield self[key]}
+    end
+
+    def each
+      @keys.each {|key| yield [key, self[key]]}
+    end
+
+    alias_method :each_pair, :each
+
+    def clear
+      super
+      @keys.clear
+      self
+    end
+
+    def shift
+      k = @keys.first
+      v = delete(k)
+      [k, v]
+    end
+
+    def merge!(other_hash)
+      other_hash.each {|k,v| self[k] = v }
+      self
+    end
+
+    def merge(other_hash)
+      dup.merge!(other_hash)
+    end
+
+    # When replacing with another hash, the initial order of our keys must come from the other hash -ordered or not.
+    def replace(other)
+      super
+      @keys = other.keys
+      self
+    end
+
+    def inspect
+      "#<Dictionary #{super}>"
+    end
+
+    private
+
+    def sync_keys!
+      @keys.delete_if {|k| !has_key?(k)}
+    end
+  end
+end