rails_current 1.0.0 → 1.1.0

data/README.md

@@ -2,23 +2,52 @@
 NAME
 --------------------------------
   rails_current
-         
+
+--------------------------------
+DESCRIPTION
+--------------------------------
+
+  track 'current_user' et all in a tidy, global, and thread-safe fashion.
 
 
 --------------------------------
 SYNOPSIS
 --------------------------------
-  most rails apps scatter a bunch of @currentfoobar vars everywhere.  don't do
-  that.  do
+  most rails apps scatter a bunch of @current_foobar vars everywhere.  don't do
+  that.  it's fugly.  instead, do this.
+
+    class ApplicationController
+
+      Current(:user){ User.find session[:current_user }
+      Current(:account)
+
+      include Current
+
+    end
+
+    ...
 
-    Current.user = ...
 
-    if Current.user
+    if current_user
+
+      ...
+
+    end
+
+
+    self.current_account = Account.find(id)
 
-    if Current.account
 
   etc.
 
   out of the box it's loaded with Current.controller
 
+--------------------------------
+INSTALL
+--------------------------------
+
+   gem install rails-current
+
+
    gem 'rails-current', :require => 'current'
+   bundle install

data/lib/rails_current.rb

@@ -1,31 +1,87 @@
-require 'fattr'
+require 'map'
 
 module Current
-  def Current.version() '1.0.0' end
+  def Current.version() '1.1.0' end
+
+  def Current.data
+    Thread.current[:current] ||= Map.new
+  end
+
+  def Current.clear
+    data.clear
+    self
+  end
+
+  def Current.reset
+    calls.keys.each{|name, block| undefine_attribute_method(name) }
+    data.clear
+    calls.clear
+    self
+  end
 
   def Current.attribute(name, *args, &block)
+    options = Map.options_for(args)
+
     name = name.to_s
-    attribute_names.push(name) unless attribute?(name)
-    Fattr(name, *args, &block)
+    default = options.has_key?(:default) ? options[:default] : args.shift
+
+    block ||= proc{ default }
+    calls[name] = block
+
+    define_attribute_method(name)
+    self
+  end
+
+  def Current.calls
+    @calls ||= Map.new
+  end
+
+  def Current.define_attribute_method(name)
+    unless respond_to?(name)
+      singleton_class.module_eval do
+        define_method(name) do
+          if data.has_key?(name)
+            data[name]
+          else
+            data[name] = calls[name].call
+          end
+        end
+
+        define_method(name + '=') do |value|
+          data[name] = value
+        end
+
+        define_method(name + '?') do |value|
+          data[name]
+        end
+      end
+    end
+  end
+
+  def Current.undefine_attribute_method(name)
+    if respond_to?(name)
+      singleton_class.module_eval do
+        remove_method(name)
+        remove_method(name + '=')
+        remove_method(name + '?')
+      end
+    end
+  end
+
+  def Current.singleton_class
+    @singleton_class ||= class << self; self; end
   end
 
   def Current.attribute?(name)
-    attribute_names.include?(name.to_s)
+    calls.has_key?(name)
   end
 
   def Current.attribute_names
-    @attribute_names ||= []
+    calls.keys
   end
 
   def Current.attributes
-    attribute_names.inject({}){|hash, name| hash.update(name => send(name))}
-  end
-
-  def Current.clear
-    attribute_names.each do |name|
-      ivar = "@#{ name }"
-      remove_instance_variable(ivar) if instance_variable_defined?(ivar)
-    end
+    attribute_names.inject(Map.new){|map, name| map.update(name => send(name))}
   end
 
   def Current.method_missing(method, *args, &block)

data/rails_current.gemspec

@@ -3,7 +3,7 @@
 
 Gem::Specification::new do |spec|
   spec.name = "rails_current"
-  spec.version = "1.0.0"
+  spec.version = "1.1.0"
   spec.platform = Gem::Platform::RUBY
   spec.summary = "rails_current"
   spec.description = "description: rails_current kicks the ass"
@@ -13,7 +13,10 @@ Gem::Specification::new do |spec|
  "Rakefile",
  "lib",
  "lib/rails_current.rb",
- "rails_current.gemspec"]
+ "rails_current.gemspec",
+ "test",
+ "test/rails_current_test.rb",
+ "test/testing.rb"]
 
   spec.executables = []
   

data/test/rails_current_test.rb

