 module WithStubbedConst
  def with_stubbed_const(consts, scope=self.class)
    stash = {}
    consts.each_pair do |key, val|
      stash[key] = scope.send(:remove_const, key)
      scope.send(:const_set, key, val)
    end

    begin
      yield
    ensure
      consts.each_pair do |key, val|
        scope.send(:remove_const, key)
        scope.send(:const_set, key, stash[key])
      end
    end
  end
 end
 require 'test/unit'
 require 'test_helper/with_stubbed_const'

 class TestWithStubbedConst < Test::Unit::TestCase
  include WithStubbedConst

  module Bar
    BAZ = 10
  end

  FOO = "foo"

  def test_default_scope
    assert_equal "foo", FOO
    with_stubbed_const(:FOO => "changed!") { assert_equal "changed!", FOO }
    assert_equal "foo", FOO
  end

  def test_specified_scope
    assert_equal 10, Bar::BAZ
    with_stubbed_const({:BAZ => 20}, Bar) { assert_equal 20, Bar::BAZ }
    assert_equal 10, Bar::BAZ
  end

  def test_block_raises
    assert_equal "foo", FOO
    with_stubbed_const(:FOO => 99) { assert_equal 99, FOO; raise "boom" } rescue nil
    assert_equal "foo", FOO
  end

 end
 gsettings set org.gnome.desktop.input-sources xkb-options "['ctrl:nocaps']"
 # Take a look at your current xkb-options
 gsettings get org.gnome.desktop.input-sources xkb-options

 # If you see @as [] then just run the command from above
 # Otherwise you need to preserve the existing options (such as foo:bar below)
 # while inserting the new one
 gsettings set org.gnome.desktop.input-sources xkb-options "['ctrl:nocaps', 'foo:bar']"
 [core]
  # -E means don't page if less one screen
  # -F means quit when EOF reached
  # -r fixes the %C(yellow)%+d colouring somehow
  pager = less -E -F -r

 [alias]
  ll  = log --pretty=nice -n 30 # about one screen worth
  lll = log --pretty=nice       # goes back forever

 [pretty]
  # %h  is short commit hash
  # %cr is time ago in words
  # %cn is committer name
  # %s  is the commit message title
  # %+d is a line break and a list of refs
  nice = format:%Cblue%h %Cred%cr %Cgreen%cn%Creset - %s%C(yellow)%+d
 <%= render :partial => 'thing_one', :locals => { :foo => '123' } %>

 <%= render 'thing_one', :foo => '123' %>
  #
  # A trick so you can have partials that take blocks.
  # Uses render :layout.
  #
  # Example:
  #   <%= block_render 'some_partial_with_a_yield', :foo => 123 do %>
  #     Any erb here...
  #   <% end %>
  #
  def block_render(partial_name, locals={})
    render :layout => partial_name, :locals => locals do
      yield
    end
  end
 <%= block_render 'block_thing', :foo => '123' do %>
  stuff inside here
 <% end %>
 <%#
  #
  # Locals:
  #   right (optional)
  #
  # Example usage:
  # <x= block_render 'shared/more_button_menu' x>
  #   <li><x= link_to 'Foo, '#' x></li>
  #   <li><x= link_to 'Bar, '#' x></li>
  # <x end x>
  #
 -%>
 <a class="btn dropdown-toggle" data-toggle="dropdown" href="#">More <span class="caret"></span></a>
 <ul class="dropdown-menu<%= " pull-right" if defined?(right) && right %>">
  <%= yield %>
 </ul>
 @namespace url(http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul);

 .tabbrowser-tab[pinned] {
  width: 72px;
 }
 #
 # This was causing problems when submitting the nested object form
 # in a/v/product/channels_edit because all the nested channels would
 # be created at plan Channel objects instead of the PrimaryChannel, EusChannel etc.
 #
 # In active record normally :type is ignored, eg:
 #   Channel.create(:type='PrimaryChannel', :etc=>1, ...)
 # ignores the type attr and uses 'Channel'.
 #
 # This hack will make it actually use the :type value.
 #
 # Usage:
 #
 #   class User < ActiveRecord::Base
 #     extend ActiveRecord::CreateWithSubtype
 #       ...
 #   end
 #
 #   class AdminUser < User
 #     ...
 #   end
 #
 # >> User.create(:type=>'AdminUser', :username=>'simon', ...) #=> #<AdminUser id:123 ...>
 #
 # Actually needed this for nested objects in forms using accepts_nested_attributes_for.
 #  http://railscasts.com/episodes/197-nested-model-form-part-2
 #
 # When updating the type is preserved, but when creating a new subobject with the nested form
 # the type is always the base class, which in my case was a problem.
 #
 # (I put this file in lib/active_record/create_with_subtype.rb)
 #
 module ActiveRecord
  module CreateWithSubtype
    def create(attributes=nil, &block)
      # Check if :type attribute exists. Remove it from attributes
      # (Note that attributes can be an array, hence Hash test)
      specified_type = attributes.delete(:type) if attributes.is_a?(Hash)
      if specified_type
        # Find the specified class
        use_sub_class = const_get(specified_type)
        # Sanity check
        raise "'#{use_sub_class}' not a subclass of '#{self}'" unless self.descendants.include?(use_sub_class)
        # Call create on the specified subclass
        use_sub_class.create(attributes, &block)
      else
        # Otherwise, just do the normal thing
        super(attributes, &block)
      end
    end
  end
 end
 #
 # If you want to use helper methods inside your controller's actions
 # (even though it is arguably a code smell, ie you should push your
 # presentation logic down into views rather than have it in your
 # controllers), you can include the helper modules you want, for
 # example:
 #
 #     class ThingController < ActionController::Base
 #       include ApplicationHelper
 #       include ThingHelper
 #       ...
 #     end
 #
 # But this will pollute your controller with all the methods from the
 # helpers which might be undesirable.
 #
 # There are various workarounds for this, such as:
 # * http://www.johnyerhot.com/2008/01/10/rails-using-helpers-in-you-controller/
 # * http://snippets.dzone.com/posts/show/1799
 # * http://masonoise.wordpress.com/2010/01/16/using-rails-tag-helpers-in-a-controller/
 #
 # You can also access any helper from a controller action using something like
 # this:
 #
 #     ActionController::Base.helpers.some_helper
 #     ThingController.helpers.some_helper
 #
 # or even this (?)
 #
 #     self.class.helpers.other_helper
 #
 # but that fairly inconvenient and awkward looking, so let's make it nicer.
 #
 # This defines the use_helper_method which can be used as follows:
 #
 #     class ThingController < ActionController::Base
 #       use_helper_method :some_helper, :other_helper
 #       ...
 #       def some_action
 #         ...
 #         @message = "Hello #{some_helper(@thing)}\n\nRegards #{other_helper(@user)}"
 #       end
 #     end
 #
 # It will create a private method in your controller that just calls
 # the helpers you specified. Now you can call some_helper and pluralize
 # directly from your action methods.
 #
 # (Not to be confused with ActionController::Base.helper_method and
 # ActionController::Base.helper which do very different things...)
 #
 # Note: This is kind of experimental. There might be a better way to
 # do it.
 #
 class ActionController::Base
  def self.use_helper_method(*syms)
    syms.each do |helper_method|
      class_eval <<-EOM
        private
        def #{helper_method}(*args)
          self.class.helpers.#{helper_method}(*args)
        end
      EOM
    end
  end
 end
 #
 # This is pretty confusing until you know what's going on...
 #
 # See http://techspry.com/ruby_and_rails/html_safe-and-helpers-in-rails-3-mystery-solved/
 # for an explanation...
 #
 ruby-1.8.7-p334 :025 > foo_safe = "<p>foo</p>".html_safe
 => "<p>foo</p>" 

 ruby-1.8.7-p334 :026 > (foo_safe + "<p>bar</p>").html_safe # not what you thought! unintuitive!
 => "<p>foo</p>&lt;p&gt;bar&lt;/p&gt;" 

 ruby-1.8.7-p334 :027 > "#{foo_safe}<p>bar</p>".html_safe # I think it works because of the implicit to_s
 => "<p>foo</p><p>bar</p>"

 ruby-1.8.7-p334 :028 > foo_safe.safe_concat("<p>bar</p>") # correct, but looks pretty clunky, right?
 => "<p>foo</p><p>bar</p>" 
 diff --git a/ext/bigdecimal/lib/bigdecimal/math.rb b/ext/bigdecimal/lib/bigdecimal/math.rb
 index c17841f..c672cbf 100644
 --- a/ext/bigdecimal/lib/bigdecimal/math.rb
 +++ b/ext/bigdecimal/lib/bigdecimal/math.rb
 @@ -9,6 +9,7 @@ require 'bigdecimal'
 #   atan(x, prec)  Note: |x|<1, x=0.9999 may not converge.
 #   exp (x, prec)
 #   log (x, prec)
 +#   TAU (prec)
 #   PI  (prec)
 #   E   (prec) == exp(1.0,prec)
 #
 @@ -222,6 +223,11 @@ module BigMath
     y
   end
 
 +  # See http://tauday.com/
 +  def TAU(prec)
 +    PI(prec)*BigDecimal("2")
 +  end
 +
   # Computes the value of pi to the specified number of digits of precision.
   def PI(prec)
     raise ArgumentError, "Zero or negative argument for PI" if prec <= 0
 diff --git a/math.c b/math.c
 index e3a78f7..e8b2525 100644
 --- a/math.c
 +++ b/math.c
 @@ -775,8 +775,10 @@ Init_Math(void)
 
 #ifdef M_PI
     rb_define_const(rb_mMath, "PI", DBL2NUM(M_PI));
 +    rb_define_const(rb_mMath, "TAU", DBL2NUM(M_PI*2.0));
 #else
     rb_define_const(rb_mMath, "PI", DBL2NUM(atan(1.0)*4.0));
 +    rb_define_const(rb_mMath, "TAU", DBL2NUM(atan(1.0)*8.0));
 #endif
 
 #ifdef M_E
 $ git status -s
 M ext/bigdecimal/lib/bigdecimal/math.rb
 M math.c
 $ /usr/local/bin/ruby --version # (after doing make && sudo make install)
 ruby 1.9.3dev (2011-06-16 trunk 32123) [x86_64-darwin10.7.0]
 $ /usr/local/bin/ruby -r bigdecimal/math -e 'puts Math::TAU, BigMath.TAU(100)'
 6.283185307179586
 0.62831853071795864769252867665590057683943387987502116419498891846156328125724179972560696506842341359642961730265646057277261767213856E1
 # See http://tauday.com/

 module Math
  TAU = PI * 2.0
 end

 if defined? BigMath
  module BigMath
    module_function
    def TAU(prec)
      PI(prec) * BigDecimal("2")
    end
  end
 end
 $ ruby -I. -r bigdecimal/math -r tau -e 'puts Math::TAU, BigMath.TAU(100)' 
 6.283185307179586
 0.62831853071795864769252867665590057683943387987502116419498891846156328125724179972560696506842341359642961730265646057277261767213856E1
	module WithStubbedConst
	def with_stubbed_const(consts, scope=self.class)
	stash = {}
	consts.each_pair do \|key, val\|
	stash[key] = scope.send(:remove_const, key)
	scope.send(:const_set, key, val)
	end

	begin
	yield
	ensure
	consts.each_pair do \|key, val\|
	scope.send(:remove_const, key)
	scope.send(:const_set, key, stash[key])
	end
	end
	end
	end
	require 'test/unit'
	require 'test_helper/with_stubbed_const'

	class TestWithStubbedConst < Test::Unit::TestCase
	include WithStubbedConst

	module Bar
	BAZ = 10
	end

	FOO = "foo"

	def test_default_scope
	assert_equal "foo", FOO
	with_stubbed_const(:FOO => "changed!") { assert_equal "changed!", FOO }
	assert_equal "foo", FOO
	end

	def test_specified_scope
	assert_equal 10, Bar::BAZ
	with_stubbed_const({:BAZ => 20}, Bar) { assert_equal 20, Bar::BAZ }
	assert_equal 10, Bar::BAZ
	end

	def test_block_raises
	assert_equal "foo", FOO
	with_stubbed_const(:FOO => 99) { assert_equal 99, FOO; raise "boom" } rescue nil
	assert_equal "foo", FOO
	end

	end
	# Take a look at your current xkb-options
	gsettings get org.gnome.desktop.input-sources xkb-options

	# If you see @as [] then just run the command from above
	# Otherwise you need to preserve the existing options (such as foo:bar below)
	# while inserting the new one
	gsettings set org.gnome.desktop.input-sources xkb-options "['ctrl:nocaps', 'foo:bar']"
	[core]
	# -E means don't page if less one screen
	# -F means quit when EOF reached
	# -r fixes the %C(yellow)%+d colouring somehow
	pager = less -E -F -r

	[alias]
	ll = log --pretty=nice -n 30 # about one screen worth
	lll = log --pretty=nice # goes back forever

	[pretty]
	# %h is short commit hash
	# %cr is time ago in words
	# %cn is committer name
	# %s is the commit message title
	# %+d is a line break and a list of refs
	nice = format:%Cblue%h %Cred%cr %Cgreen%cn%Creset - %s%C(yellow)%+d
	<%= render :partial => 'thing_one', :locals => { :foo => '123' } %>

	<%= render 'thing_one', :foo => '123' %>
	#
	# A trick so you can have partials that take blocks.
	# Uses render :layout.
	#
	# Example:
	# <%= block_render 'some_partial_with_a_yield', :foo => 123 do %>
	# Any erb here...
	# <% end %>
	#
	def block_render(partial_name, locals={})
	render :layout => partial_name, :locals => locals do
	yield
	end
	end
	<%= block_render 'block_thing', :foo => '123' do %>
	stuff inside here
	<% end %>
	<%#
	#
	# Locals:
	# right (optional)
	#
	# Example usage:
	# <x= block_render 'shared/more_button_menu' x>
	# <li><x= link_to 'Foo, '#' x></li>
	# <li><x= link_to 'Bar, '#' x></li>
	# <x end x>
	#
	-%>
	<a class="btn dropdown-toggle" data-toggle="dropdown" href="#">More <span class="caret"></span></a>
	<ul class="dropdown-menu<%= " pull-right" if defined?(right) && right %>">
	<%= yield %>
	</ul>
	@namespace url(http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul);

	.tabbrowser-tab[pinned] {
	width: 72px;
	}
	#
	# This was causing problems when submitting the nested object form
	# in a/v/product/channels_edit because all the nested channels would
	# be created at plan Channel objects instead of the PrimaryChannel, EusChannel etc.
	#
	# In active record normally :type is ignored, eg:
	# Channel.create(:type='PrimaryChannel', :etc=>1, ...)
	# ignores the type attr and uses 'Channel'.
	#
	# This hack will make it actually use the :type value.
	#
	# Usage:
	#
	# class User < ActiveRecord::Base
	# extend ActiveRecord::CreateWithSubtype
	# ...
	# end
	#
	# class AdminUser < User
	# ...
	# end
	#
	# >> User.create(:type=>'AdminUser', :username=>'simon', ...) #=> #<AdminUser id:123 ...>
	#
	# Actually needed this for nested objects in forms using accepts_nested_attributes_for.
	# http://railscasts.com/episodes/197-nested-model-form-part-2
	#
	# When updating the type is preserved, but when creating a new subobject with the nested form
	# the type is always the base class, which in my case was a problem.
	#
	# (I put this file in lib/active_record/create_with_subtype.rb)
	#
	module ActiveRecord
	module CreateWithSubtype
	def create(attributes=nil, &block)
	# Check if :type attribute exists. Remove it from attributes
	# (Note that attributes can be an array, hence Hash test)
	specified_type = attributes.delete(:type) if attributes.is_a?(Hash)
	if specified_type
	# Find the specified class
	use_sub_class = const_get(specified_type)
	# Sanity check
	raise "'#{use_sub_class}' not a subclass of '#{self}'" unless self.descendants.include?(use_sub_class)
	# Call create on the specified subclass
	use_sub_class.create(attributes, &block)
	else
	# Otherwise, just do the normal thing
	super(attributes, &block)
	end
	end
	end
	end