rails_current 1.9.0 → 2.1.0

checksums.yaml

@@ -1,15 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: !binary |-
-    OTEyNzAzZTc0MGYzOWZhMzc0MjY5ZTY1N2MyOWQ1ZGRkOGFhZDE2NQ==
-  data.tar.gz: !binary |-
-    MmE2NzM3YjYxMjIzMTcxM2QzYWZlMTRjYmEyOGM0M2MwNjczMTM5ZA==
-!binary "U0hBNTEy":
-  metadata.gz: !binary |-
-    ZDZlZjA1ZmY4MzIzZTJjMWIxMTg1YmNkZjllYWY0ZGQ4YjdkMjk3NjE3YmFl
-    NDAyMWJmMDA4ZjhhNjExZDFlNDYwNDFmZTcxMTk5MjZjOThhZDk0NzVlZGIy
-    OTkyNGNlOGYwMmRhYWRkNDE0YjQzMDJjMWY5NGUwNDYwNWM5OGM=
-  data.tar.gz: !binary |-
-    NWM4ODVlMTIzNWU0OTgzMzUzNGQ4NjI0YjkyZDlhZGZjODEzZmIxYzVhNGY5
-    NjE2ZjNiMzMyMTdiY2NkZDA5YWQ1ZGJiYTZlNjRiZjdkN2U3Mzc0NjUyNDdl
-    NWQwYzcyNmM5ZjU3YThiYzY3MWU2NzNhYmNkNjRhNzI5YmQyZTU=
+SHA1:
+  metadata.gz: 186f701535b7d65d21e71f7d1598a7caeb17f946
+  data.tar.gz: 6e51dc1f716e488da848212f0b107728f22b63f5
+SHA512:
+  metadata.gz: 9482a45d120991b3380422c515769a286f049d362fcab55561fcd9aea8bd40188d740235fa7eb2dc9f09d61bfa6d260eca583df46342b87284d53c11c165d507
+  data.tar.gz: af54cc69dbf1b94c2e71905ae5e802964b8cf3041f982d051e95c36691bb83db2b720be749b417742548a0a47bf411b2c44422061752dbf02aca947532a42dcb

data/Manifest.txt

@@ -0,0 +1,8 @@
+Manifest.txt
+README.md
+Rakefile
+lib/rails_current.rb
+tasks/default.rake
+tasks/this.rb
+test/rails_current_test.rb
+test/testing.rb

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,29 @@ 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.
 
-  the Current module is cleared out before every request and is thread safe.
+## INSTALL
 
---------------------------------
-INSTALL
---------------------------------
+```
+gem install rails_current
 
-   gem install rails-current
 
+gem 'rails-current', :require => 'current'
+bundle install
+```
 
-   gem 'rails-current', :require => 'current'
-   bundle install

data/Rakefile

@@ -1,394 +1,18 @@
-This.rubyforge_project = 'codeforpeople'
-This.author = "Ara T. Howard"
-This.email = "ara.t.howard@gmail.com"
-This.homepage = "https://github.com/ahoward/#{ This.lib }"
+# vim: syntax=ruby
+load 'tasks/this.rb'
 
