surrounded 0.8.4 → 0.9.0

data/javascripts/main.js

@@ -0,0 +1 @@
+console.log('This would be the main JS file.');

data/javascripts/scale.fix.js

@@ -0,0 +1,17 @@
+var metas = document.getElementsByTagName('meta');
+var i;
+if (navigator.userAgent.match(/iPhone/i)) {
+  for (i=0; i<metas.length; i++) {
+    if (metas[i].name == "viewport") {
+      metas[i].content = "width=device-width, minimum-scale=1.0, maximum-scale=1.0";
+    }
+  }
+  document.addEventListener("gesturestart", gestureStart, false);
+}
+function gestureStart() {
+  for (i=0; i<metas.length; i++) {
+    if (metas[i].name == "viewport") {
+      metas[i].content = "width=device-width, minimum-scale=0.25, maximum-scale=1.6";
+    }
+  }
+}

data/lib/surrounded/access_control.rb

@@ -33,10 +33,10 @@ module Surrounded
       mod.class_eval {
         define_method "disallow_#{name}?" do
           begin
-            apply_roles if __apply_role_policy == :trigger
+            apply_behaviors
             instance_exec(&block)
           ensure
-            remove_roles if __apply_role_policy == :trigger
+            remove_behaviors
           end
         end
       }
@@ -58,6 +58,18 @@ module Surrounded
           !self.respond_to?(method_restrictor, true) || !self.send(method_restrictor)
         }.to_set
       end