@@ -0,0 +1,130 @@
+
+Testing Current do
+
+##
+#
+  test 'Current attributes can be declared by name' do
+    assert{ Current.attribute :foo }
+    assert{ Current.foo.nil? }
+  end
+
+##
+#
+  test 'Current attributes can be declared by name with a default' do
+    assert{ Current.attribute :foo, 42 }
+    assert{ Current.foo == 42 }
+
+    assert{ Current.attribute :bar, :default => 42.0 }
+    assert{ Current.bar == 42.0 }
+
+    assert{ Current.attribute(:foobar){ 'forty-two' } }
+    assert{ Current.foobar == 'forty-two' }
+  end
+
+##
+#
+  test 'Current attributes can be retrieved en mass' do
+    assert{ Current.attributes =~ {} }
+    assert{ Current.attribute :foo, 42 }
+    assert{ Current.attribute :bar, 42.0 }
+    assert{ Current.attributes =~ {:foo => 42, :bar => 42.0} }
+  end
+
+##
+#
+  test 'that Current attributes are thread safe' do
+    assert{ Current.attribute :foo }
+    assert{ Current.attribute :bar }
+
+    require 'thread'
+    ra = Queue.new
+    rb = Queue.new
+    wa = Queue.new
+    wb = Queue.new
+
+    a = Thread.new do
+      Thread.current.abort_on_exception = true
+      id = Thread.current.object_id
+      Current.foo = 40
+      Current.bar = 2
+      ra.push(id)
+      wa.pop()
+      ra.push( Current.attributes )
+    end
+
+    b = Thread.new do
+      Thread.current.abort_on_exception = true
+      id = Thread.current.object_id
+      Current.foo = 'forty'
+      Current.bar = 'two'
+      rb.push(id)
+      wb.pop()
+      rb.push( Current.attributes )
+    end
+
+    ra.pop
+    rb.pop
+
+    assert{ Current.attributes =~ {:foo => nil, :bar => nil} }
+
+    id = Thread.current.object_id
+     
+    wa.push(id)
+    wb.push(id)
+
+    assert{ ra.pop =~ {:foo => 40, :bar => 2 } }
+    assert{ rb.pop =~ {:foo => 'forty', :bar => 'two' } }
+
+    assert{ Current.attributes =~ {:foo => nil, :bar => nil} }
+  end
+
+##
+#
+  test 'that Current methods can be mixed into a class or object' do
+    assert{ Current.attribute :foo, 42 }
+    assert{ Current.attribute :bar, 42.0 }
+
+    c = assert do
+      Class.new do
+        include Current
+      end.new
+    end
+
+    assert{ c.current_foo == 42 }
+    assert{ c.current_bar == 42.0 }
+
+    o = assert do
+      Object.new.tap{|o| o.extend Current }
+    end
+
+    assert{ o.current_foo == 42 }
+    assert{ o.current_bar == 42.0 }
+
+    assert{ c.current_foo = 'forty-two' }
+    assert{ o.current_foo == 'forty-two' }
+
+    assert{ o.current_bar = 0b101010 }
+    assert{ c.current_bar == 0b101010 }
+
+    assert{ c.current_foo = :bar }
+    assert{ o.current_bar = :foo }
+
+    assert{ Current.attributes =~ {:foo => :bar, :bar => :foo} }
+  end
+
+##
+#
+  teardown do
+    assert{ Current.reset }
+  end
+
+end
+
+
+BEGIN {
+  this = File.expand_path(__FILE__)
+  root = File.dirname(File.dirname(this))
+
+  require(File.join(root, 'lib/rails_current.rb'))
+  require(File.join(root, 'test/testing.rb'))
+}

data/test/testing.rb

