activecontext 0.1

data/lib/activecontext.rb

@@ -0,0 +1,26 @@
+require "activecontext/container"
+
+module ActiveContext
+  def biject(*args)
+    inject(*args)
+    outject(*args)
+  end
+  
+  def inject(*names)
+    names.each do |name|
+      raise "invalid inject name #{name}" if methods.include?(name)
+      define_method name do
+        (value = Container.current[name]) && value.is_a?(Proc) ? value.call : value
+      end
+    end
+  end
+  
+  def outject(*names)
+    names.each do |name|
+      raise "invalid outject name #{name}" if methods.include?(:"#{name}=")
+      define_method "#{name}=" do |*args|
+        Container.current[name] = args.first
+      end
+    end
+  end
+end

data/lib/activecontext/container.rb

@@ -0,0 +1,62 @@
+module ActiveContext
+  class Container
+    def initialize
+      @names = {}
+    end
+
+    def register(name, ctx={}, &block)
+      raise "invalid context name" if methods.include?(name)
+      instance_variable_set("@#{name}", ctx)
+
+      eigen = class << self; self; end
+      eigen.send(:define_method, name) do |*args, &block2|
+        raise "#{name} #{args.first} already exist" if @names.key?(args.first)
+        @names[args.first] = name
+        
+        if args.length > 1
+          raise "pass either a block or value. not both." if block2
+          self[args.first] = args[1]
+        end
+        
+        self[args.first] = block2 if block2
+      end
+    end
+
+    def []=(key, value)
+      if @names.key?(key)
+        self.context(@names[key])[key] = value
+      else
+        raise "unknown name #{key}"
+      end
+    end
+
+    def [](key)
+      if @names.key?(key)
+        self.context(@names[key])[key]
+      else
+        raise "unknown name #{key}"
+      end
+    end
+
+    def run(&block)
+      c = Thread.current[:contextualize]
+      raise "found existing container" if c && c != self
+
+      begin
+        Thread.current[:contextualize] = self
+        block.call
+      ensure
+        Thread.current[:contextualize] = nil
+      end unless c
+    end
+
+    def self.current
+      Thread.current[:contextualize]
+    end
+
+    def context(name)
+      instance_variable_get("@#{name}")
+    end
+
+  end
+end

data/lib/activecontext/rack.rb

@@ -0,0 +1,26 @@
+require "activecontext/container"
+require "rack/request"
+
+module ActiveContext
+  class Rack
+    def initialize(app, &block)
+      @app = app
+      @block = block
+    end
+
+    def call(env)
+      req = ::Rack::Request.new(env)
+
+      container = Container.new
+
+      container.register :request, {}
+      container.register :session, req.session
+
+      container.instance_exec(req, &@block) if @block
+
+      container.run do
+        @app.call(env)
+      end
+    end
+  end
+end

data/spec/activecontext_spec.rb

@@ -0,0 +1,178 @@
+require "rspec"
+require "activecontext"
+
+describe ActiveContext do
+  
+  class TestObject
+  end
+  
+  def new_test_object
+    t = TestObject.new
+    
+    def t.eigenclass
+      class << self; self; end
+    end
+    
+    t
+  end
+  
+  describe "inject" do
+    it "should create a method for the injected name" do
+      o = new_test_object
+      o.eigenclass.instance_eval do
+        extend ActiveContext
+        inject :somename
+      end
+      o.should respond_to(:somename)
+    end
+    
+    it "should create multiple methods when passing multiple injected names" do
+      o = new_test_object
+      o.eigenclass.instance_eval do
+        extend ActiveContext
+        inject :somename, :othername
+      end
+      o.should respond_to(:somename)
+      o.should respond_to(:othername)
+    end
+  
+    it "should fail if a method with the same name as injected already exist" do
+      o = new_test_object
+      lambda do
+        o.eigenclass.instance_eval do
+          extend ActiveContext
+            inject :to_s
+        end
+      end.should raise_error("invalid inject name to_s")
+    end
+    
+    it "should return the value of the injected name" do
+      c = ActiveContext::Container.new
+      c.register :request, {}
+      c.request :somename, :joe
+      
+      c.run do
+        o = new_test_object
+        o.eigenclass.instance_eval do
+          extend ActiveContext
+          inject :somename
+        end
+      
+        o.somename.should be(:joe)
+      end
+    end
+  
+    it "should return the value of the injected name" do
+      c = ActiveContext::Container.new
+      c.register :request, {}
+      c.request :somename do
+        :joe
+      end
+      
+      c.run do
+        o = new_test_object
+        o.eigenclass.instance_eval do
+          extend ActiveContext
+          inject :somename
+        end
+      
+        o.somename.should be(:joe)
+      end
+    end
+    
+    it "should return nil if no value exist" do
+      c = ActiveContext::Container.new
+      c.register :request, {}
+      c.request :somename
+      
+      c.run do
+        o = new_test_object
+        o.eigenclass.instance_eval do
+          extend ActiveContext
+          inject :somename
+        end
+      
+        o.somename.should be_nil
+      end
+    end
+    
+  end
+  
+  describe "outject" do
+    it "should create a method for the injected name" do
+      o = new_test_object
+      o.eigenclass.instance_eval do
+        extend ActiveContext
+        outject :somename
+      end
+      o.should respond_to(:"somename=")
+    end
+  
+    it "should create multiple methods when passing multiple outjected names" do
+      o = new_test_object
+      o.eigenclass.instance_eval do
+        extend ActiveContext
+        outject :somename, :othername
+      end
+      o.should respond_to(:"somename=")
+      o.should respond_to(:"othername=")
+    end
+  
+    it "should fail if a method with the same name as outjected already exist" do
+      o = new_test_object
+      lambda do
+        o.eigenclass.instance_eval do
+          extend ActiveContext
+          def dummy=(key, value)
+          end
+          outject :dummy
+        end
+      end.should raise_error("invalid outject name dummy")
+    end
+    
+    it "should set the outjected value and read it back" do
+      c = ActiveContext::Container.new
+      ctx = {}
+      c.register :request, ctx
+      c.request :somename, :joe
+      
+      c.run do
+        o = new_test_object
+        o.eigenclass.instance_eval do
+          extend ActiveContext
+          inject :somename
+          outject :somename
+        end
+  
+        o.somename = :bob
+        o.somename.should be(:bob)
+      end
+      
+      ctx.should eql({:somename => :bob})
+    end
+  end
+  
+  describe "biject" do
+    it "should create a method pair for injected and outjected of the passed name" do
+      o = new_test_object
+      o.eigenclass.instance_eval do
+        extend ActiveContext
+        biject :somename
+      end
+      o.should respond_to(:somename)
+      o.should respond_to(:"somename=")
+    end
+    
+    it "should create multiple method pairs for injected an outjected of the passed names" do
+      o = new_test_object
+      o.eigenclass.instance_eval do
+        extend ActiveContext
+        biject :somename, :othername
+      end
+      o.should respond_to(:somename)
+      o.should respond_to(:"somename=")
+      o.should respond_to(:othername)
+      o.should respond_to(:"othername=")
+    end
+  end
+end

