surrounded 0.7.3 → 0.8.0

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/context.rb

@@ -5,16 +5,24 @@ require 'surrounded/shortcuts'
 
 # Some features are only available in versions of Ruby
 # where this method is true
-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
+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
 
+# Extend your classes with Surrounded::Context to handle their
+# initialization and application of behaviors to the role players
+# passed into the constructor.
+#
+# The purpose of this module is to help you create context objects
+# which encapsulate the interaction and behavior of objects inside.
 module Surrounded
   module Context
     def self.extended(base)
@@ -32,12 +40,16 @@ module Surrounded
       instance
     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
     end
 
     private
 
+    # Set the default type of implementation for role methods for all contexts.
     def self.default_role_type
       @default_role_type ||= :module
     end
@@ -47,7 +59,11 @@ module Surrounded
     end
     
     # Additional Features
+    
+    # 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
 
     def private_const_set(name, const)
@@ -60,10 +76,12 @@ module Surrounded
       @default_role_type ||= Surrounded::Context.default_role_type
     end
 
+    # Set the default type of implementation for role method for an individual context.
     def default_role_type=(type)
       @default_role_type = type
     end
 
+    # Create a named behavior for a role using the standard library SimpleDelegator.
     def wrap(name, &block)
       require 'delegate'
       wrapper_name = name.to_s.gsub(/(?:^|_)([a-z])/){ $1.upcase }
@@ -73,6 +91,7 @@ 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'
@@ -80,12 +99,14 @@ module Surrounded
         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
       end
     end
 
+    # Define behaviors for your role players
     def role(name, type=nil, &block)
       role_type = type || default_role_type
       if role_type == :module
@@ -108,6 +129,8 @@ module Surrounded
       @__apply_role_policy ||= :trigger
     end
 
+    # Shorthand for creating an instance level initialize method which
+    # handles the mapping of the given arguments to their named role.
     def initialize(*setup_args)
       private_attr_reader(*setup_args)
 