-task :license do
-  open('LICENSE', 'w'){|fd| fd.puts "same as ruby's"}
-end
-
-task :default do
-  puts((Rake::Task.tasks.map{|task| task.name.gsub(/::/,':')} - ['default']).sort)
-end
-
-task :test do
-  run_tests!
-end
-
-namespace :test do
-  task(:unit){ run_tests!(:unit) }
-  task(:functional){ run_tests!(:functional) }
-  task(:integration){ run_tests!(:integration) }
-end
-
-def run_tests!(which = nil)
-  which ||= '**'
-  test_dir = File.join(This.dir, "test")
-  test_glob ||= File.join(test_dir, "#{ which }/**_test.rb")
-  test_rbs = Dir.glob(test_glob).sort
-        
-  div = ('=' * 119)
-  line = ('-' * 119)
-
-  test_rbs.each_with_index do |test_rb, index|
-    testno = index + 1
-    command = "#{ This.ruby } -w -I ./lib -I ./test/lib #{ test_rb }"
-
-    puts
-    say(div, :color => :cyan, :bold => true)
-    say("@#{ testno } => ", :bold => true, :method => :print)
-    say(command, :color => :cyan, :bold => true)
-    say(line, :color => :cyan, :bold => true)
-
-    system(command)
-
-    say(line, :color => :cyan, :bold => true)
-
-    status = $?.exitstatus
-
-    if status.zero? 
-      say("@#{ testno } <= ", :bold => true, :color => :white, :method => :print)
-      say("SUCCESS", :color => :green, :bold => true)
-    else
-      say("@#{ testno } <= ", :bold => true, :color => :white, :method => :print)
-      say("FAILURE", :color => :red, :bold => true)
-    end
-    say(line, :color => :cyan, :bold => true)
-
-    exit(status) unless status.zero?
-  end
-end
-
-
-task :gemspec do
-  ignore_extensions = ['git', 'svn', 'tmp', /sw./, 'bak', 'gem']
-  ignore_directories = ['pkg']
-  ignore_files = ['test/log']
-
-  shiteless = 
-    lambda do |list|
-      list.delete_if do |entry|
-        next unless test(?e, entry)
-        extension = File.basename(entry).split(%r/[.]/).last
-        ignore_extensions.any?{|ext| ext === extension}
-      end
-      list.delete_if do |entry|
-        next unless test(?d, entry)
-        dirname = File.expand_path(entry)
-        ignore_directories.any?{|dir| File.expand_path(dir) == dirname}
-      end
-      list.delete_if do |entry|
-        next unless test(?f, entry)
-        filename = File.expand_path(entry)
-        ignore_files.any?{|file| File.expand_path(file) == filename}
-      end
-    end
-
-  lib         = This.lib
-  object      = This.object
-  version     = This.version
-  files       = shiteless[Dir::glob("**/**")]
-  executables = shiteless[Dir::glob("bin/*")].map{|exe| File.basename(exe)}
-  #has_rdoc    = true #File.exist?('doc')
-  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 : "same as ruby's"
-
-  if This.extensions.nil?
-    This.extensions = []
-    extensions = This.extensions
-    %w( Makefile configure extconf.rb ).each do |ext|
-      extensions << ext if File.exists?(ext)
-    end
-  end
-  extensions = [extensions].flatten.compact
-
-  if This.dependencies.nil?
-    dependencies = []
-  else
-    case This.dependencies
-      when Hash
-        dependencies = This.dependencies.values
-      when Array
-        dependencies = This.dependencies
-    end
-  end
-
-  template = 
-    if test(?e, 'gemspec.erb')
-      Template{ IO.read('gemspec.erb') }
-    else
-      Template {
-        <<-__
-          ## <%= lib %>.gemspec
-          #
-
-          Gem::Specification::new do |spec|
-            spec.name = <%= lib.inspect %>
-            spec.version = <%= version.inspect %>
-            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 %>
-            
-            spec.require_path = "lib"
-
-            spec.test_files = <%= test_files.inspect %>
-
-            <% dependencies.each do |lib_version| %>
-              spec.add_dependency(*<%= Array(lib_version).flatten.inspect %>)
-            <% end %>
-
-            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 %>
-          end
-        __
-      }
-    end
-
-  Fu.mkdir_p(This.pkgdir)
-  gemspec = "#{ lib }.gemspec"
-  open(gemspec, "w"){|fd| fd.puts(template)}
-  This.gemspec = gemspec
-end
-
-task :gem => [:clean, :gemspec] do
-  Fu.mkdir_p(This.pkgdir)
-  before = Dir['*.gem']
-  cmd = "gem build #{ This.gemspec }"
-  `#{ cmd }`
-  after = Dir['*.gem']
-  gem = ((after - before).first || after.first) or abort('no gem!')
-  Fu.mv(gem, This.pkgdir)
-  This.gem = File.join(This.pkgdir, File.basename(gem))
-end
-
-task :readme do
-  samples = ''
-  prompt = '~ > '
-  lib = This.lib
-  version = This.version
-
-  Dir['sample*/*'].sort.each do |sample|
-    samples << "\n" << "  <========< #{ sample } >========>" << "\n\n"
+This.name     = "rails_current"
+This.author   = "Ara T. Howard"
+This.email    = "ara.t.howard@gmail.com"
+This.homepage = "https://github.com/ahoward/#{ This.name }"
 
-    cmd = "cat #{ sample }"
-    samples << Util.indent(prompt + cmd, 2) << "\n\n"
-    samples << Util.indent(`#{ cmd }`, 4) << "\n"
+This.ruby_gemspec do |spec|
+  spec.add_dependency( 'map', '~> 6.0')
 
-    cmd = "ruby #{ sample }"
-    samples << Util.indent(prompt + cmd, 2) << "\n\n"
+  spec.add_development_dependency( 'rake'     , '~> 10.1')
+  spec.add_development_dependency( 'minitest' , '~> 5.0' )
 
-    cmd = "ruby -e'STDOUT.sync=true; exec %(ruby -I ./lib #{ sample })'"
-    samples << Util.indent(`#{ cmd } 2>&1`, 4) << "\n"
-  end
-
-  template = 
-    if test(?e, 'README.erb')
-      Template{ IO.read('README.erb') }
-    else
-      Template {
-        <<-__
-          NAME
-            #{ lib }
-
-          DESCRIPTION
-
-          INSTALL
-            gem install #{ lib }
-
-          SAMPLES
-            #{ samples }
-        __
-      }
-    end
-
-  open("README", "w"){|fd| fd.puts template}
-end
-
-
-task :clean do
-  Dir[File.join(This.pkgdir, '**/**')].each{|entry| Fu.rm_rf(entry)}
-end
-
-
-task :release => [:clean, :gemspec, :gem] do
-  gems = Dir[File.join(This.pkgdir, '*.gem')].flatten
-  raise "which one? : #{ gems.inspect }" if gems.size > 1
-  raise "no gems?" if gems.size < 1
-
-  cmd = "gem push #{ This.gem }"
-  puts cmd
-  puts
-  system(cmd)
-  abort("cmd(#{ cmd }) failed with (#{ $?.inspect })") unless $?.exitstatus.zero?
-
-  cmd = "rubyforge login && rubyforge add_release #{ This.rubyforge_project } #{ This.lib } #{ This.version } #{ This.gem }"
-  puts cmd
-  puts
-  system(cmd)
-  abort("cmd(#{ cmd }) failed with (#{ $?.inspect })") unless $?.exitstatus.zero?
+  spec.licenses = ['Ruby']
 end
 
-
-
-
-
-BEGIN {
-# support for this rakefile
-#
-  $VERBOSE = nil
-
-  require 'ostruct'
-  require 'erb'
-  require 'fileutils'
-  require 'rbconfig'
-  require 'pp'
-
-# fu shortcut
-#
-  Fu = FileUtils
-
-# cache a bunch of stuff about this rakefile/environment
-#
-  This = OpenStruct.new
-
-  This.file = File.expand_path(__FILE__)
-  This.dir = File.dirname(This.file)
-  This.pkgdir = File.join(This.dir, 'pkg')
-
-# grok lib
-#
-  lib = ENV['LIB']
-  unless lib
-    lib = File.basename(Dir.pwd).sub(/[-].*$/, '')
-  end
-  This.lib = lib
-
-# grok version
-#
-  version = ENV['VERSION']
-  unless version
-    require "./lib/#{ This.lib }"
-    This.name = lib.capitalize
-    This.object = eval(This.name)
-    version = This.object.send(:version)
-  end
-  This.version = version
-
-# see if dependencies are export by the module
-#
-  if This.object.respond_to?(:dependencies)
-    This.dependencies = This.object.dependencies
-  end
-
-# we need to know the name of the lib an it's version
-#
-  abort('no lib') unless This.lib
-  abort('no version') unless This.version
-
-# discover full path to this ruby executable
-#
-  c = Config::CONFIG
-  bindir = c["bindir"] || c['BINDIR']
-  ruby_install_name = c['ruby_install_name'] || c['RUBY_INSTALL_NAME'] || 'ruby'
-  ruby_ext = c['EXEEXT'] || ''
-  ruby = File.join(bindir, (ruby_install_name + ruby_ext))
-  This.ruby = ruby
-
-# some utils
-#
-  module Util
-    def indent(s, n = 2)
-      s = unindent(s)
-      ws = ' ' * n
-      s.gsub(%r/^/, ws)
-    end
-
-    def unindent(s)
-      indent = nil
-      s.each_line do |line|
-      next if line =~ %r/^\s*$/
-      indent = line[%r/^\s*/] and break
-    end
-    indent ? s.gsub(%r/^#{ indent }/, "") : s
-  end
-    extend self
-  end
-
-# template support
-#
-  class Template
-    def initialize(&block)
-      @block = block
-      @template = block.call.to_s
-    end
-    def expand(b=nil)
-      ERB.new(Util.unindent(@template)).result((b||@block).binding)
-    end
-    alias_method 'to_s', 'expand'
-  end
-  def Template(*args, &block) Template.new(*args, &block) end
-
-# colored console output support
-#
-  This.ansi = {
-    :clear      => "\e[0m",
-    :reset      => "\e[0m",
-    :erase_line => "\e[K",
-    :erase_char => "\e[P",
-    :bold       => "\e[1m",
-    :dark       => "\e[2m",
-    :underline  => "\e[4m",
-    :underscore => "\e[4m",
-    :blink      => "\e[5m",
-    :reverse    => "\e[7m",
-    :concealed  => "\e[8m",
-    :black      => "\e[30m",
-    :red        => "\e[31m",
-    :green      => "\e[32m",
-    :yellow     => "\e[33m",
-    :blue       => "\e[34m",
-    :magenta    => "\e[35m",
-    :cyan       => "\e[36m",
-    :white      => "\e[37m",
-    :on_black   => "\e[40m",
-    :on_red     => "\e[41m",
-    :on_green   => "\e[42m",
-    :on_yellow  => "\e[43m",
-    :on_blue    => "\e[44m",
-    :on_magenta => "\e[45m",
-    :on_cyan    => "\e[46m",
-    :on_white   => "\e[47m"
-  }
-  def say(phrase, *args)
-    options = args.last.is_a?(Hash) ? args.pop : {}
-    options[:color] = args.shift.to_s.to_sym unless args.empty?
-    keys = options.keys
-    keys.each{|key| options[key.to_s.to_sym] = options.delete(key)}
-
-    color = options[:color]
-    bold = options.has_key?(:bold)
-
-    parts = [phrase]
-    parts.unshift(This.ansi[color]) if color
-    parts.unshift(This.ansi[:bold]) if bold
-    parts.push(This.ansi[:clear]) if parts.size > 1
-
-    method = options[:method] || :puts
-
-    Kernel.send(method, parts.join)
-  end
-
-# always run out of the project dir
-#
-  Dir.chdir(This.dir)
-}
+load 'tasks/default.rake'

data/lib/rails_current.rb

@@ -1,8 +1,9 @@
 # -*- encoding : utf-8 -*-
 
 module Current
+  VERSION = '2.1.0'
   def Current.version
-    '1.9.0'
+    VERSION
   end
 
   def Current.dependencies
@@ -153,8 +154,7 @@ module Current
     case method.to_s
       when /^current_(.*)$/
         msg = $1
-        value = Current.send(msg, *args, &block)
-
+        Current.send(msg, *args, &block)
       else
         super
     end
@@ -172,8 +172,8 @@ module Current
       controller.perform_caching = true
       controller.cache_store = store
 
-      request = ActionDispatch::TestRequest.new
-      response = ActionDispatch::TestResponse.new
+      request = ActionDispatch::TestRequest.create({})
+      response = ActionDispatch::TestResponse.create({})
 
       controller.request = request
       controller.response = response
@@ -262,10 +262,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
@@ -285,12 +285,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
@@ -301,4 +301,3 @@ BEGIN {
   Object.send(:remove_const, :Current) if defined?(::Current)
   Object.send(:remove_const, :Rails_current) if defined?(::Rails_current)
 }
-

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
+      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,3 +1,4 @@
+require 'testing'
 
 Testing Current do
 
@@ -42,7 +43,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 +53,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 +95,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 +172,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
@@ -201,10 +202,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)
@@ -243,10 +244,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 +273,6 @@ private
   end
 end
 