@@ -0,0 +1,197 @@
+# -*- encoding : utf-8 -*-
+#
+require 'test/unit'
+
+testdir = File.expand_path(File.dirname(__FILE__))
+rootdir = File.dirname(testdir)
+libdir = File.join(rootdir, 'lib')
+
+STDOUT.sync = true
+
+$:.unshift(testdir) unless $:.include?(testdir)
+$:.unshift(libdir) unless $:.include?(libdir)
+$:.unshift(rootdir) unless $:.include?(rootdir)
+
+class Testing
+  class Slug < ::String
+    def Slug.for(*args)
+      string = args.flatten.compact.join('-')
+      words = string.to_s.scan(%r/\w+/)
+      words.map!{|word| word.gsub %r/[^0-9a-zA-Z_-]/, ''}
+      words.delete_if{|word| word.nil? or word.strip.empty?}
+      new(words.join('-').downcase)
+    end
+  end
+  
+  class Context
+    attr_accessor :name
+
+    def initialize(name, *args)
+      @name = name
+    end
+
+    def to_s
+      Slug.for(name)
+    end
+  end
+end
+
+def Testing(*args, &block)
+  Class.new(::Test::Unit::TestCase) do
+
+  ## class methods
+  #
+    class << self
+      def contexts
+        @contexts ||= []
+      end
+
+      def context(*args, &block)
+        return contexts.last if(args.empty? and block.nil?)
+
+        context = Testing::Context.new(*args)
+        contexts.push(context)
+
+        begin
+          block.call(context)
+        ensure
+          contexts.pop
+        end
+      end
+
+      def slug_for(*args)
+        string = [context, args].flatten.compact.join('-')
+        words = string.to_s.scan(%r/\w+/)
+        words.map!{|word| word.gsub %r/[^0-9a-zA-Z_-]/, ''}
+        words.delete_if{|word| word.nil? or word.strip.empty?}
+        words.join('-').downcase.sub(/_$/, '')
+      end
+
+      def name() const_get(:Name) end
+
+      def testno()
+        '%05d' % (@testno ||= 0)
+      ensure
+        @testno += 1
+      end
+
+      def testing(*args, &block)
+        method = ["test", testno, slug_for(*args)].delete_if{|part| part.empty?}.join('_')
+        define_method(method, &block)
+      end
+
+      def test(*args, &block)
+        testing(*args, &block)
+      end
+
+      def setup(&block)
+        define_method(:setup, &block) if block
+      end
+
+      def teardown(&block)
+        define_method(:teardown, &block) if block
+      end
+
+      def prepare(&block)
+        @prepare ||= []
+        @prepare.push(block) if block
+        @prepare
+      end
+
+      def cleanup(&block)
+        @cleanup ||= []
+        @cleanup.push(block) if block
+        @cleanup
+      end
+    end
+
+  ## configure the subclass!
+  #
+    const_set(:Testno, '0')
+    slug = slug_for(*args).gsub(%r/-/,'_')
+    name = ['TESTING', '%03d' % const_get(:Testno), slug].delete_if{|part| part.empty?}.join('_')
+    name = name.upcase!
+    const_set(:Name, name)
+    const_set(:Missing, Object.new.freeze)
+
+  ## instance methods
+  #
+    alias_method('__assert__', 'assert')
+
+    def assert(*args, &block)
+      if args.size == 1 and args.first.is_a?(Hash)
+        options = args.first
+        expected = getopt(:expected, options){ missing }
+        actual = getopt(:actual, options){ missing }
+        if expected == missing and actual == missing
+          actual, expected, *ignored = options.to_a.flatten
+        end
+        expected = expected.call() if expected.respond_to?(:call)
+        actual = actual.call() if actual.respond_to?(:call)
+        assert_equal(expected, actual)
+      end
+
+      if block
+        label = "assert(#{ args.join(' ') })"
+        result = nil
+        assert_nothing_raised{ result = block.call }
+        __assert__(result, label)
+        result
+      else
+        result = args.shift
+        label = "assert(#{ args.join(' ') })"
+        __assert__(result, label)
+        result
+      end
+    end
+
+    def missing
+      self.class.const_get(:Missing)
+    end
+
+    def getopt(opt, hash, options = nil, &block)
+      [opt.to_s, opt.to_s.to_sym].each do |key|
+        return hash[key] if hash.has_key?(key)
+      end
+      default =
+        if block
+          block.call
+        else
+          options.is_a?(Hash) ? options[:default] : nil
+        end
+      return default
+    end
+
+    def subclass_of exception
+      class << exception
+        def ==(other) super or self > other end
+      end
+      exception
+    end
+
+  ##
+  #
+    module_eval(&block)
+
+    self.setup()
+    self.prepare.each{|b| b.call()}
+
+    at_exit{ 
+      self.teardown()
+      self.cleanup.each{|b| b.call()}
+    }
+
+    self
+  end
+end
+
+
+if $0 == __FILE__
+
+  Testing 'Testing' do
+    testing('foo'){ assert true }
+    test{ assert true }
+    p instance_methods.grep(/test/)
+  end
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rails_current
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-12-17 00:00:00.000000000 Z
+date: 2012-01-05 00:00:00.000000000 Z
 dependencies: []
 description: ! 'description: rails_current kicks the ass'
 email: ara.t.howard@gmail.com
@@ -21,6 +21,8 @@ files:
 - Rakefile
 - lib/rails_current.rb
 - rails_current.gemspec
+- test/rails_current_test.rb
+- test/testing.rb
 homepage: https://github.com/ahoward/rails_current
 licenses: []
 post_install_message: