rails_current 1.8.0 → 2.2.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    ZmEzNGM0MmJiYWQxZjFiOWIzMmZlMDEzMjc4NjE5ZWJjZWRiNWQ1ZA==
-  data.tar.gz: !binary |-
-    MjQ5YmUxNDk4YjlmZWRkNjQ0NmNmODFlMDQ4YWM0MzY2YzRhOTcxNw==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    OGE4MWM3MjAzM2ExMTQ4ZjEwYjczYjU3ZjkyZWNmYWYzZWI2ODYyOTUzNjcy
-    MjBlNTk3MThhY2Y4N2E2N2E1NmY0ZDcyNzg5MGE5ZWUyOTE4MDZiNDRmMmIw
-    NjU1NWRiN2U1MGU1YjAyZTg3OTkxZGUwYjlmODdiN2U5NDY4M2Y=
-  data.tar.gz: !binary |-
-    YjZkYzA5ZWI3MzljZGRmYTgxMGEzM2I2OTNkMzBhNmJmZDlmZWMyMDY2MGU0
-    MzM4OWI2ZmMyODljNTRjNjE4Mjk4OWRlOTljMWFlNjJhOGNmMTk3NDc5ZTYz
-    ZGM1MmJmNzgxNTFhYjI4ZDk3NzFjNTAyZGVlYmVkZWEwZDEyNjQ=
+SHA256:
+  metadata.gz: dd096f5c6ef3f51bb7c82d1f66ba813955d641d3781dcffaab6c1ad8dbb7d5b5
+  data.tar.gz: 2d61359d45c4496c30ce0ec87c7f5a5fda1e170003af08e26853b5cb1ff10de5
+SHA512:
+  metadata.gz: 1d7211d22661a811d1cfffa16b39333a8ceee0d235372c927804cb8c2a6137fc2b4ebc9a8a1fc80f501ee836bce58f5ccef3a96a3fbeb90ad7ec30acbc96e8bf
+  data.tar.gz: 3707b6e19d80cbca2b9b701cfc01cde7ba1e8d9524229f40a9388f3c39116e9d69dcd4b5c9d2227d1fd4a68eece6677999287f3f6b911f7524b61c99301365fe

data/README.md

@@ -1,38 +1,29 @@
---------------------------------
-NAME
---------------------------------
-  rails_current
+# rails_current
 
---------------------------------
-DESCRIPTION
---------------------------------
+## DESCRIPTION
 
-  track 'current_user' et all in a tidy, global, and thread-safe fashion.
+track `current_user` et all in a tidy, global, and thread-safe fashion.
 
 
---------------------------------
-SYNOPSIS
---------------------------------
+## SYNOPSIS
 
-  most rails apps scatter a bunch of @current_foobar vars everywhere.  don't do
-  that.  it's fugly.  instead, do this.
+most rails apps scatter a bunch of `@current_foobar` vars everywhere. don't do that. it's fugly. instead, do this.
 
-  declare the current_XXX variables you'll want tracked.  you can pass a block
-  for lazy computation
+declare the `current_XXX` variables you'll want tracked. you can pass a block for lazy computation
 
-    class ApplicationController
+```
+class ApplicationController
 
-      Current(:user){ User.find session[:current_user }
-      Current(:account)
+  Current(:user){ User.find session[:current_user }
+  Current(:account)
 
-    end
-
-  you can now access the current state two ways
-  
+end
+```
 
-  1) globally from anywhere in your code base
-  
+you can now access the current state two ways
 
+* globally from anywhere in your code base
+    ```
     if Current.user
 
       ...
@@ -40,29 +31,30 @@ SYNOPSIS
     end
 
     Current.user = User.find(id)
+    ```
+* using the `current_` methods that are added by including the Current module
+  into any class (ActionController::Base and ActionView::Base automatically
+  include it)
+  ```
+  if current_user
 
-  2) or using the current_ methods that are added by including the Current
-  module into any class (ActionController::Base and ActionView::Base
-  automatically include it)
-  
+    ...
 
-    if current_user
+  end
 
-      ...
-
-    end
+  self.current_user = User.find(id)
+  ```
 
-    self.current_user = User.find(id)
+the `Current` module is cleared out before every request and is thread safe.
 
+## INSTALL
 
-  the Current module is cleared out before every request and is thread safe.
+```
+gem install rails_current
 
---------------------------------
-INSTALL
---------------------------------
 
-   gem install rails-current
+gem 'rails-current', :require => 'current'
 
+bundle install
+```
 
-   gem 'rails-current', :require => 'current'
-   bundle install

data/Rakefile

@@ -1,8 +1,11 @@
-This.rubyforge_project = 'codeforpeople'
+#This.rubyforge_project = 'codeforpeople'
 This.author = "Ara T. Howard"
 This.email = "ara.t.howard@gmail.com"
 This.homepage = "https://github.com/ahoward/#{ This.lib }"
 
+task :license do
+  open('LICENSE', 'w'){|fd| fd.puts "Ruby"}
+end
 
 task :default do
   puts((Rake::Task.tasks.map{|task| task.name.gsub(/::/,':')} - ['default']).sort)
@@ -29,7 +32,7 @@ def run_tests!(which = nil)
 
   test_rbs.each_with_index do |test_rb, index|
     testno = index + 1
-    command = "#{ File.basename(This.ruby) } -I ./lib -I ./test/lib #{ test_rb }"
+    command = "#{ This.ruby } -w -I ./lib -I ./test/lib #{ test_rb }"
 
     puts
     say(div, :color => :cyan, :bold => true)
@@ -60,7 +63,7 @@ end
 task :gemspec do
   ignore_extensions = ['git', 'svn', 'tmp', /sw./, 'bak', 'gem']
   ignore_directories = ['pkg']
-  ignore_files = ['test/log', 'a.rb'] + Dir['db/*'] + %w'db'
+  ignore_files = ['test/log']
 
   shiteless = 
     lambda do |list|
@@ -87,9 +90,10 @@ task :gemspec do
   files       = shiteless[Dir::glob("**/**")]
   executables = shiteless[Dir::glob("bin/*")].map{|exe| File.basename(exe)}
   #has_rdoc    = true #File.exist?('doc')
-  test_files  = test(?e, "test/#{ lib }.rb") ? "test/#{ lib }.rb" : nil
+  test_files  = "test/#{ lib }.rb" if File.file?("test/#{ lib }.rb")
   summary     = object.respond_to?(:summary) ? object.summary : "summary: #{ lib } kicks the ass"
   description = object.respond_to?(:description) ? object.description : "description: #{ lib } kicks the ass"
+  license     = object.respond_to?(:license) ? object.license : "Ruby"
 
   if This.extensions.nil?
     This.extensions = []
@@ -100,7 +104,6 @@ task :gemspec do
   end
   extensions = [extensions].flatten.compact
 
-# TODO
   if This.dependencies.nil?
     dependencies = []
   else
@@ -127,6 +130,7 @@ task :gemspec do
             spec.platform = Gem::Platform::RUBY
             spec.summary = <%= lib.inspect %>
             spec.description = <%= description.inspect %>
+            spec.license = <%= license.inspect %>
 
             spec.files =\n<%= files.sort.pretty_inspect %>
             spec.executables = <%= executables.inspect %>
@@ -141,7 +145,6 @@ task :gemspec do
 
             spec.extensions.push(*<%= extensions.inspect %>)
 
-            spec.rubyforge_project = <%= This.rubyforge_project.inspect %>
             spec.author = <%= This.author.inspect %>
             spec.email = <%= This.email.inspect %>
             spec.homepage = <%= This.homepage.inspect %>
@@ -188,8 +191,8 @@ task :readme do
   end
 
   template = 
-    if test(?e, 'readme.erb')
-      Template{ IO.read('readme.erb') }
+    if test(?e, 'README.erb')
+      Template{ IO.read('README.erb') }
     else
       Template {
         <<-__

data/lib/rails_current.rb

@@ -1,16 +1,22 @@
 # -*- encoding : utf-8 -*-
 
 module Current
+  VERSION = '2.2.0'
+
   def Current.version
-    '1.8.0'
+    VERSION
   end
 
   def Current.dependencies
     {
-      'map'           => [ 'map'           , ' >= 6.0.1' ]
+      'map' => [ 'map', ' ~> 6.0' ]
     }
   end
 
+  def Current.description
+    "track 'current_user' et all in a tidy, global, and thread-safe fashion for your rails apps"
+  end
+
   begin
     require 'rubygems'
   rescue LoadError
@@ -149,48 +155,60 @@ module Current
     case method.to_s
       when /^current_(.*)$/
         msg = $1
-        value = Current.send(msg, *args, &block)
-
+        Current.send(msg, *args, &block)
       else
         super
     end
   end
 
   def Current.mock_controller(options = {})
-    require 'rails'
-    require 'action_controller'
-    require 'action_dispatch/testing/test_request.rb' 
-    require 'action_dispatch/testing/test_response.rb' 
+    ensure_rails_application do
+      require 'action_controller'
+      require 'action_dispatch/testing/test_request.rb'
+      require 'action_dispatch/testing/test_response.rb'
 
-    default_url_options =
-      begin
-        require 'rails_default_url_options'
-        DefaultUrlOptions
-      rescue LoadError
-        options[:default_url_options] || {}
+      store = ActiveSupport::Cache::MemoryStore.new
+
+      controller = mock_controller_class.new
+      controller.perform_caching = true
+      controller.cache_store = store
+
+      request = ActionDispatch::TestRequest.create
+      response = ActionDispatch::TestResponse.create
+
+      controller.request = request
+      controller.response = response
+
+      singleton_class =
+        class << controller
+          self
+        end
+
+      singleton_class.module_eval do
+        define_method(:default_url_options) do
+          @default_url_options ||= (
+            defined?(DefaultUrlOptions) ? DefaultUrlOptions.dup : {}
+          )
+        end
       end
 
-    ensure_rails_application do
-      store = ActiveSupport::Cache::MemoryStore.new 
-      controller =  
-        begin 
-          ApplicationController.new 
-        rescue NameError 
-          ActionController::Base.new 
-        end 
-      controller.perform_caching = true 
-      controller.cache_store = store 
-      request = ActionDispatch::TestRequest.new 
-      response = ActionDispatch::TestResponse.new 
-      controller.request = request 
-      controller.response = response 
-      #controller.send(:initialize_template_class, response) 
-      #controller.send(:assign_shortcuts, request, response) 
-      controller.send(:default_url_options).merge!(default_url_options)
       Current.proxy_for(controller)
     end
   end 
 
+  def Current.mock_controller_class
+    unless const_defined?(:Controller)
+      controller_class =
+        if defined?(::ApplicationController)
+          Class.new(::ApplicationController)
+        else
+          Class.new(::ActionController::Base)
+        end
+      const_set(:Controller, controller_class)
+    end
+    return const_get(:Controller)
+  end
+
   def Current.ensure_rails_application(&block)
     require 'rails' unless defined?(Rails)
     if Rails.application.nil?
@@ -228,10 +246,6 @@ module Current
   end
 end
 
-def Current(*args, &block)
-  Current.attribute(*args, &block)
-end
-
 if defined?(Rails)
 
 ##
@@ -245,10 +259,10 @@ if defined?(Rails)
 ##
 #
   module Current
-    def Current.install_before_filter!
+    def Current.install_before_action!
       if defined?(::ActionController::Base)
         ::ActionController::Base.module_eval do
-          prepend_before_filter do |controller|
+          prepend_before_action do |controller|
             Current.clear
             Current.controller = Current.proxy_for(controller)
             Current.action = controller ? controller.send(:action_name) : nil
@@ -268,12 +282,12 @@ if defined?(Rails)
     class Engine < Rails::Engine
       config.before_initialize do
         ActiveSupport.on_load(:action_controller) do
-          Current.install_before_filter!
+          Current.install_before_action!
         end
       end
     end
   else
-    Current.install_before_filter!
+    Current.install_before_action!
   end
 
 end

data/rails_current.gemspec

@@ -0,0 +1,40 @@
+## rails_current.gemspec
+#
+
+Gem::Specification::new do |spec|
+  spec.name = "rails_current"
+  spec.version = "2.2.0"
+  spec.platform = Gem::Platform::RUBY
+  spec.summary = "rails_current"
+  spec.description = "track 'current_user' et all in a tidy, global, and thread-safe fashion for your rails apps"
+  spec.license = "Ruby"
+
+  spec.files =
+["README.md",
+ "Rakefile",
+ "lib",
+ "lib/rails_current.rb",
+ "rails_current.gemspec",
+ "tasks",
+ "tasks/default.rake",
+ "tasks/this.rb",
+ "test",
+ "test/rails_current_test.rb",
+ "test/testing.rb"]
+
+  spec.executables = []
+  
+  spec.require_path = "lib"
+
+  spec.test_files = nil
+
+  
+    spec.add_dependency(*["map", " ~> 6.0"])
+  
+
+  spec.extensions.push(*[])
+
+  spec.author = "Ara T. Howard"
+  spec.email = "ara.t.howard@gmail.com"
+  spec.homepage = "https://github.com/ahoward/rails_current"
+end

data/tasks/default.rake

@@ -0,0 +1,227 @@
+# vim: syntax=ruby
+require 'rake/clean'
+require 'digest'
+#------------------------------------------------------------------------------
+# If you want to Develop on this project just run 'rake develop' and you'll
+# have all you need to get going. If you want to use bundler for development,
+# then run 'rake develop:using_bundler'
+#------------------------------------------------------------------------------
+namespace :develop do
+
+  # Install all the development and runtime dependencies of this gem using the
+  # gemspec.
+  task :default => 'Gemfile' do
+    require 'rubygems/dependency_installer'
+    installer = ::Gem::DependencyInstaller.new
+    puts "Installing bundler..."
+    installer.install 'bundler'
+    sh 'bundle install'
+    puts "\n\nNow run 'rake test'"
+  end
+
+  # Create a Gemfile that just references the gemspec
+  file 'Gemfile' => :gemspec do
+    File.open( "Gemfile", "w+" ) do |f|
+      f.puts "# DO NOT EDIT - This file is automatically generated"
+      f.puts "# Make changes to Manifest.txt and/or Rakefile and regenerate"
+      f.puts 'source "https://rubygems.org/"'
+      f.puts 'gemspec'
+    end
+  end
+end
+desc "Boostrap development"
+task :develop => "develop:default"
+
+#------------------------------------------------------------------------------
+# Minitest - standard TestTask
+#------------------------------------------------------------------------------
+begin
+  require 'rake/testtask'
+  Rake::TestTask.new( :test ) do |t|
+    t.ruby_opts    = %w[ -rubygems ]
+    t.libs         = %w[ lib spec test ]
+    t.pattern      = "{test,spec}/**/{test_*,*_spec,*_test}.rb"
+  end
+
+  task :test_requirements
+  task :test => :test_requirements
+  task :default => :test
+rescue LoadError
+  This.task_warning( 'test' )
+end
+
+#------------------------------------------------------------------------------
+# RDoc - standard rdoc rake task, although we must make sure to use a more
+#        recent version of rdoc since it is the one that has 'tomdoc' markup
+#------------------------------------------------------------------------------
+begin
+  gem 'rdoc' # otherwise we get the wrong task from stdlib
+  require 'rdoc/task'
+  RDoc::Task.new do |t|
+    t.markup   = 'tomdoc'
+    t.rdoc_dir = 'doc'
+    t.main     = 'README.md'
+    t.title    = "#{This.name} #{This.version}"
+    t.rdoc_files.include( FileList['*.{rdoc,md,txt}'], FileList['ext/**/*.c'],
+                          FileList['lib/**/*.rb'] )
+  end
+rescue StandardError, LoadError
+  This.task_warning( 'rdoc' )
+end
+
+#------------------------------------------------------------------------------
+# Manifest - We want an explicit list of thos files that are to be packaged in
+#            the gem. Most of this is from Hoe.
+#------------------------------------------------------------------------------
+namespace 'manifest' do
+  desc "Check the manifest"
+  task :check => :clean do
+    files = FileList["**/*", ".*"].exclude( This.exclude_from_manifest ).to_a.sort
+    files = files.select{ |f| File.file?( f ) }
+
+    tmp = "Manifest.tmp"
+    File.open( tmp, 'w' ) do |f|
+      f.puts files.join("\n")
+    end
+
+    begin
+      sh "diff -du Manifest.txt #{tmp}"
+    ensure
+      rm tmp
+    end
+    puts "Manifest looks good"
+  end
+
+  desc "Generate the manifest"
+  task :generate => :clean do
+    files = %x[ git ls-files ].split("\n").sort
+    files.reject! { |f| f =~ This.exclude_from_manifest }
+    File.open( "Manifest.txt", "w" ) do |f|
+      f.puts files.join("\n")
+    end
+  end
+end
+
+#------------------------------------------------------------------------------
+# Fixme - look for fixmes and report them
+#------------------------------------------------------------------------------
+namespace :fixme do
+  task :default => 'manifest:check' do
+    This.manifest.each do |file|
+      next if file == __FILE__
+      next unless file =~ %r/(txt|rb|md|rdoc|css|html|xml|css)\Z/
+      puts "FIXME: Rename #{file}" if file =~ /fixme/i
+      IO.readlines( file ).each_with_index do |line, idx|
+        prefix = "FIXME: #{file}:#{idx+1}".ljust(42)
+        puts "#{prefix} => #{line.strip}" if line =~ /fixme/i
+      end
+    end
+  end
+
+  def fixme_project_root
+    This.project_path( '../fixme' )
+  end
+
+  def fixme_project_path( subtree )
+    fixme_project_root.join( subtree )
+  end
+
+  def local_fixme_files
+    This.manifest.select { |p| p =~ %r|^tasks/| }
+  end
+
+  def outdated_fixme_files
+    local_fixme_files.select do |local|
+      upstream     = fixme_project_path( local )
+      upstream.exist? &&
+        ( Digest::SHA256.file( local ) != Digest::SHA256.file( upstream ) )
+    end
+  end
+
+  def fixme_up_to_date?
+    outdated_fixme_files.empty?
+  end
+
+  desc "See if the fixme tools are outdated"
+  task :outdated => :release_check do
+    if fixme_up_to_date? then
+      puts "Fixme files are up to date."
+    else
+      outdated_fixme_files.each do |f|
+        puts "#{f} is outdated"
+      end
+    end
+  end
+
+  desc "Update outdated fixme files"
+  task :update => :release_check do
+    if fixme_up_to_date? then
+      puts "Fixme files are already up to date."
+    else
+      puts "Updating fixme files:"
+      outdated_fixme_files.each do |local|
+        upstream = fixme_project_path( local )
+        puts "  * #{local}"
+        FileUtils.cp( upstream, local )
+      end
+      puts "Use your git commands as appropriate."
+    end
+  end
+end
+desc "Look for fixmes and report them"
+task :fixme => "fixme:default"
+
+#------------------------------------------------------------------------------
+# Gem Specification
+#------------------------------------------------------------------------------
+# Really this is only here to support those who use bundler
+desc "Build the #{This.name}.gemspec file"
+task :gemspec do
+  File.open( This.gemspec_file, "wb+" ) do |f|
+    f.puts "# DO NOT EDIT - This file is automatically generated"
+    f.puts "# Make changes to Manifest.txt and/or Rakefile and regenerate"
+    f.write This.platform_gemspec.to_ruby
+  end
+end
+
+# .rbc files from ruby 2.0
+CLOBBER << FileList["**/*.rbc"]
+
+# The standard gem packaging task, everyone has it.
+require 'rubygems/package_task'
+::Gem::PackageTask.new( This.platform_gemspec ) do
+  # nothing
+end
+
+#------------------------------------------------------------------------------
+# Release - the steps we go through to do a final release, this is pulled from
+#           a compbination of mojombo's rakegem, hoe and hoe-git
+#
+# 1) make sure we are on the master branch
+# 2) make sure there are no uncommitted items
+# 3) check the manifest and make sure all looks good
+# 4) build the gem
+# 5) do an empty commit to have the commit message of the version
+# 6) tag that commit as the version
+# 7) push master
+# 8) push the tag
+# 7) pus the gem
+#------------------------------------------------------------------------------
+task :release_check do
+  unless `git branch` =~ /^\* master$/
+    abort "You must be on the master branch to release!"
+  end
+  unless `git status` =~ /^nothing to commit/m
+    abort "Nope, sorry, you have unfinished business"
+  end
+end
+
+desc "Create tag v#{This.version}, build and push #{This.platform_gemspec.full_name} to rubygems.org"
+task :release => [ :release_check, 'manifest:check', :gem ] do
+  sh "git commit --allow-empty -a -m 'Release #{This.version}'"
+  sh "git tag -a -m 'v#{This.version}' v#{This.version}"
+  sh "git push origin master"
+  sh "git push origin v#{This.version}"
+  sh "gem push pkg/#{This.platform_gemspec.full_name}.gem"
+end
+

data/tasks/this.rb

@@ -0,0 +1,207 @@
+require 'pathname'
+
+# Public: A Class containing all the metadata and utilities needed to manage a
+# ruby project.
+class ThisProject
+  # The name of this project
+  attr_accessor :name
+
+  # The author's name
+  attr_accessor :author
+
+  # The email address of the author(s)
+  attr_accessor :email
+
+  # The homepage of this project
+  attr_accessor :homepage
+
+  # The regex of files to exclude from the manifest
+  attr_accessor :exclude_from_manifest
+
+  # The hash of Gem::Specifications keyed' by platform
+  attr_accessor :gemspecs
+
+  # Public: Initialize ThisProject
+  #
+  # Yields self
+  def initialize(&block)
+    @exclude_from_manifest = Regexp.union(/\.(git|DS_Store)/,
+                                          /^(doc|coverage|pkg|tmp|Gemfile(\.lock)?)/,
+                                          /^[^\/]+\.gemspec/,
+                                          /\.(swp|jar|bundle|so|rvmrc|travis.yml)$/,
+                                          /~$/)
+    @gemspecs              = Hash.new
+    yield self if block_given?
+  end
+
+  # Public: return the version of ThisProject
+  #
+  # Search the ruby files in the project looking for the one that has the
+  # version string in it. This does not eval any code in the project, it parses
+  # the source code looking for the string.
+  #
+  # Returns a String version
+  def version
+    [ "lib/#{ name }.rb", "lib/#{ name }/version.rb" ].each do |v|
+      path = project_path( v )
+      next unless path.exist?
+      line = path.read[/^\s*VERSION\s*=\s*.*/]
+      if line then
+        return line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+      end
+    end
+  end
+
+  # Internal: Return a section of an RDoc file with the given section name
+  #
+  # path         - the relative path in the project of the file to parse
+  # section_name - the section out of the file from which to parse data
+  #
+  # Retuns the text of the section as an array of paragrphs.
+  def section_of( file, section_name )
+    re    = /^[=#]+ (.*)$/
+    sectional = project_path( file )
+    parts = sectional.read.split( re )[1..-1]
+    parts.map! { |p| p.strip }
+
+    sections = Hash.new
+    Hash[*parts].each do |k,v|
+      sections[k] = v.split("\n\n")
+    end
+    return sections[section_name]
+  end
+
+  # Internal: print out a warning about the give task
+  def task_warning( task )
+    warn "WARNING: '#{task}' tasks are not defined. Please run 'rake develop'"
+  end
+
+  # Internal: Return the full path to the file that is relative to the project
+  # root.
+  #
+  # path - the relative path of the file from the project root
+  #
+  # Returns the Pathname of the file
+  def project_path( *relative_path )
+    project_root.join( *relative_path )
+  end
+
+  # Internal: The absolute path of this file
+  #
+  # Returns the Pathname of this file.
+  def this_file_path
+    Pathname.new( __FILE__ ).expand_path
+  end
+
+  # Internal: The root directory of this project
+  #
+  # This is defined as being the directory that is in the path of this project
+  # that has the first Rakefile
+  #
+  # Returns the Pathname of the directory
+  def project_root
+    this_file_path.ascend do |p|
+      rakefile = p.join( 'Rakefile' )
+      return p if rakefile.exist?
+    end
+  end
+
+  # Internal: Returns the contents of the Manifest.txt file as an array
+  #
+  # Returns an Array of strings
+  def manifest
+    manifest_file = project_path( "Manifest.txt" )
+    abort "You need a Manifest.txt" unless manifest_file.readable?
+    manifest_file.readlines.map { |l| l.strip }
+  end
+
+  # Internal: Return the files that define the extensions
+  #
+  # Returns an Array
+  def extension_conf_files
+    manifest.grep( /extconf.rb\Z/ )
+  end
+
+  # Internal: Returns the gemspace associated with the current ruby platform
+  def platform_gemspec
+    gemspecs.fetch(platform) { This.ruby_gemspec }
+  end
+
+  def core_gemspec
+    Gem::Specification.new do |spec|
+      spec.name        = name
+      spec.version     = version
+      spec.author      = author
+      spec.email       = email
+      spec.homepage    = homepage
+
+      spec.summary     = summary 
+      spec.description = description == summary ? "#{ description} " : description
+      spec.license     = license
+
+      spec.files       = manifest
+      spec.executables = spec.files.grep(/^bin/) { |f| File.basename(f) }
+      spec.test_files  = spec.files.grep(/^spec/)
+
+      spec.extra_rdoc_files += spec.files.grep(/(txt|rdoc|md)$/)
+      spec.rdoc_options = [ "--main"  , 'README.md',
+                            "--markup", "tomdoc" ]
+
+      spec.required_ruby_version = '>= 2.2.0'
+    end
+  end
+
+  # Internal: Return the gemspec for the ruby platform
+  def ruby_gemspec( core = core_gemspec, &block )
+    yielding_gemspec( 'ruby', core, &block )
+  end
+
+  # Internal: Return the gemspec for the jruby platform
+  def java_gemspec( core = core_gemspec, &block )
+    yielding_gemspec( 'java', core, &block )
+  end
+
+  # Internal: give an initial spec and a key, create a new gemspec based off of
+  # it.
+  #
+  # This will force the new gemspecs 'platform' to be that of the key, since the
+  # only reason you would have multiple gemspecs at this point is to deal with
+  # different platforms.
+  def yielding_gemspec( key, core )
+    spec = gemspecs[key] ||= core.dup
+    spec.platform = key
+    yield spec if block_given?
+    return spec
+  end
+
+  # Internal: Return the platform of ThisProject at the current moment in time.
+  def platform
+    (RUBY_PLATFORM == "java") ? 'java' : Gem::Platform::RUBY
+  end
+
+  # Internal: Return the DESCRIPTION section of the README.rdoc file
+  def description_section
+    section_of( 'README.md', 'DESCRIPTION')
+  end
+
+  # Internal: Return the summary text from the README
+  def summary
+    description_section.first
+  end
+
+  # Internal: Return the full description text from the README
+  def description
+    description_section.join(" ").tr("\n", ' ').gsub(/[{}]/,'').gsub(/\[[^\]]+\]/,'') # strip rdoc
+  end
+
+  def license
+    "ISC"
+  end
+
+  # Internal: The path to the gemspec file
+  def gemspec_file
+    project_path( "#{ name }.gemspec" )
+  end
+end
+
+This = ThisProject.new

data/test/rails_current_test.rb

@@ -1,5 +1,4 @@
-
-Testing Current do
+Testing.test Current do
 
 ##
 #
@@ -42,7 +41,7 @@ Testing Current do
     wa = Queue.new
     wb = Queue.new
 
-    a = Thread.new do
+    Thread.new do
       Thread.current.abort_on_exception = true
       id = Thread.current.object_id
       Current.foo = 40
@@ -52,7 +51,7 @@ Testing Current do
       ra.push( Current.attributes )
     end
 
-    b = Thread.new do
+    Thread.new do
       Thread.current.abort_on_exception = true
       id = Thread.current.object_id
       Current.foo = 'forty'
@@ -94,7 +93,7 @@ Testing Current do
     assert{ c.current_bar == 42.0 }
 
     o = assert do
-      Object.new.tap{|o| o.extend Current }
+      Object.new.tap{|o1| o1.extend Current }
     end
 
     assert{ o.current_foo == 42 }
@@ -171,7 +170,7 @@ Testing Current do
       assert{ Current.attributes =~ {:user => nil, :controller => nil, :action => nil} }
 
       assert{ $before_initialize_called }
-      assert{ $prepend_before_filter_called }
+      assert{ $prepend_before_action_called }
 
       assert do
         Current.user = :user
@@ -196,15 +195,19 @@ Testing Current do
 private
   def mock_rails!
     Object.module_eval <<-__
+      remove_const :Rails if const_defined? :Rails
+      remove_const :ActionController if const_defined? :ActionController
+      remove_const :ActionView if const_defined? :ActionView
+
       module Rails
       end
 
       module ActionController
         class Base
-          def Base.prepend_before_filter(*args, &block)
+          def Base.prepend_before_action(*args, &block)
             block.call
           ensure
-            $prepend_before_filter_called = true
+            $prepend_before_action_called = true
           end
 
           def Base.helper(&block)
@@ -243,10 +246,10 @@ private
 
       module ActionController
         class Base
-          def Base.prepend_before_filter(*args, &block)
+          def Base.prepend_before_action(*args, &block)
             block.call
           ensure
-            $prepend_before_filter_called = true
+            $prepend_before_action_called = true
           end
 
           def Base.helper(&block)
@@ -272,7 +275,6 @@ private
   end
 end
 
-
 BEGIN {
   $this = File.expand_path(__FILE__)
   $root = File.dirname(File.dirname($this))

data/test/testing.rb

@@ -1,16 +1,12 @@
 # -*- encoding : utf-8 -*-
-#
-require 'test/unit'
+gem 'minitest'
+require 'minitest/autorun'
+require 'minitest/pride'
 
-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)
+if defined?(Testing)
+  Object.send(:remove_const, :Testing)
+end
 
 class Testing
   class Slug < ::String
@@ -36,8 +32,8 @@ class Testing
   end
 end
 
-def Testing(*args, &block)
-  Class.new(::Test::Unit::TestCase) do
+def Testing.test(*args, &block)
+  Class.new(::Minitest::Test) do
 
   ## class methods
   #
@@ -103,6 +99,35 @@ def Testing(*args, &block)
         @cleanup.push(block) if block
         @cleanup
       end
+
+    end
+
+    def assert_nothing_raised(*args, &block )
+      if Module === args.last
+        msg = nil
+      else
+        msg = args.pop
+      end
+      begin
+        line = __LINE__; yield
+      rescue MiniTest::Skip
+        raise
+      rescue Exception => e
+        bt = e.backtrace
+        as = e.instance_of?(MiniTest::Assertion)
+        if as
+          ans = /\A#{Regexp.quote(__FILE__)}:#{line}:in /o
+          bt.reject! {|ln| ans =~ ln}
+        end
+        if ((args.empty? && !as) ||
+            args.any? {|a| a.instance_of?(Module) ? e.is_a?(a) : e.class == a })
+          msg = message(msg) { "Exception raised:\n<#{mu_pp(e)}>" }
+          raise MiniTest::Assertion, msg.call, bt
+        else
+          raise
+        end
+      end
+      nil
     end
 
   ## configure the subclass!
@@ -124,7 +149,7 @@ def Testing(*args, &block)
         expected = getopt(:expected, options){ missing }
         actual = getopt(:actual, options){ missing }
         if expected == missing and actual == missing
-          actual, expected, *ignored = options.to_a.flatten
+          actual, expected, *_ = options.to_a.flatten
         end
         expected = expected.call() if expected.respond_to?(:call)
         actual = actual.call() if actual.respond_to?(:call)
@@ -184,14 +209,3 @@ def Testing(*args, &block)
     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,30 +1,31 @@
 --- !ruby/object:Gem::Specification
 name: rails_current
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 2.2.0
 platform: ruby
 authors:
 - Ara T. Howard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-08 00:00:00.000000000 Z
+date: 2020-10-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: map
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.0.1
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.0.1
-description: ! 'description: rails_current kicks the ass'
+        version: '6.0'
+description: track 'current_user' et all in a tidy, global, and thread-safe fashion
+  for your rails apps
 email: ara.t.howard@gmail.com
 executables: []
 extensions: []
@@ -33,10 +34,14 @@ files:
 - README.md
 - Rakefile
 - lib/rails_current.rb
+- rails_current.gemspec
+- tasks/default.rake
+- tasks/this.rb
 - test/rails_current_test.rb
 - test/testing.rb
 homepage: https://github.com/ahoward/rails_current
-licenses: []
+licenses:
+- Ruby
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -44,17 +49,16 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: codeforpeople
-rubygems_version: 2.0.3
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: rails_current