+
+      # Ask if the context will allow access to a trigger given the current players.
+      def allow?(name)
+        unless self.respond_to?(name)
+          raise NoMethodError, %{undefined method `#{name}' for #{self.inspect}}
+        end
+        if self.respond_to?("disallow_#{name}?")
+          !self.public_send("disallow_#{name}?")
+        else
+          true
+        end
+      end
     end
   end
 end

data/lib/surrounded/context.rb

@@ -2,6 +2,7 @@ require 'set'
 require 'surrounded/context/role_map'
 require 'surrounded/context/role_builders'
 require 'surrounded/context/initializing'
+require 'surrounded/context/trigger_controls'
 require 'surrounded/access_control'
 require 'surrounded/shortcuts'
 require 'surrounded/east_oriented'
@@ -15,18 +16,18 @@ require 'surrounded/east_oriented'
 module Surrounded
   module Context
     def self.extended(base)
-      base.extend RoleBuilders, Initializing
       base.class_eval {
+        extend RoleBuilders, Initializing
+
         @triggers = Set.new
         include InstanceMethods
-      }
-    end
 
-    # Provides a Set of all available trigger methods where
-    # behaviors will be applied to the roles before execution
-    # and removed afterward.
-    def triggers
-      @triggers.dup
+        trigger_mod = Module.new
+        const_set('TriggerMethods', trigger_mod)
+        include trigger_mod
+
+        extend TriggerControls
+      }
     end
 
     private
@@ -39,15 +40,6 @@ module Surrounded
     class << self
       attr_writer :default_role_type
     end
-    
-    # Provide the ability to create access control methods for your triggers.
-    def protect_triggers;  self.extend(::Surrounded::AccessControl); end
-    
-    # Automatically create class methods for each trigger method.
-    def shortcut_triggers; self.extend(::Surrounded::Shortcuts); end
-    
-    # Automatically return the context object from trigger methods.
-    def east_oriented_triggers; self.extend(::Surrounded::EastOriented); end
 
     def default_role_type
       @default_role_type ||= Surrounded::Context.default_role_type
@@ -57,87 +49,25 @@ module Surrounded
     def default_role_type=(type)
       @default_role_type = type
     end
-
-    # Set the time to apply roles to objects. Either :trigger or :initialize. 
-    # Defaults to :trigger
-    def apply_roles_on(which)
-      @__apply_role_policy = which
-    end
-
-    def __apply_role_policy
-      @__apply_role_policy ||= :trigger
-    end
-
-    # Creates a context instance method which will apply behaviors to role players
-    # before execution and remove the behaviors after execution.
-    #
-    # Alternatively you may define your own methods then declare them as triggers
-    # afterward.
-    # 
-    # Example:
-    #   trigger :some_event do
-    #     # code here
-    #   end
-    #
-    #   def some_event
-    #     # code here
-    #   end
-    #   trigger :some_event
-    #
-    def trigger(*names, &block)
-      if block.nil?
-        names.each do |name|
-          convert_method_to_trigger(name)
-        end
-      else
-        name = names.first
-        define_method(name, &block)
-        convert_method_to_trigger(name)
-      end
-    end
-
-    def store_trigger(*names)
-      @triggers.merge(names)
-    end
     
-    def convert_method_to_trigger(name)
-      unless triggers.include?(name) || name.nil?
-        alias_method :"__trigger_#{name}", :"#{name}"
-        private :"__trigger_#{name}"
-        remove_method :"#{name}"
-        define_trigger_wrap_method(name)
-        store_trigger(name)
-      end
-    end
+    # Provide the ability to create access control methods for your triggers.
+    def protect_triggers;  self.extend(::Surrounded::AccessControl); end
 
-    def define_trigger_wrap_method(name)
-      mod = Module.new
-      line = __LINE__
-      mod.class_eval %{
-        def #{name}(*args, &block)
-          begin
-            apply_roles if __apply_role_policy == :trigger
+    # Automatically create class methods for each trigger method.
+    def shortcut_triggers; self.extend(::Surrounded::Shortcuts); end
 
-            #{trigger_return_content(name)}
+    # Automatically return the context object from trigger methods.
+    def east_oriented_triggers; self.extend(::Surrounded::EastOriented); end
 
-          ensure
-            remove_roles if __apply_role_policy == :trigger
-          end
-        end
-      }, __FILE__, line
-      const_set("SurroundedTrigger#{name.to_s.upcase.sub(/\?\z/,'Query')}", mod)
-      include mod
-    end
-    
-    def trigger_return_content(name, *args, &block)
-      %{self.send("__trigger_#{name}", *args, &block)}
-    end
-    
     # === Utility shortcuts
+
+    def role_const_defined?(name)
+      const_defined?(name, false)
+    end
     
     # Set a named constant and make it private
     def private_const_set(name, const)
-      unless self.const_defined?(name, false)
+      unless role_const_defined?(name)
         const = const_set(name, const)
         private_constant name.to_sym
       end
@@ -157,10 +87,6 @@ module Surrounded
       end
     end
 
-    def role_const_defined?(name)
-      const_defined?(name, false)
-    end
-
     module InstanceMethods
       # Check whether a given name is a role inside the context.
       # The provided block is used to evaluate whether or not the caller
@@ -183,14 +109,6 @@ module Surrounded
 
       private
 
-      def preinitialize
-        @__apply_role_policy = self.class.send(:__apply_role_policy)
-      end
-
-      def postinitialize
-        apply_roles if __apply_role_policy == :initialize
-      end
-
       def role_map
         @role_map ||= RoleMap.new
       end
@@ -221,59 +139,65 @@ module Surrounded
         role_map.update(role, role_module_basename(mod_name), object)
       end
 
-      def __apply_role_policy
-        @__apply_role_policy
-      end
-
-      def add_interface(role, behavior, object)
+      def apply_behavior(role, behavior, object)
         if behavior && role_const_defined?(behavior)
-          applicator = role_const(behavior).is_a?(Class) ? method(:add_class_interface) : method(:add_module_interface)
-
-          role_player = applicator.call(object, role_const(behavior))
+          applicator = if self.respond_to?("apply_behavior_#{role}")
+                          method("apply_behavior_#{role}")
+                        elsif role_const(behavior).is_a?(Class)
+                          method(:apply_class_behavior)
+                        else
+                          method(:apply_module_behavior)
+                        end
+
+          role_player = applicator.call(role_const(behavior), object)
           map_role(role, behavior, role_player)
         end
         role_player || object
       end
 
-      def add_module_interface(obj, mod)
+      def apply_module_behavior(mod, obj)
         adder_name = module_extension_methods.find{|meth| obj.respond_to?(meth) }
-        return obj if !adder_name
+        return obj unless adder_name
 
         obj.method(adder_name).call(mod)
         obj
       end
 
-      def add_class_interface(obj, klass)
+      def apply_class_behavior(klass, obj)
         wrapper_name = wrap_methods.find{|meth| klass.respond_to?(meth) }
         return obj if !wrapper_name
         klass.method(wrapper_name).call(obj)
       end
-
-      def remove_interface(role, behavior, object)
+      
+      def remove_behavior(role, behavior, object)
         if behavior && role_const_defined?(behavior)
-          remover_name = (module_removal_methods + unwrap_methods).find{|meth| object.respond_to?(meth) }
+          remover_name = (module_removal_methods + unwrap_methods).find do |meth|
+            object.respond_to?(meth)
+          end
         end
 
-        if remover_name
-          role_player = object.send(remover_name)
-        end
+        role_player = if self.respond_to?("remove_behavior_#{role}")
+                        self.send("remove_behavior_#{role}", role_const(behavior), object)
+                      elsif remover_name
+                        object.send(remover_name)
+                      end
 
         role_player || object
       end
 
-      def apply_roles
+      def apply_behaviors
         role_map.each do |role, mod_name, object|
-          player = add_interface(role, mod_name, object)
+          player = apply_behavior(role, mod_name, object)
           player.send(:store_context, self) do; end
         end
       end
 
-      def remove_roles
+      def remove_behaviors
         role_map.each do |role, mod_name, player|
           if player.respond_to?(:remove_context, true)
             player.send(:remove_context) do; end
           end
-          remove_interface(role, mod_name, player)
+          remove_behavior(role, mod_name, player)
         end
       end
 

data/lib/surrounded/context/initializing.rb

@@ -3,9 +3,7 @@ module Surrounded
     module Initializing
       def new(*args, &block)
         instance = allocate
-        instance.send(:preinitialize)
         instance.send(:initialize, *args, &block)
-        instance.send(:postinitialize)
         instance
       end
 
@@ -18,11 +16,9 @@ module Surrounded
         line = __LINE__
         mod.class_eval "
           def initialize(#{setup_args.join(',')})
-            preinitialize
             arguments = method(__method__).parameters.map{|arg| eval(arg[1].to_s) }
             @role_map = RoleMap.new
             map_roles(#{setup_args}.zip(arguments))
-            postinitialize
           end
         ", __FILE__, line
         const_set("ContextInitializer", mod)

data/lib/surrounded/context/role_builders.rb

@@ -1,17 +1,3 @@
-# Some features are only available in versions of Ruby
-# where this method is true
-unless defined?(module_method_rebinding?)
-  def module_method_rebinding?
-    return @__module_method_rebinding__ if defined?(@__module_method_rebinding__)
-    sample_method = Enumerable.instance_method(:to_a)
-    @__module_method_rebinding__ = begin
-      !!sample_method.bind(Object.new)
-    rescue TypeError
-      false
-    end
-  end
-end
-
 module Surrounded
   module Context
     module RoleBuilders
@@ -43,19 +29,17 @@ module Surrounded
       alias_method :wrapper, :wrap
 
 
-      if module_method_rebinding?
-        # Create an object which will bind methods to the role player
-        def interface(name, &block)
-          class_basename = name.to_s.gsub(/(?:^|_)([a-z])/){ $1.upcase }
-          interface_name = class_basename + 'Interface'
+      # Create an object which will bind methods to the role player
+      def interface(name, &block)
+        class_basename = name.to_s.gsub(/(?:^|_)([a-z])/){ $1.upcase }
+        interface_name = class_basename + 'Interface'
 
-          behavior = private_const_set(interface_name, Module.new(&block))
+        behavior = private_const_set(interface_name, Module.new(&block))
 
-          require 'surrounded/context/negotiator'
-          undef_method(name)
-          define_method(name) do
-            instance_variable_set("@#{name}", Negotiator.new(role_map.assigned_player(name), behavior))
-          end
+        require 'surrounded/context/negotiator'
+        undef_method(name)
+        define_method(name) do
+          instance_variable_set("@#{name}", Negotiator.new(role_map.assigned_player(name), behavior))
         end
       end
       

data/lib/surrounded/context/role_map.rb

@@ -9,7 +9,7 @@ module Surrounded
 
       def role_player?(object)
         !values(object).empty?
-      rescue ::Triad::ValueNotPresent
+      rescue ::Triad::ItemNotPresent
         false
       end
 

data/lib/surrounded/context/trigger_controls.rb

@@ -0,0 +1,91 @@
+module Surrounded
+  module Context
+    module TriggerControls
+
+      # Provides a Set of all available trigger methods where
+      # behaviors will be applied to the roles before execution
+      # and removed afterward.
+      def triggers
+        @triggers.dup
+      end
+          
+      def store_trigger(*names)
+        @triggers.merge(names)
+      end
+      
+      # Creates a context instance method which will apply behaviors to role players
+      # before execution and remove the behaviors after execution.
+      #
+      # Alternatively you may define your own methods then declare them as triggers
+      # afterward.
+      # 
+      # Example:
+      #   trigger :some_event do
+      #     # code here
+      #   end
+      #
+      #   def some_event
+      #     # code here
+      #   end
+      #   trigger :some_event
+      #
+      def trigger(*names, &block)
+        if block.nil?
+          names.each do |name|
+            convert_method_to_trigger(name)
+          end
+        else
+          name = names.first
+          define_trigger_action(*names, &block)
+          define_trigger(name, &block)
+          store_trigger(name)
+        end
+      end
+      
+      def convert_method_to_trigger(name)
+        unless triggers.include?(name) || name.nil?
+          alias_method :"__trigger_#{name}", :"#{name}"
+          private :"__trigger_#{name}"
+          remove_method :"#{name}"
+          define_trigger(name)
+          store_trigger(name)
+        end
+      end
+
+      def define_trigger(name)
+        line = __LINE__
+        self.class_eval %{
+          def #{name}(*args, &block)
+            begin
+              apply_behaviors
+
+              #{trigger_return_content(name)}
+
+            ensure
+              remove_behaviors
+            end
+          end
+        }, __FILE__, line
+      end
+    
+      def trigger_return_content(name)
+        if method_defined?(name)
+          %{super}
+        else
+          %{self.send("__trigger_#{name}", *args, &block)}
+        end
+      end
+      
+      
+      def define_trigger_action(*name_and_args, &block)
+        trigger_action_module.module_eval do
+          define_method(*name_and_args, &block)
+        end
+      end
+      
+      def trigger_action_module
+        self.const_get('TriggerMethods', false)
+      end
+    end
+  end
+end