opal-activesupport 0.2.0 → 0.3.0

data/test/core_ext/blank_test.rb

@@ -0,0 +1,24 @@
+# encoding: utf-8
+
+require 'abstract_unit'
+require 'active_support/core_ext/object/blank'
+
+class BlankTest < ActiveSupport::TestCase
+  BLANK = [ EmptyTrue.new, nil, false, '', '   ', "  \n\t  \r ", '　', [], {} ]
+  NOT   = [ EmptyFalse.new, Object.new, true, 0, 1, 'a', [nil], { nil => 0 } ]
+
+  def test_blank
+    BLANK.each { |v| assert v.blank?,  "#{v.inspect} should be blank" }
+    NOT.each   { |v| assert !v.blank?, "#{v.inspect} should not be blank" }
+  end
+
+  def test_present
+    BLANK.each { |v| assert !v.present?, "#{v.inspect} should not be present" }
+    NOT.each   { |v| assert v.present?,  "#{v.inspect} should be present" }
+  end
+
+  def test_presence
+    BLANK.each { |v| assert_equal nil, v.presence, "#{v.inspect}.presence should return nil" }
+    NOT.each   { |v| assert_equal v,   v.presence, "#{v.inspect}.presence should return self" }
+  end
+end

data/{spec/core_ext/class/attribute_spec.rb → test/core_ext/class/attribute_test.rb}

@@ -1,22 +1,23 @@
-require 'spec_helper'
+require 'abstract_unit'
+require 'active_support/core_ext/class/attribute'
 
-describe Class do
-  before do
+class ClassAttributeTest < ActiveSupport::TestCase
+  def setup
     @klass = Class.new { class_attribute :setting }
     @sub = Class.new(@klass)
   end
 
-  it 'defaults to nil' do
+  test 'defaults to nil' do
     assert_nil @klass.setting
     assert_nil @sub.setting
   end
 
-  it 'inheritable' do
+  test 'inheritable' do
     @klass.setting = 1
     assert_equal 1, @sub.setting
   end
 
-  it 'overridable' do
+  test 'overridable' do
     @sub.setting = 1
     assert_nil @klass.setting
 
@@ -26,20 +27,20 @@ describe Class do
     assert_equal 1, Class.new(@sub).setting
   end
 
-  it 'predicate method' do
+  test 'query method' do
     assert_equal false, @klass.setting?
     @klass.setting = 1
     assert_equal true, @klass.setting?
   end
 
-  it 'instance reader delegates to class' do
+  test 'instance reader delegates to class' do
     assert_nil @klass.new.setting
 
     @klass.setting = 1
     assert_equal 1, @klass.new.setting
   end
 
-  it 'instance override' do
+  test 'instance override' do
     object = @klass.new
     object.setting = 1
     assert_nil @klass.setting
@@ -47,43 +48,38 @@ describe Class do
     assert_equal 1, object.setting
   end
 
-  it 'instance predicate' do
+  test 'instance query' do
     object = @klass.new
     assert_equal false, object.setting?
     object.setting = 1
     assert_equal true, object.setting?
   end
 
-  it 'disabling instance writer' do
+  test 'disabling instance writer' do
     object = Class.new { class_attribute :setting, :instance_writer => false }.new
     assert_raise(NoMethodError) { object.setting = 'boom' }
   end
 
-  it 'disabling instance reader' do
+  test 'disabling instance reader' do
     object = Class.new { class_attribute :setting, :instance_reader => false }.new
     assert_raise(NoMethodError) { object.setting }
     assert_raise(NoMethodError) { object.setting? }
   end
 
-  it 'disabling both instance writer and reader' do
+  test 'disabling both instance writer and reader' do
     object = Class.new { class_attribute :setting, :instance_accessor => false }.new
     assert_raise(NoMethodError) { object.setting }
     assert_raise(NoMethodError) { object.setting? }
     assert_raise(NoMethodError) { object.setting = 'boom' }
   end
 
-  it 'disabling instance predicate' do
-    object = Class.new { class_attribute :setting, instance_predicate: false }.new
-    assert_raise(NoMethodError) { object.setting? }
-  end
-
-  it 'works well with singleton classes' do
+  test 'works well with singleton classes' do
     object = @klass.new
     object.singleton_class.setting = 'foo'
     assert_equal 'foo', object.setting
   end
 
-  it 'setter returns set value' do
+  test 'setter returns set value' do
     val = @klass.send(:setting=, 1)
     assert_equal 1, val
   end

data/test/core_ext/kernel_test.rb

@@ -0,0 +1,124 @@
+require 'abstract_unit'
+require 'active_support/core_ext/kernel'
+
+class KernelTest < ActiveSupport::TestCase
+  # def test_silence_warnings
+  #   silence_warnings { assert_nil $VERBOSE }
+  #   assert_equal 1234, silence_warnings { 1234 }
+  # end
+  #
+  # def test_silence_warnings_verbose_invariant
+  #   old_verbose = $VERBOSE
+  #   silence_warnings { raise }
+  #   flunk
+  # rescue
+  #   assert_equal old_verbose, $VERBOSE
+  # end
+  #
+  #
+  # def test_enable_warnings
+  #   enable_warnings { assert_equal true, $VERBOSE }
+  #   assert_equal 1234, enable_warnings { 1234 }
+  # end
+  #
+  # def test_enable_warnings_verbose_invariant
+  #   old_verbose = $VERBOSE
+  #   enable_warnings { raise }
+  #   flunk
+  # rescue
+  #   assert_equal old_verbose, $VERBOSE
+  # end
+  #
+  #
+  # def test_silence_stderr
+  #   old_stderr_position = STDERR.tell
+  #   silence_stderr { STDERR.puts 'hello world' }
+  #   assert_equal old_stderr_position, STDERR.tell
+  # rescue Errno::ESPIPE
+  #   # Skip if we can't STDERR.tell
+  # end
+  #
+  # def test_quietly
+  #   old_stdout_position, old_stderr_position = STDOUT.tell, STDERR.tell
+  #   quietly do
+  #     puts 'see me, feel me'
+  #     STDERR.puts 'touch me, heal me'
+  #   end
+  #   assert_equal old_stdout_position, STDOUT.tell
+  #   assert_equal old_stderr_position, STDERR.tell
+  # rescue Errno::ESPIPE
+  #   # Skip if we can't STDERR.tell
+  # end
+  #
+  # def test_silence_stderr_with_return_value
+  #   assert_equal 1, silence_stderr { 1 }
+  # end
+
+  def test_class_eval
+    o = Object.new
+    class << o; @x = 1; end
+    assert_equal 1, o.class_eval { @x }
+  end
+
+  # def test_capture
+  #   assert_equal 'STDERR', capture(:stderr) { $stderr.print 'STDERR' }
+  #   assert_equal 'STDOUT', capture(:stdout) { print 'STDOUT' }
+  #   assert_equal "STDERR\n", capture(:stderr) { system('echo STDERR 1>&2') }
+  #   assert_equal "STDOUT\n", capture(:stdout) { system('echo STDOUT') }
+  # end
+end
+
+# class KernelSuppressTest < ActiveSupport::TestCase
+#   def test_reraise
+#     assert_raise(LoadError) do
+#       suppress(ArgumentError) { raise LoadError }
+#     end
+#   end
+#
+#   def test_suppression
+#     suppress(ArgumentError) { raise ArgumentError }
+#     suppress(LoadError) { raise LoadError }
+#     suppress(LoadError, ArgumentError) { raise LoadError }
+#     suppress(LoadError, ArgumentError) { raise ArgumentError }
+#   end
+# end
+#
+# class MockStdErr
+#   attr_reader :output
+#   def puts(message)
+#     @output ||= []
+#     @output << message
+#   end
+#
+#   def info(message)
+#     puts(message)
+#   end
+#
+#   def write(message)
+#     puts(message)
+#   end
+# end
+#
+# class KernelDebuggerTest < ActiveSupport::TestCase
+#   def test_debugger_not_available_message_to_stderr
+#     old_stderr = $stderr
+#     $stderr = MockStdErr.new
+#     debugger
+#     assert_match(/Debugger requested/, $stderr.output.first)
+#   ensure
+#     $stderr = old_stderr
+#   end
+#
+#   def test_debugger_not_available_message_to_rails_logger
+#     rails = Class.new do
+#       def self.logger
+#         @logger ||= MockStdErr.new
+#       end
+#     end
+#     Object.const_set(:Rails, rails)
+#     debugger
+#     assert_match(/Debugger requested/, rails.logger.output.first)
+#   ensure
+#     Object.send(:remove_const, :Rails)
+#   end
+# end