data/spec/container_spec.rb

@@ -0,0 +1,136 @@
+require "rspec"
+require "activecontext/container"
+
+describe ActiveContext::Container do
+  
+  it "should not contain any known names" do
+    ActiveContext::Container.new.instance_variable_get("@names").should be_empty
+  end
+  
+  it "should fail if an unknown name is accessed" do
+    c = ActiveContext::Container.new
+    lambda do
+      c[:key]
+    end.should raise_error("unknown name key")
+  end
+
+  it "should fail when setting an unknown name" do
+    c = ActiveContext::Container.new
+    lambda do
+      c[:key] = 1
+    end.should raise_error("unknown name key")
+  end
+  
+  it "should set current container, run block and clean up container" do
+    c = ActiveContext::Container.new
+    c.run do
+      ActiveContext::Container.current.should be(c)
+    end
+    ActiveContext::Container.current.should be_nil
+  end
+  
+  it "should support nesting of the same container" do
+    c = ActiveContext::Container.new
+    c.run do
+      c.run do
+        ActiveContext::Container.current.should be(c)
+      end
+      ActiveContext::Container.current.should be(c)
+    end
+    ActiveContext::Container.current.should be_nil
+  end
+  
+  it "should fail when different container exist" do
+    c = ActiveContext::Container.new
+    c.run do
+      c2 = ActiveContext::Container.new
+      lambda do
+        c2.run
+      end.should raise_error("found existing container")
+    end
+  end
+  
+  describe "registering a context" do
+    it "should create an instance variable with same name as context" do
+      c = ActiveContext::Container.new
+      ctx = {}
+      c.register :request, ctx
+      c.context("request").should eq(ctx)
+    end
+    
+    it "should create a method with same name as context to declare names in this context" do
+      c = ActiveContext::Container.new
+      c.register :request, {}
+      c.methods(:request).should_not be_nil
+    end
+    
+    it "should fail when a method with same name already exist" do
+      c = ActiveContext::Container.new
+      lambda do
+        c.register :register, {}
+      end.should raise_error("invalid context name")
+    end
+    
+    describe "registering a name" do
+      it "should map the name to a context" do
+        c = ActiveContext::Container.new
+        c.register :request, {}
+        c.request :somename
+        c.instance_variable_get("@names").should eq({:somename => :request})
+      end
+      
+      it "should fail if name already exist" do
+        c = ActiveContext::Container.new
+        c.register :request, {}
+        c.request :somename
+        lambda do
+          c.request :somename
+        end.should raise_error("request somename already exist")
+      end
+      
+      it "should take a initial value as second argument" do
+        c = ActiveContext::Container.new
+        c.register :request, {}
+        c.request :somename, :joe
+        c.context("request")[:somename].should be(:joe)
+      end
+
+      it "should take a initial value factory as block" do
+        c = ActiveContext::Container.new
+        c.register :request, {}
+        factory = -> { :joe }
+        c.request :somename, &factory
+        c.context("request")[:somename].should be(factory)
+      end
+      
+      it "should fail when passing a initial value argument and a block at the same time" do
+        c = ActiveContext::Container.new
+        c.register :request, {}
+        factory = -> { :joe }
+        lambda do
+          c.request :somename, :bob, &factory
+        end.should raise_error("pass either a block or value. not both.")
+      end
+    end
+    
+    it "should set a value" do
+      c = ActiveContext::Container.new
+      c.register :request, {}
+      c.request :somename
+      c[:somename] = :joe
+      c[:somename].should be(:joe)
+    end
+    
+    it "should get the initial value" do
+      c = ActiveContext::Container.new
+      c.register :request, {}
+      c.request :somename, :joe
+      c.request :othername do
+        :bob
+      end
+      c[:somename].should be(:joe)
+      c[:othername].call.should be(:bob)
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: activecontext
+version: !ruby/object:Gem::Version
+  version: '0.1'
+  prerelease: 
+platform: ruby
+authors:
+- jan zimmek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70264750979080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70264750979080
+description: ''
+email:
+- jan.zimmek@web.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/activecontext/container.rb
+- lib/activecontext/rack.rb
+- lib/activecontext.rb
+- spec/activecontext_spec.rb
+- spec/container_spec.rb
+homepage: http://www.github.com/jzimmek/activecontext
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: ''
+test_files: []