@@ -127,6 +150,22 @@ module Surrounded
       private(*method_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|
@@ -180,12 +219,20 @@ module Surrounded
     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
+      # is allowed to inquire about the roles.
       def role?(name, &block)
         return false unless role_map.role?(name)
-        accessor = eval('self', block.binding)
+        accessor = block.binding.eval('self')
         role_map.role_player?(accessor) && role_map.assigned_player(name)
       end
 
+      # Check if a given object is a role player in the context.
+      def role_player?(obj)
+        role_map.role_player?(obj)
+      end
+
       def triggers
         self.class.triggers
       end
@@ -224,7 +271,7 @@ module Surrounded
 
         role_player = applicator.call(object, behavior)
         map_role(role, role_module_basename(behavior), role_player) if behavior
-        role_player.store_context(self)
+        role_player.send(:store_context, self){}
         role_player
       end
 
@@ -247,7 +294,7 @@ module Surrounded
         remover_name = (module_removal_methods + unwrap_methods).find{|meth| object.respond_to?(meth) }
         return object if !remover_name
 
-        object.remove_context
+        object.send(:remove_context) do; end
         role_player = object.method(remover_name).call
 
         map_role(role, role_module_basename(behavior), role_player) if behavior
@@ -271,18 +318,22 @@ module Surrounded
         end
       end
 
+      # List of possible methods to use to add behavior to an object from a module.
       def module_extension_methods
         [:cast_as, :extend]
       end
 
+      # List of possible methods to use to add behavior to an object from a wrapper.
       def wrap_methods
         [:new]
       end
 
+      # List of possible methods to use to remove behavior from an object with a module.
       def module_removal_methods
         [:uncast]
       end
 
+      # List of possible methods to use to remove behavior from an object with a wrapper.
       def unwrap_methods
         [:__getobj__]
       end

data/lib/surrounded/version.rb

@@ -1,3 +1,3 @@
 module Surrounded
-  VERSION = "0.7.3"
+  VERSION = "0.8.0"
 end

data/lib/surrounded.rb

@@ -1,46 +1,32 @@
 require "surrounded/version"
 require "surrounded/context"
 
+# This module should be added to objects which will enter
+# into context objects. 
+#
+# Its main purpose is to keep a reference to the context
+# and to implement method_missing to handle the relationship
+# to other objects in the context.
 module Surrounded
-  def self.included(klass)
-    klass.class_eval {
-      extend Surrounded::Contextual
-    }
-    unless klass.is_a?(Class)
-      def klass.extended(object)
-        Surrounded.create_surroundings(object)
-      end
-    end
-  end
 
-  def self.extended(object)
-    Surrounded.create_surroundings(object)
-  end
+  private
 
-  module Contextual
-    def new(*args)
-      instance = super
-      Surrounded.create_surroundings(instance)
-      instance
+  def store_context(ctxt, &block)
+    accessor = block.binding.eval('self')
+    if accessor.role_player?(self)
+      surroundings.unshift(ctxt)
     end
   end
 
-  def store_context(ctxt)
-    surroundings.unshift(ctxt)
-  end
-
-  def remove_context
-    surroundings.shift
-  end
-
-  private
-
-  def self.create_surroundings(obj)
-    obj.instance_variable_set(:@__surroundings__, [])
+  def remove_context(&block)
+    accessor = block.binding.eval('self')
+    if accessor.role_player?(self)
+      surroundings.shift
+    end
   end
 
   def surroundings
-    @__surroundings__
+    @__surroundings__ ||= []
   end
 
   def context

data/params.json

@@ -0,0 +1 @@
+{"name":"Surrounded","tagline":"Gives an object implicit access to other objects in it's environment.","body":"# ![Surrounded](http://saturnflyer.github.io/surrounded/images/surrounded.png \"Surrounded\")\r\n## Bring your own complexity\r\n\r\n[![Build Status](https://travis-ci.org/saturnflyer/surrounded.png?branch=master)](https://travis-ci.org/saturnflyer/surrounded)\r\n[![Code Climate](https://codeclimate.com/github/saturnflyer/surrounded.png)](https://codeclimate.com/github/saturnflyer/surrounded)\r\n[![Coverage Status](https://coveralls.io/repos/saturnflyer/surrounded/badge.png)](https://coveralls.io/r/saturnflyer/surrounded)\r\n[![Gem Version](https://badge.fury.io/rb/surrounded.png)](http://badge.fury.io/rb/surrounded)\r\n\r\n# Surrounded aims to make things simple and get out of your way.\r\n\r\nMost of what you care about is defining the behavior of objects. How they interact is important.\r\nThe purpose of this library is to clear away the details of getting things setup and to allow you to make changes to the way you handle roles.\r\n\r\nThere are two main parts to this library. \r\n\r\n1. `Surrounded` gives objects an implicit awareness of other objects in their environments.\r\n2. `Surrounded::Context` helps you create objects which encapsulate other objects. These *are* the environments.\r\n\r\nFirst, take a look at creating contexts. This is where you'll spend most of your time.\r\n\r\n## Easily create encapsulated environments for your objects.\r\n\r\nTypical initialization of an environment, or a Context in DCI, has a lot of code. For example:\r\n\r\n```ruby\r\nclass MyEnvironment\r\n\r\n  attr_reader :employee, :boss\r\n  private :employee, :boss\r\n  def initialize(employee, boss)\r\n    @employee = employee.extend(Employee)\r\n    @boss = boss\r\n  end\r\n\r\n  module Employee\r\n    # extra behavior here...\r\n  end\r\nend\r\n```\r\n\r\nThis code allows the MyEnvironment class to create instances where it will have an `employee` and a `boss` role internally. These are set to `attr_reader`s and are made private.\r\n\r\nThe `employee` is extended with behaviors defined in the `Employee` module, and in this case there's no extra stuff for the `boss` so it doesn't get extended with anything.\r\n\r\nMost of the time you'll follow a pattern like this. Some objects will get extra behavior and some won't. The modules that you use to provide the behavior will match the names you use for the roles to which you assign objects.\r\n\r\nBy adding `Surrounded::Context` you can shortcut all this work.\r\n\r\n```ruby\r\nclass MyEnvironment\r\n  extend Surrounded::Context\r\n  \r\n  initialize(:employee, :boss)\r\n\r\n  module Employee\r\n    # extra behavior here...\r\n  end\r\nend\r\n```\r\n\r\nSurrounded gives you an `initialize` class method which does all the setup work for you.\r\n\r\n## Managing Roles\r\n\r\n_I don't want to use modules. Can't I use something like SimpleDelegator?_\r\n\r\nWell, it just so happens that you can. This code will work just fine:\r\n\r\n```ruby\r\nclass MyEnvironment\r\n  extend Surrounded::Context\r\n  \r\n  initialize(:employee, :boss)\r\n\r\n  class Employee < SimpleDelegator\r\n    # extra behavior here...\r\n  end\r\nend\r\n```\r\n\r\nInstead of extending the `employee` object, Surrounded will run `Employee.new(employee)` to create the wrapper for you. You'll need to include the `Surrounded` module in your wrapper, but we'll get to that.\r\n\r\nBut the syntax can be even simpler than that if you want.\r\n\r\n```ruby\r\nclass MyEnvironment\r\n  extend Surrounded::Context\r\n  \r\n  initialize(:employee, :boss)\r\n\r\n  role :employee do\r\n    # extra behavior here...\r\n  end\r\nend\r\n```\r\n\r\nBy default, this code will create a module for you named `Employee`. If you want to use a wrapper, you can do this:\r\n\r\n```ruby\r\nclass MyEnvironment\r\n  extend Surrounded::Context\r\n  \r\n  initialize(:employee, :boss)\r\n\r\n  wrap :employee do\r\n    # extra behavior here...\r\n  end\r\nend\r\n```\r\n\r\nBut if you're making changes and you decide to move from a module to a wrapper or from a wrapper to a module, you'll need to change that method call. Instead, you could just tell it which type of role to use:\r\n\r\n```ruby\r\nclass MyEnvironment\r\n  extend Surrounded::Context\r\n  \r\n  initialize(:employee, :boss)\r\n\r\n  role :employee, :wrapper do\r\n    # extra behavior here...\r\n  end\r\nend\r\n```\r\n\r\nThe default available types are `:module`, `:wrap` or `:wrapper`, and `:interface`. We'll get to `interface` below. The `:wrap` and `:wrapper` types are the same and they'll both create classes which inherit from SimpleDelegator _and_ include Surrounded for you.\r\n\r\nThese are minor little changes which highlight how simple it is to use Surrounded.\r\n\r\n_Well... I want to use [Casting](https://github.com/saturnflyer/casting) so I get the benefit of modules without extending objects. Can I do that?_\r\n\r\nYup. The ability to use Casting is built-in. If the objects you provide to your context respond to `cast_as` then Surrounded will use that.\r\n\r\n_Ok. So is that it?_\r\n\r\nThere's a lot more. Let's look at the individual objects and what they need for this to be valuable...\r\n\r\n## Objects' access to their environments\r\n\r\nAdd `Surrounded` to your objects to give them awareness of other objects.\r\n\r\n```ruby\r\nclass User\r\n  include Surrounded\r\nend\r\n```\r\n\r\nNow the `User` instances will be able to implicitly access objects in their environment.\r\n\r\nVia `method_missing` those `User` instances can access a `context` object it stores in an internal collection. \r\n\r\nInside of the `MyEnvironment` context we saw above, the `employee` and `boss` objects are instances of `User` for this example.\r\n\r\nBecause the `User` class includes `Surrounded`, the instances of that class will be able to access other objects in the same context implicitly.\r\n\r\nLet's make our context look like this:\r\n\r\n```ruby\r\nclass MyEnvironment\r\n  # other stuff from above is still here...\r\n\r\n  def shove_it\r\n    employee.quit\r\n  end\r\n\r\n  role :employee do\r\n    def quit\r\n      say(\"I'm sick of this place, #{boss.name}!\")\r\n      stomp\r\n      throw_papers\r\n      say(\"I quit!\")\r\n    end\r\n  end\r\nend\r\n```\r\n\r\nWhat's happening in there is that when the `shove_it` method is called on the instance of `MyEnvironment`, the `employee` has the ability to refer to `boss` because it is in the same context, e.g. the same environment.\r\n\r\nThe behavior defined in the `Employee` module assumes that it may access other objects in it's local environment. The `boss` object, for example, is never explicitly passed in as an argument.\r\n\r\nWhat `Surrounded` does for us is to make the relationship between objects and gives them the ability to access each other. Adding new or different roles to the context now only requires that we add them to the context and nothing else. No explicit references must be passed to each individual method. The objects are aware of the other objects around them and can refer to them by their role name.\r\n\r\nI didn't mention how the context is set, however.\r\n\r\n## Tying objects together\r\n\r\nYour context will have methods of it's own which will trigger actions on the objects inside, but we need those trigger methods to set the accessible context for each of the contained objects.\r\n\r\nHere's an example of what we want:\r\n\r\n```ruby\r\nclass MyEnvironment\r\n  # other stuff from above is still here...\r\n\r\n  def shove_it\r\n    employee.store_context(self)\r\n    employee.quit\r\n    employee.remove_context\r\n  end\r\n\r\n  role :employee do\r\n    def quit\r\n      say(\"I'm sick of this place, #{boss.name}!\")\r\n      stomp\r\n      throw_papers\r\n      say(\"I quit!\")\r\n    end\r\n  end\r\nend\r\n```\r\n\r\nNow that the `employee` has a reference to the context, it won't blow up when it hits `boss` inside that `quit` method.\r\n\r\nWe saw how we were able to clear up a lot of that repetitive work with the `initialize` method, so this is how we do it here:\r\n\r\n```ruby\r\nclass MyEnvironment\r\n  # other stuff from above is still here...\r\n\r\n  trigger :shove_it do\r\n    employee.quit\r\n  end\r\n\r\n  role :employee do\r\n    def quit\r\n      say(\"I'm sick of this place, #{boss.name}!\")\r\n      stomp\r\n      throw_papers\r\n      say(\"I quit!\")\r\n    end\r\n  end\r\nend\r\n```\r\n\r\nBy using this `trigger` keyword, our block is the code we care about, but internally the method is created to first set all the objects' current contexts.\r\n\r\nThe context will also store the triggers so that you can, for example, provide details outside of the environment about what triggers exist.\r\n\r\n```ruby\r\ncontext = MyEnvironment.new(current_user, the_boss)\r\ncontext.triggers #=> [:shove_it]\r\n```\r\n\r\nYou might find that useful for dynamically defining user interfaces.\r\n\r\nSometimes I'd rather not use this DSL, however. I want to just write regular methods. \r\n\r\nWe can do that too. You'll need to opt in to this by specifying `set_methods_as_triggers` for the context class.\r\n\r\n```ruby\r\nclass MyEnvironment\r\n  # other stuff from above is still here...\r\n  \r\n  set_methods_as_triggers\r\n\r\n  def shove_it\r\n    employee.quit\r\n  end\r\n\r\n  role :employee do\r\n    def quit\r\n      say(\"I'm sick of this place, #{boss.name}!\")\r\n      stomp\r\n      throw_papers\r\n      say(\"I quit!\")\r\n    end\r\n  end\r\nend\r\n```\r\n\r\nThis will allow you to write methods like you normally would. They are aliased internally with a prefix and the method name that you use is rewritten to add and remove the context for the objects in this context. The public API of your class remains the same, but the extra feature of wrapping your method is handled for you.\r\n\r\nThis will treat all instance methods defined on your context the same way, so be aware of that.\r\n\r\n## Where roles exist\r\n\r\nBy using `Surrounded::Context` you are declaring a relationship between the objects inside playing your defined roles.\r\n\r\nBecause all the behavior is defined internally and only relevant internally, those relationships don't exist outside of the environment.\r\n\r\nSurrounded makes all of your role modules and classes private constants. It's not a good idea to try to reuse behavior defined for one context in another area.\r\n\r\n## The role DSL\r\n\r\nUsing the `role` method to define modules and classes takes care of the setup for you. This way you can swap between implementations:\r\n\r\n```ruby\r\n\r\n  # this uses modules\r\n  role :source do\r\n    def transfer\r\n      self.balance -= amount\r\n      destination.balance += amount\r\n      self\r\n    end\r\n  end\r\n\r\n  # this uses SimpleDelegator and Surrounded\r\n  role :source, :wrap do\r\n    def transfer\r\n      self.balance -= amount\r\n      destination.balance += amount\r\n      __getobj__\r\n    end\r\n  end\r\n\r\n  # this uses a special interface object which pulls\r\n  # methods from a module and applies them to your object.\r\n  role :source, :interface do\r\n    def transfer\r\n      self.balance -= amount\r\n      destination.balance += amount\r\n      self\r\n    end\r\n  end\r\n```\r\n\r\nThe `:interface` option is a special object which has all of its methods removed (excepting `__send__` and `object_id`) so that other methods will be pulled from the ones that you define, or from the object it attempts to proxy.\r\n\r\nNotice that the `:interface` allows you to return `self` whereas the `:wrap` acts more like a wrapper and forces you to deal with that shortcoming by using it's wrapped-object-accessor method: `__getobj__`.\r\n\r\nIf you'd like to choose one and use it all the time, you can set the default:\r\n\r\n```ruby\r\nclass MoneyTransfer\r\n  extend Surrounded::Context\r\n\r\n  self.default_role_type = :interface # also :wrap, :wrapper, or :module\r\n\r\n  role :source do\r\n    def transfer\r\n      self.balance -= amount\r\n      destination.balance += amount\r\n      self\r\n    end\r\n  end\r\nend\r\n```\r\n\r\nOr, if you like, you can choose the default for your entire project:\r\n\r\n```ruby\r\nSurrounded::Context.default_role_type = :interface\r\n\r\nclass MoneyTransfer\r\n  extend Surrounded::Context\r\n\r\n  role :source do\r\n    def transfer\r\n      self.balance -= amount\r\n      destination.balance += amount\r\n      self\r\n    end\r\n  end\r\nend\r\n```\r\n\r\n## Policies for the application of role methods\r\n\r\nThere are 2 approaches to applying new behavior to your objects.\r\n\r\nBy default your context will add methods to an object before a trigger is run\r\nand behaviors will be removed after the trigger is run.\r\n\r\nAlternatively you may set the behaviors to be added during the initialize method\r\nof your context.\r\n\r\nHere's how it works:\r\n\r\n```ruby\r\nclass ActiviatingAccount\r\n  extend Surrounded::Context\r\n\r\n  apply_roles_on(:trigger) # this is the default\r\n  # apply_roles_on(:initialize) # set this to apply behavior from the start\r\n\r\n  initialize(:activator, :account)\r\n\r\n  role :activator do\r\n    def some_behavior; end\r\n  end\r\n\r\n  def non_trigger_method\r\n    activator.some_behavior # not available unless you apply roles on initialize\r\n  end\r\n\r\n  trigger :some_trigger_method do\r\n    activator.some_behavior # always available\r\n  end\r\nend\r\n```\r\n\r\n_Why are those options there?_\r\n\r\nWhen you initialize a context and apply behavior at the same time, you'll need\r\nto remove that behavior. For example, if you are using Casting AND you apply roles on initialize:\r\n\r\n```ruby\r\ncontext = ActiviatingAccount.new(current_user, Account.find(123))\r\ncontext.do_something\r\ncurrent_user.some_behavior # this method is still available\r\ncurrent_user.uncast # you'll have to manually cleanup\r\n```\r\n\r\nBut if you go with the default and apply behaviors on trigger, your roles will be cleaned up automatically:\r\n\r\n```ruby\r\ncontext = ActiviatingAccount.new(current_user, Account.find(123))\r\ncontext.do_something\r\ncurrent_user.some_behavior # NoMethodError\r\n```\r\n\r\n## Overview in code\r\n\r\nHere's a view of the possibilities in code.\r\n\r\n```ruby\r\n# set default role type for *all* contexts in your program\r\nSurrounded::Context.default_role_type = :module # also :wrap, :wrapper, or :interface\r\n\r\nclass ActiviatingAccount\r\n  extend Surrounded::Context\r\n\r\n  apply_roles_on(:trigger) # this is the default\r\n  # apply_roles_on(:initialize) # set this to apply behavior from the start\r\n  \r\n  set_methods_as_triggers # allows you to skip the 'trigger' dsl\r\n  \r\n  # set the default role type only for this class\r\n  self.default_role_type = :module # also :wrap, :wrapper, or :interface\r\n\r\n  initialize(:activator, :account)\r\n\r\n  role :activator do # module by default\r\n    def some_behavior; end\r\n  end\r\n\r\n  #  role :activator, :module do\r\n  #    def some_behavior; end\r\n  #  end\r\n  #\r\n  #  role :activator, :wrap do\r\n  #    def some_behavior; end\r\n  #  end\r\n  #\r\n  #  role :activator, :interface do\r\n  #    def some_behavior; end\r\n  #  end\r\n  #\r\n  # use your own classes if you don't want SimpleDelegator\r\n  # class SomeSpecialRole\r\n  #   include Surrounded # you must remember this\r\n  #   # Surrounded assumes SomeSpecialRole.new(some_special_role)\r\n  #   def initialize(...);\r\n  #     # ... your code here\r\n  #   end\r\n  # end\r\n\r\n  # works as a trigger (assigning the current context) only if set_methods_as_triggers is set\r\n  def regular_method\r\n    activator.some_behavior # behavior not available unless you apply roles on initialize\r\n  end\r\n\r\n  trigger :some_trigger_method do\r\n    activator.some_behavior # behavior always available\r\n  end\r\nend\r\n```\r\n\r\n## Dependencies\r\n\r\nThe dependencies are minimal. The plan is to keep it that way but allow you to configure things as you need. The [Triad](http://github.com/saturnflyer/triad) project was written specifically to manage the mapping of roles and objects to the modules which contain the behaviors.\r\n\r\nIf you're using [Casting](http://github.com/saturnflyer/casting), for example, Surrounded will attempt to use that before extending an object, but it will still work without it.\r\n\r\n## Installation\r\n\r\nAdd this line to your application's Gemfile:\r\n\r\n```ruby\r\ngem 'surrounded'\r\n```\r\n\r\nAnd then execute:\r\n\r\n    $ bundle\r\n\r\nOr install it yourself as:\r\n\r\n    $ gem install surrounded\r\n    \r\n## Installation for Rails\r\n\r\nSee [surrounded-rails](https://github.com/saturnflyer/surrounded-rails)\r\n\r\n## Contributing\r\n\r\n1. Fork it\r\n2. Create your feature branch (`git checkout -b my-new-feature`)\r\n3. Commit your changes (`git commit -am 'Add some feature'`)\r\n4. Push to the branch (`git push origin my-new-feature`)\r\n5. Create new Pull Request\r\n","google":"","note":"Don't delete this file! It's used internally to help with page regeneration."}

data/stylesheets/print.css

@@ -0,0 +1,226 @@
+html, body, div, span, applet, object, iframe,
+h1, h2, h3, h4, h5, h6, p, blockquote, pre,
+a, abbr, acronym, address, big, cite, code,
+del, dfn, em, img, ins, kbd, q, s, samp,
+small, strike, strong, sub, sup, tt, var,
+b, u, i, center,
+dl, dt, dd, ol, ul, li,
+fieldset, form, label, legend,
+table, caption, tbody, tfoot, thead, tr, th, td,
+article, aside, canvas, details, embed,
+figure, figcaption, footer, header, hgroup,
+menu, nav, output, ruby, section, summary,
+time, mark, audio, video {
+  margin: 0;
+  padding: 0;
+  border: 0;
+  font-size: 100%;
+  font: inherit;
+  vertical-align: baseline;
+}
+/* HTML5 display-role reset for older browsers */
+article, aside, details, figcaption, figure,
+footer, header, hgroup, menu, nav, section {
+  display: block;
+}
+body {
+  line-height: 1;
+}
+ol, ul {
+  list-style: none;
+}
+blockquote, q {
+  quotes: none;
+}
+blockquote:before, blockquote:after,
+q:before, q:after {
+  content: '';
+  content: none;
+}
+table {
+  border-collapse: collapse;
+  border-spacing: 0;
+}
+body {
+  font-size: 13px;
+  line-height: 1.5;
+  font-family: 'Helvetica Neue', Helvetica, Arial, serif;
+  color: #000;
+}
+
+a {
+  color: #d5000d;
+  font-weight: bold;
+}
+
+header {
+  padding-top: 35px;
+  padding-bottom: 10px;
+}
+
+header h1 {
+  font-weight: bold;
+  letter-spacing: -1px;
+  font-size: 48px;
+  color: #303030;
+  line-height: 1.2;
+}
+
+header h2 {
+  letter-spacing: -1px;
+  font-size: 24px;
+  color: #aaa;
+  font-weight: normal;
+  line-height: 1.3;
+}
+#downloads {
+  display: none;
+}
+#main_content {
+  padding-top: 20px;
+}
+
+code, pre {
+  font-family: Monaco, "Bitstream Vera Sans Mono", "Lucida Console", Terminal;
+  color: #222;
+  margin-bottom: 30px;
+  font-size: 12px;
+}
+
+code {
+  padding: 0 3px;
+}
+
+pre {
+  border: solid 1px #ddd;
+  padding: 20px;
+  overflow: auto;
+}
+pre code {
+  padding: 0;
+}
+
+ul, ol, dl {
+  margin-bottom: 20px;
+}
+
+
+/* COMMON STYLES */
+
+table {
+  width: 100%;
+  border: 1px solid #ebebeb;
+}
+
+th {
+  font-weight: 500;
+}
+
+td {
+  border: 1px solid #ebebeb;
+  text-align: center;
+  font-weight: 300;
+}
+
+form {
+  background: #f2f2f2;
+  padding: 20px;
+
+}
+
+
+/* GENERAL ELEMENT TYPE STYLES */
+
+h1 {
+  font-size: 2.8em;
+}
+
+h2 {
+  font-size: 22px;
+  font-weight: bold;
+  color: #303030;
+  margin-bottom: 8px;
+}
+
+h3 {
+  color: #d5000d;
+  font-size: 18px;
+  font-weight: bold;
+  margin-bottom: 8px;
+}
+
+h4 {
+  font-size: 16px;
+  color: #303030;
+  font-weight: bold;
+}
+
+h5 {
+  font-size: 1em;
+  color: #303030;
+}
+
+h6 {
+  font-size: .8em;
+  color: #303030;
+}
+
+p {
+  font-weight: 300;
+  margin-bottom: 20px;
+}
+
+a {
+  text-decoration: none;
+}
+
+p a {
+  font-weight: 400;
+}
+
+blockquote {
+  font-size: 1.6em;
+  border-left: 10px solid #e9e9e9;
+  margin-bottom: 20px;
+  padding: 0 0 0 30px;
+}
+
+ul li {
+  list-style: disc inside;
+  padding-left: 20px;
+}
+
+ol li {
+  list-style: decimal inside;
+  padding-left: 3px;
+}
+
+dl dd {
+  font-style: italic;
+  font-weight: 100;
+}
+
+footer {
+  margin-top: 40px;
+  padding-top: 20px;
+  padding-bottom: 30px;
+  font-size: 13px;
+  color: #aaa;
+}
+
+footer a {
+  color: #666;
+}
+
+/* MISC */
+.clearfix:after {
+  clear: both;
+  content: '.';
+  display: block;
+  visibility: hidden;
+  height: 0;
+}
+
+.clearfix {display: inline-block;}
+* html .clearfix {height: 1%;}
+.clearfix {display: block;}