-
 BEGIN {
   $this = File.expand_path(__FILE__)
   $root = File.dirname(File.dirname($this))

data/test/testing.rb

@@ -1,16 +1,8 @@
 # -*- 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)
+gem 'minitest'
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'rails_current'
 
 class Testing
   class Slug < ::String
@@ -37,7 +29,7 @@ class Testing
 end
 
 def Testing(*args, &block)
-  Class.new(::Test::Unit::TestCase) do
+  Class.new(::Minitest::Test) do
 
   ## class methods
   #
@@ -103,6 +95,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 +145,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 +205,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,64 +1,99 @@
 --- !ruby/object:Gem::Specification
 name: rails_current
 version: !ruby/object:Gem::Version
-  version: 1.9.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Ara T. Howard
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-21 00:00:00.000000000 Z
+date: 2018-03-01 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: track 'current_user' et all in a tidy, global, and thread-safe fashion
-  for your rails apps
+        version: '6.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: track `current_user` et all in a tidy, global, and thread-safe fashion.
 email: ara.t.howard@gmail.com
 executables: []
 extensions: []
-extra_rdoc_files: []
+extra_rdoc_files:
+- Manifest.txt
+- README.md
 files:
+- Manifest.txt
 - 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:
-- same as ruby's
+- Ruby
 metadata: {}
 post_install_message: 
-rdoc_options: []
+rdoc_options:
+- "--main"
+- README.md
+- "--markup"
+- tomdoc
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: codeforpeople
-rubygems_version: 2.0.3
+rubyforge_project: 
+rubygems_version: 2.6.8
 signing_key: 
 specification_version: 4
-summary: rails_current
+summary: track `current_user` et all in a tidy, global, and thread-safe fashion.
 test_files: []

data/rails_current.gemspec

@@ -1,38 +0,0 @@
-## rails_current.gemspec
-#
-
-Gem::Specification::new do |spec|
-  spec.name = "rails_current"
-  spec.version = "1.9.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 = "same as ruby's"
-
-  spec.files =
-["README.md",
- "Rakefile",
- "lib",
- "lib/rails_current.rb",
- "rails_current.gemspec",
- "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.1"])
-  
-
-  spec.extensions.push(*[])
-
-  spec.rubyforge_project = "codeforpeople"
-  spec.author = "Ara T. Howard"
-  spec.email = "ara.t.howard@gmail.com"
-  spec.homepage = "https://github.com/ahoward/rails_current"
-end