data/test/core_ext/module/remove_method_test.rb

@@ -0,0 +1,29 @@
+require 'abstract_unit'
+require 'active_support/core_ext/module/remove_method'
+
+module RemoveMethodTests
+  class A
+    def do_something
+      return 1
+    end
+    
+  end
+end
+
+class RemoveMethodTest < ActiveSupport::TestCase
+  
+  def test_remove_method_from_an_object
+    RemoveMethodTests::A.class_eval{
+      self.remove_possible_method(:do_something)
+    }
+    assert !RemoveMethodTests::A.new.respond_to?(:do_something)
+  end
+  
+  def test_redefine_method_in_an_object
+    RemoveMethodTests::A.class_eval{
+      self.redefine_method(:do_something) { return 100 }
+    }
+    assert_equal 100, RemoveMethodTests::A.new.do_something
+  end
+
+end

data/test/core_ext/module_test.rb

@@ -0,0 +1,439 @@
+require 'abstract_unit'
+require 'active_support/core_ext/module'
+
+module One
+  Constant1 = "Hello World"
+  Constant2 = "What's up?"
+end
+
+class Ab
+  include One
+  Constant1 = "Hello World" # Will have different object id than One::Constant1
+  Constant3 = "Goodbye World"
+end
+
+module Xy
+  class Bc
+    include One
+  end
+end
+
+module Yz
+  module Zy
+    class Cd
+      include One
+    end
+  end
+end
+
+Somewhere = Struct.new(:street, :city) do
+  attr_accessor :name
+end
+
+class Someone < Struct.new(:name, :place)
+  delegate :street, :city, :to_f, :to => :place
+  delegate :name=, :to => :place, :prefix => true
+  delegate :upcase, :to => "place.city"
+  delegate :table_name, :to => :class
+  delegate :table_name, :to => :class, :prefix => true
+
+  def self.table_name
+    'some_table'
+  end
+
+  FAILED_DELEGATE_LINE = __LINE__ + 1
+  delegate :foo, :to => :place
+
+  FAILED_DELEGATE_LINE_2 = __LINE__ + 1
+  delegate :bar, :to => :place, :allow_nil => true
+end
+
+Invoice   = Struct.new(:client) do
+  delegate :street, :city, :name, :to => :client, :prefix => true
+  delegate :street, :city, :name, :to => :client, :prefix => :customer
+end
+
+Project   = Struct.new(:description, :person) do
+  delegate :name, :to => :person, :allow_nil => true
+  delegate :to_f, :to => :description, :allow_nil => true
+end
+
+Developer = Struct.new(:client) do
+  delegate :name, :to => :client, :prefix => nil
+end
+
+Tester = Struct.new(:client) do
+  delegate :name, :to => :client, :prefix => false
+end
+
+class ParameterSet
+  delegate :[], :[]=, :to => :@params
+
+  def initialize
+    @params = {:foo => "bar"}
+  end
+end
+
+class Name
+  delegate :upcase, :to => :@full_name
+
+  def initialize(first, last)
+    @full_name = "#{first} #{last}"
+  end
+end
+
+class ModuleTest < ActiveSupport::TestCase
+  def setup
+    @david = Someone.new("David", Somewhere.new("Paulina", "Chicago"))
+  end
+
+  def test_delegation_to_methods
+    assert_equal "Paulina", @david.street
+    assert_equal "Chicago", @david.city
+  end
+
+  def test_delegation_to_assignment_method
+    @david.place_name = "Fred"
+    assert_equal "Fred", @david.place.name
+  end
+
+  def test_delegation_to_index_get_method
+    @params = ParameterSet.new
+    assert_equal "bar", @params[:foo]
+  end
+
+  def test_delegation_to_index_set_method
+    @params = ParameterSet.new
+    @params[:foo] = "baz"
+    assert_equal "baz", @params[:foo]
+  end
+
+  # def test_delegation_down_hierarchy
+  #   assert_equal "CHICAGO", @david.upcase
+  # end
+
+  def test_delegation_to_instance_variable
+    david = Name.new("David", "Hansson")
+    assert_equal "DAVID HANSSON", david.upcase
+  end
+
+  def test_delegation_to_class_method
+    assert_equal 'some_table', @david.table_name
+    assert_equal 'some_table', @david.class_table_name
+  end
+
+  def test_missing_delegation_target
+    assert_raise(ArgumentError) do
+      Name.send :delegate, :nowhere
+    end
+    assert_raise(ArgumentError) do
+      Name.send :delegate, :noplace, :tos => :hollywood
+    end
+  end
+
+  def test_delegation_prefix
+    invoice = Invoice.new(@david)
+    assert_equal invoice.client_name, "David"
+    assert_equal invoice.client_street, "Paulina"
+    assert_equal invoice.client_city, "Chicago"
+  end
+
+  def test_delegation_custom_prefix
+    invoice = Invoice.new(@david)
+    assert_equal invoice.customer_name, "David"
+    assert_equal invoice.customer_street, "Paulina"
+    assert_equal invoice.customer_city, "Chicago"
+  end
+
+  def test_delegation_prefix_with_nil_or_false
+    assert_equal Developer.new(@david).name, "David"
+    assert_equal Tester.new(@david).name, "David"
+  end
+
+  def test_delegation_prefix_with_instance_variable
+    assert_raise ArgumentError do
+      Class.new do
+        def initialize(client)
+          @client = client
+        end
+        delegate :name, :address, :to => :@client, :prefix => true
+      end
+    end
+  end
+
+  def test_delegation_with_allow_nil
+    rails = Project.new("Rails", Someone.new("David"))
+    assert_equal rails.name, "David"
+  end
+
+  def test_delegation_with_allow_nil_and_nil_value
+    rails = Project.new("Rails")
+    assert_nil rails.name
+  end
+
+  def test_delegation_with_allow_nil_and_nil_value_and_prefix
+    Project.class_eval do
+      delegate :name, :to => :person, :allow_nil => true, :prefix => true
+    end
+    rails = Project.new("Rails")
+    assert_nil rails.person_name
+  end
+
+  # def test_delegation_without_allow_nil_and_nil_value
+  #   david = Someone.new("David")
+  #   assert_raise(RuntimeError) { david.street }
+  # end
+  #
+  # def test_delegation_to_method_that_exists_on_nil
+  #   nil_person = Someone.new(nil)
+  #   assert_equal 0.0, nil_person.to_f
+  # end
+  #
+  # def test_delegation_to_method_that_exists_on_nil_when_allowing_nil
+  #   nil_project = Project.new(nil)
+  #   assert_equal 0.0, nil_project.to_f
+  # end
+  #
+  # def test_delegation_does_not_raise_error_when_removing_singleton_instance_methods
+  #   parent = Class.new do
+  #     def self.parent_method; end
+  #   end
+  #
+  #   assert_nothing_raised do
+  #     Class.new(parent) do
+  #       class << self
+  #         delegate :parent_method, :to => :superclass
+  #       end
+  #     end
+  #   end
+  # end
+
+  # DISABLED: Backtrace in JavaScript is Hard™
+  # def test_delegation_exception_backtrace
+  #   someone = Someone.new("foo", "bar")
+  #   someone.foo
+  # rescue NoMethodError => e
+  #   file_and_line = "#{__FILE__}:#{Someone::FAILED_DELEGATE_LINE}"
+  #   # We can't simply check the first line of the backtrace, because JRuby reports the call to __send__ in the backtrace.
+  #   assert e.backtrace.any?{|a| a.include?(file_and_line)},
+  #          "[#{e.backtrace.inspect}] did not include [#{file_and_line}]"
+  # end
+
+  # DISABLED: Backtrace in JavaScript is Hard™
+  # def test_delegation_exception_backtrace_with_allow_nil
+  #   someone = Someone.new("foo", "bar")
+  #   someone.bar
+  # rescue NoMethodError => e
+  #   file_and_line = "#{__FILE__}:#{Someone::FAILED_DELEGATE_LINE_2}"
+  #   # We can't simply check the first line of the backtrace, because JRuby reports the call to __send__ in the backtrace.
+  #   assert e.backtrace.any?{|a| a.include?(file_and_line)},
+  #          "[#{e.backtrace.inspect}] did not include [#{file_and_line}]"
+  # end
+
+  def test_parent
+    assert_equal Yz::Zy, Yz::Zy::Cd.parent
+    assert_equal Yz, Yz::Zy.parent
+    assert_equal Object, Yz.parent
+  end
+
+  def test_parents
+    assert_equal [Yz::Zy, Yz, Object], Yz::Zy::Cd.parents
+    assert_equal [Yz, Object], Yz::Zy.parents
+  end
+
+  # def test_local_constants
+  #   assert_equal %w(Constant1 Constant3), Ab.local_constants.sort.map(&:to_s)
+  # end
+  #
+  # def test_local_constant_names
+  #   ActiveSupport::Deprecation.silence do
+  #     assert_equal %w(Constant1 Constant3), Ab.local_constant_names.sort.map(&:to_s)
+  #   end
+  # end
+end
+
+# module BarMethodAliaser
+#   def self.included(foo_class)
+#     foo_class.class_eval do
+#       include BarMethods
+#       alias_method_chain :bar, :baz
+#     end
+#   end
+# end
+#
+# module BarMethods
+#   def bar_with_baz
+#     bar_without_baz << '_with_baz'
+#   end
+#
+#   def quux_with_baz!
+#     quux_without_baz! << '_with_baz'
+#   end
+#
+#   def quux_with_baz?
+#     false
+#   end
+#
+#   def quux_with_baz=(v)
+#     send(:quux_without_baz=, v) << '_with_baz'
+#   end
+#
+#   def duck_with_orange
+#     duck_without_orange << '_with_orange'
+#   end
+# end
+#
+# class MethodAliasingTest < ActiveSupport::TestCase
+#   def setup
+#     Object.const_set :FooClassWithBarMethod, Class.new { def bar() 'bar' end }
+#     @instance = FooClassWithBarMethod.new
+#   end
+#
+#   def teardown
+#     Object.instance_eval { remove_const :FooClassWithBarMethod }
+#   end
+#
+#   def test_alias_method_chain
+#     assert @instance.respond_to?(:bar)
+#     feature_aliases = [:bar_with_baz, :bar_without_baz]
+#
+#     feature_aliases.each do |method|
+#       assert !@instance.respond_to?(method)
+#     end
+#
+#     assert_equal 'bar', @instance.bar
+#
+#     FooClassWithBarMethod.class_eval { include BarMethodAliaser }
+#
+#     feature_aliases.each do |method|
+#       assert_respond_to @instance, method
+#     end
+#
+#     assert_equal 'bar_with_baz', @instance.bar
+#     assert_equal 'bar', @instance.bar_without_baz
+#   end
+#
+#   def test_alias_method_chain_with_punctuation_method
+#     FooClassWithBarMethod.class_eval do
+#       def quux!; 'quux' end
+#     end
+#
+#     assert !@instance.respond_to?(:quux_with_baz!)
+#     FooClassWithBarMethod.class_eval do
+#       include BarMethodAliaser
+#       alias_method_chain :quux!, :baz
+#     end
+#     assert_respond_to @instance, :quux_with_baz!
+#
+#     assert_equal 'quux_with_baz', @instance.quux!
+#     assert_equal 'quux', @instance.quux_without_baz!
+#   end
+#
+#   def test_alias_method_chain_with_same_names_between_predicates_and_bang_methods
+#     FooClassWithBarMethod.class_eval do
+#       def quux!; 'quux!' end
+#       def quux?; true end
+#       def quux=(v); 'quux=' end
+#     end
+#
+#     assert !@instance.respond_to?(:quux_with_baz!)
+#     assert !@instance.respond_to?(:quux_with_baz?)
+#     assert !@instance.respond_to?(:quux_with_baz=)
+#
+#     FooClassWithBarMethod.class_eval { include BarMethodAliaser }
+#     assert_respond_to @instance, :quux_with_baz!
+#     assert_respond_to @instance, :quux_with_baz?
+#     assert_respond_to @instance, :quux_with_baz=
+#
+#
+#     FooClassWithBarMethod.alias_method_chain :quux!, :baz
+#     assert_equal 'quux!_with_baz', @instance.quux!
+#     assert_equal 'quux!', @instance.quux_without_baz!
+#
+#     FooClassWithBarMethod.alias_method_chain :quux?, :baz
+#     assert_equal false, @instance.quux?
+#     assert_equal true,  @instance.quux_without_baz?
+#
+#     FooClassWithBarMethod.alias_method_chain :quux=, :baz
+#     assert_equal 'quux=_with_baz', @instance.send(:quux=, 1234)
+#     assert_equal 'quux=', @instance.send(:quux_without_baz=, 1234)
+#   end
+#
+#   def test_alias_method_chain_with_feature_punctuation
+#     FooClassWithBarMethod.class_eval do
+#       def quux; 'quux' end
+#       def quux?; 'quux?' end
+#       include BarMethodAliaser
+#       alias_method_chain :quux, :baz!
+#     end
+#
+#     assert_nothing_raised do
+#       assert_equal 'quux_with_baz', @instance.quux_with_baz!
+#     end
+#
+#     assert_raise(NameError) do
+#       FooClassWithBarMethod.alias_method_chain :quux?, :baz!
+#     end
+#   end
+#
+#   def test_alias_method_chain_yields_target_and_punctuation
+#     args = nil
+#
+#     FooClassWithBarMethod.class_eval do
+#       def quux?; end
+#       include BarMethods
+#
+#       FooClassWithBarMethod.alias_method_chain :quux?, :baz do |target, punctuation|
+#         args = [target, punctuation]
+#       end
+#     end
+#
+#     assert_not_nil args
+#     assert_equal 'quux', args[0]
+#     assert_equal '?', args[1]
+#   end
+#
+#   def test_alias_method_chain_preserves_private_method_status
+#     FooClassWithBarMethod.class_eval do
+#       def duck; 'duck' end
+#       include BarMethodAliaser
+#       private :duck
+#       alias_method_chain :duck, :orange
+#     end
+#
+#     assert_raise NoMethodError do
+#       @instance.duck
+#     end
+#
+#     assert_equal 'duck_with_orange', @instance.instance_eval { duck }
+#     assert FooClassWithBarMethod.private_method_defined?(:duck)
+#   end
+#
+#   def test_alias_method_chain_preserves_protected_method_status
+#     FooClassWithBarMethod.class_eval do
+#       def duck; 'duck' end
+#       include BarMethodAliaser
+#       protected :duck
+#       alias_method_chain :duck, :orange
+#     end
+#
+#     assert_raise NoMethodError do
+#       @instance.duck
+#     end
+#
+#     assert_equal 'duck_with_orange', @instance.instance_eval { duck }
+#     assert FooClassWithBarMethod.protected_method_defined?(:duck)
+#   end
+#
+#   def test_alias_method_chain_preserves_public_method_status
+#     FooClassWithBarMethod.class_eval do
+#       def duck; 'duck' end
+#       include BarMethodAliaser
+#       public :duck
+#       alias_method_chain :duck, :orange
+#     end
+#
+#     assert_equal 'duck_with_orange', @instance.duck
+#     assert FooClassWithBarMethod.public_method_defined?(:duck)
+#   end
+# end