data/stylesheets/pygment_trac.css

@@ -0,0 +1,69 @@
+.highlight  { background: #ffffff; }
+.highlight .c { color: #999988; font-style: italic } /* Comment */
+.highlight .err { color: #a61717; background-color: #e3d2d2 } /* Error */
+.highlight .k { font-weight: bold } /* Keyword */
+.highlight .o { font-weight: bold } /* Operator */
+.highlight .cm { color: #999988; font-style: italic } /* Comment.Multiline */
+.highlight .cp { color: #999999; font-weight: bold } /* Comment.Preproc */
+.highlight .c1 { color: #999988; font-style: italic } /* Comment.Single */
+.highlight .cs { color: #999999; font-weight: bold; font-style: italic } /* Comment.Special */
+.highlight .gd { color: #000000; background-color: #ffdddd } /* Generic.Deleted */
+.highlight .gd .x { color: #000000; background-color: #ffaaaa } /* Generic.Deleted.Specific */
+.highlight .ge { font-style: italic } /* Generic.Emph */
+.highlight .gr { color: #aa0000 } /* Generic.Error */
+.highlight .gh { color: #999999 } /* Generic.Heading */
+.highlight .gi { color: #000000; background-color: #ddffdd } /* Generic.Inserted */
+.highlight .gi .x { color: #000000; background-color: #aaffaa } /* Generic.Inserted.Specific */
+.highlight .go { color: #888888 } /* Generic.Output */
+.highlight .gp { color: #555555 } /* Generic.Prompt */
+.highlight .gs { font-weight: bold } /* Generic.Strong */
+.highlight .gu { color: #800080; font-weight: bold; } /* Generic.Subheading */
+.highlight .gt { color: #aa0000 } /* Generic.Traceback */
+.highlight .kc { font-weight: bold } /* Keyword.Constant */
+.highlight .kd { font-weight: bold } /* Keyword.Declaration */
+.highlight .kn { font-weight: bold } /* Keyword.Namespace */
+.highlight .kp { font-weight: bold } /* Keyword.Pseudo */
+.highlight .kr { font-weight: bold } /* Keyword.Reserved */
+.highlight .kt { color: #445588; font-weight: bold } /* Keyword.Type */
+.highlight .m { color: #009999 } /* Literal.Number */
+.highlight .s { color: #d14 } /* Literal.String */
+.highlight .na { color: #008080 } /* Name.Attribute */
+.highlight .nb { color: #0086B3 } /* Name.Builtin */
+.highlight .nc { color: #445588; font-weight: bold } /* Name.Class */
+.highlight .no { color: #008080 } /* Name.Constant */
+.highlight .ni { color: #800080 } /* Name.Entity */
+.highlight .ne { color: #990000; font-weight: bold } /* Name.Exception */
+.highlight .nf { color: #990000; font-weight: bold } /* Name.Function */
+.highlight .nn { color: #555555 } /* Name.Namespace */
+.highlight .nt { color: #000080 } /* Name.Tag */
+.highlight .nv { color: #008080 } /* Name.Variable */
+.highlight .ow { font-weight: bold } /* Operator.Word */
+.highlight .w { color: #bbbbbb } /* Text.Whitespace */
+.highlight .mf { color: #009999 } /* Literal.Number.Float */
+.highlight .mh { color: #009999 } /* Literal.Number.Hex */
+.highlight .mi { color: #009999 } /* Literal.Number.Integer */
+.highlight .mo { color: #009999 } /* Literal.Number.Oct */
+.highlight .sb { color: #d14 } /* Literal.String.Backtick */
+.highlight .sc { color: #d14 } /* Literal.String.Char */
+.highlight .sd { color: #d14 } /* Literal.String.Doc */
+.highlight .s2 { color: #d14 } /* Literal.String.Double */
+.highlight .se { color: #d14 } /* Literal.String.Escape */
+.highlight .sh { color: #d14 } /* Literal.String.Heredoc */
+.highlight .si { color: #d14 } /* Literal.String.Interpol */
+.highlight .sx { color: #d14 } /* Literal.String.Other */
+.highlight .sr { color: #009926 } /* Literal.String.Regex */
+.highlight .s1 { color: #d14 } /* Literal.String.Single */
+.highlight .ss { color: #990073 } /* Literal.String.Symbol */
+.highlight .bp { color: #999999 } /* Name.Builtin.Pseudo */
+.highlight .vc { color: #008080 } /* Name.Variable.Class */
+.highlight .vg { color: #008080 } /* Name.Variable.Global */
+.highlight .vi { color: #008080 } /* Name.Variable.Instance */
+.highlight .il { color: #009999 } /* Literal.Number.Integer.Long */
+
+.type-csharp .highlight .k { color: #0000FF }
+.type-csharp .highlight .kt { color: #0000FF }
+.type-csharp .highlight .nf { color: #000000; font-weight: normal }
+.type-csharp .highlight .nc { color: #2B91AF }
+.type-csharp .highlight .nn { color: #000000 }
+.type-csharp .highlight .s { color: #A31515 }
+.type-csharp .highlight .sc { color: #A31515 }