opal-activesupport 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 68c3aa1ca269d78c62c238b7d32662a999ab0078
-  data.tar.gz: 5d55aed5af016912fdaabf71ac1a9470a153e01c
+  metadata.gz: 87d2b460105407cc966e27d833b627f9f35922e1
+  data.tar.gz: 5c55b9cc4c9093242d4944dcf1d414f1f5b9c6a9
 SHA512:
-  metadata.gz: c17e86c15b2d703f89eb8a6ef63719fff43ecaf245917a4b7ed6327e4253c4511004466228b9368b5730d9126c1406adcabdf57c6a5fa851d210f0e0983f7f73
-  data.tar.gz: f5f730351e43750e5a06747bbb2528776fe6cbf488eec25dbadeae2d309eb83a0b9fd5f4dc4012b2b91bdf797d60013dceaac09033a7c64c44b148adb8a729c8
+  metadata.gz: 95d565c00c6a4628ed6baa96cfc735525b76dae8fe3ca8eb985479c936dec6213f1105dd6831ee4bfeea45f08251f16c3c682f13df0d9f32f01031d33abc32c7
+  data.tar.gz: 6b4f61e61dd0ef07188ea84f940dd781144dc64e5965e035be4676d33aea6c4f5c5e95a8cb77b67f6f4f7e1796ae3e93f4633331e606b1a965154a94f92cb960

data/lib/opal/activesupport/version.rb

@@ -1,5 +1,5 @@
 module Opal
   module Activesupport
-    VERSION = '0.1.0'
+    VERSION = '0.2.0'
   end
 end

data/opal/active_support/core_ext.rb

@@ -1,5 +1,10 @@
+require 'active_support/core_ext/array'
+require 'active_support/core_ext/class'
 require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/hash'
 require 'active_support/core_ext/integer'
+require 'active_support/core_ext/kernel'
+require 'active_support/core_ext/module'
 require 'active_support/core_ext/numeric'
 require 'active_support/core_ext/object'
 require 'active_support/core_ext/string'

data/opal/active_support/core_ext/array.rb

@@ -0,0 +1 @@
+require 'active_support/core_ext/array/extract_options'

data/opal/active_support/core_ext/array/extract_options.rb

@@ -0,0 +1,29 @@
+class Hash
+  # By default, only instances of Hash itself are extractable.
+  # Subclasses of Hash may implement this method and return
+  # true to declare themselves as extractable. If a Hash
+  # is extractable, Array#extract_options! pops it from
+  # the Array when it is the last element of the Array.
+  def extractable_options?
+    instance_of?(Hash)
+  end
+end
+
+class Array
+  # Extracts options from a set of arguments. Removes and returns the last
+  # element in the array if it's a hash, otherwise returns a blank hash.
+  #
+  #   def options(*args)
+  #     args.extract_options!
+  #   end
+  #
+  #   options(1, 2)        # => {}
+  #   options(1, 2, a: :b) # => {:a=>:b}
+  def extract_options!
+    if last.is_a?(Hash) && last.extractable_options?
+      pop
+    else
+      {}
+    end
+  end
+end

data/opal/active_support/core_ext/class.rb

@@ -0,0 +1 @@
+require 'active_support/core_ext/class/attribute'

data/opal/active_support/core_ext/class/attribute.rb

@@ -0,0 +1,129 @@
+require 'active_support/core_ext/kernel/singleton_class'
+require 'active_support/core_ext/module/remove_method'
+require 'active_support/core_ext/array/extract_options'
+
+class Class
+  # Declare a class-level attribute whose value is inheritable by subclasses.
+  # Subclasses can change their own value and it will not impact parent class.
+  #
+  #   class Base
+  #     class_attribute :setting
+  #   end
+  #
+  #   class Subclass < Base
+  #   end
+  #
+  #   Base.setting = true
+  #   Subclass.setting            # => true
+  #   Subclass.setting = false
+  #   Subclass.setting            # => false
+  #   Base.setting                # => true
+  #
+  # In the above case as long as Subclass does not assign a value to setting
+  # by performing <tt>Subclass.setting = _something_ </tt>, <tt>Subclass.setting</tt>
+  # would read value assigned to parent class. Once Subclass assigns a value then
+  # the value assigned by Subclass would be returned.
+  #
+  # This matches normal Ruby method inheritance: think of writing an attribute
+  # on a subclass as overriding the reader method. However, you need to be aware
+  # when using +class_attribute+ with mutable structures as +Array+ or +Hash+.
+  # In such cases, you don't want to do changes in places but use setters:
+  #
+  #   Base.setting = []
+  #   Base.setting                # => []
+  #   Subclass.setting            # => []
+  #
+  #   # Appending in child changes both parent and child because it is the same object:
+  #   Subclass.setting << :foo
+  #   Base.setting               # => [:foo]
+  #   Subclass.setting           # => [:foo]
+  #
+  #   # Use setters to not propagate changes:
+  #   Base.setting = []
+  #   Subclass.setting += [:foo]
+  #   Base.setting               # => []
+  #   Subclass.setting           # => [:foo]
+  #
+  # For convenience, an instance predicate method is defined as well.
+  # To skip it, pass <tt>instance_predicate: false</tt>.
+  #
+  #   Subclass.setting?       # => false
+  #
+  # Instances may overwrite the class value in the same way:
+  #
+  #   Base.setting = true
+  #   object = Base.new
+  #   object.setting          # => true
+  #   object.setting = false
+  #   object.setting          # => false
+  #   Base.setting            # => true
+  #
+  # To opt out of the instance reader method, pass <tt>instance_reader: false</tt>.
+  #
+  #   object.setting          # => NoMethodError
+  #   object.setting?         # => NoMethodError
+  #
+  # To opt out of the instance writer method, pass <tt>instance_writer: false</tt>.
+  #
+  #   object.setting = false  # => NoMethodError
+  #
+  # To opt out of both instance methods, pass <tt>instance_accessor: false</tt>.
+  def class_attribute(*attrs)
+    options = attrs.extract_options!
+    instance_reader = options.fetch(:instance_accessor, true) && options.fetch(:instance_reader, true)
+    instance_writer = options.fetch(:instance_accessor, true) && options.fetch(:instance_writer, true)
+    instance_predicate = options.fetch(:instance_predicate, true)
+
+    attrs.each do |name|
+      define_singleton_method(name) { nil }
+      define_singleton_method("#{name}?") { !!public_send(name) } if instance_predicate
+
+      ivar = "@#{name}"
+
+      define_singleton_method("#{name}=") do |val|
+        singleton_class.class_eval do
+          remove_possible_method(name)
+          define_method(name) { val }
+        end
+
+        if singleton_class?
+          class_eval do
+            remove_possible_method(name)
+            define_method(name) do
+              if instance_variable_defined? ivar
+                instance_variable_get ivar
+              else
+                singleton_class.send name
+              end
+            end
+          end
+        end
+        val
+      end
+
+      if instance_reader
+        remove_possible_method name
+        define_method(name) do
+          if instance_variable_defined?(ivar)
+            instance_variable_get ivar
+          else
+            self.class.public_send name
+          end
+        end
+        define_method("#{name}?") { !!public_send(name) } if instance_predicate
+      end
+
+      attr_writer name if instance_writer
+    end
+  end
+
+  private
+
+  unless respond_to?(:singleton_class?)
+    def singleton_class?
+      # Opal doesn't place singleton at ancestors.first. Returning true here
+      # seems to work in Opal anyway.
+      true || ancestors.first != self
+    end
+  end
+end

data/opal/active_support/core_ext/hash.rb

@@ -0,0 +1 @@
+require 'active_support/core_ext/hash/indifferent_access'

data/opal/active_support/core_ext/hash/indifferent_access.rb

@@ -0,0 +1,23 @@
+require 'active_support/hash_with_indifferent_access'
+
+class Hash
+
+  # Returns an <tt>ActiveSupport::HashWithIndifferentAccess</tt> out of its receiver:
+  #
+  #   { a: 1 }.with_indifferent_access['a'] # => 1
+  def with_indifferent_access
+    ActiveSupport::HashWithIndifferentAccess.new_from_hash_copying_default(self)
+  end
+
+  # Called when object is nested under an object that receives
+  # #with_indifferent_access. This method will be called on the current object
+  # by the enclosing object and is aliased to #with_indifferent_access by
+  # default. Subclasses of Hash may overwrite this method to return +self+ if
+  # converting to an <tt>ActiveSupport::HashWithIndifferentAccess</tt> would not be
+  # desirable.
+  #
+  #   b = { b: 1 }
+  #   { a: b }.with_indifferent_access['a'] # calls b.nested_under_indifferent_access
+  #   # => {"b"=>1}
+  alias nested_under_indifferent_access with_indifferent_access
+end

data/opal/active_support/core_ext/kernel.rb

@@ -0,0 +1 @@
+require 'active_support/core_ext/kernel/singleton_class'

data/opal/active_support/core_ext/kernel/singleton_class.rb

@@ -0,0 +1,6 @@
+module Kernel
+  # class_eval on an object acts like singleton_class.class_eval.
+  def class_eval(*args, &block)
+    singleton_class.class_eval(*args, &block)
+  end
+end

data/opal/active_support/core_ext/module.rb

@@ -0,0 +1 @@
+require 'active_support/core_ext/module/remove_method'

data/opal/active_support/core_ext/module/remove_method.rb

@@ -0,0 +1,15 @@
+class Module
+  # Removes the named method, if it exists.
+  def remove_possible_method(method)
+    if method_defined?(method) || private_method_defined?(method)
+      undef_method(method)
+    end
+  end
+
+  # Replaces the existing method definition, if there is one, with the passed
+  # block as its body.
+  def redefine_method(method, &block)
+    remove_possible_method(method)
+    define_method(method, &block)
+  end
+end

data/opal/active_support/core_ext/object.rb

@@ -1 +1,2 @@
 require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/object/try'

data/opal/active_support/core_ext/object/try.rb

@@ -0,0 +1,100 @@
+class Object
+  # Invokes the public method whose name goes as first argument just like
+  # +public_send+ does, except that if the receiver does not respond to it the
+  # call returns +nil+ rather than raising an exception.
+  #
+  # This method is defined to be able to write
+  #
+  #   @person.try(:name)
+  #
+  # instead of
+  #
+  #   @person.name if @person
+  #
+  # +try+ calls can be chained:
+  #
+  #   @person.try(:spouse).try(:name)
+  #
+  # instead of
+  #
+  #   @person.spouse.name if @person && @person.spouse
+  #
+  # +try+ will also return +nil+ if the receiver does not respond to the method:
+  #
+  #   @person.try(:non_existing_method) #=> nil
+  #
+  # instead of
+  #
+  #   @person.non_existing_method if @person.respond_to?(:non_existing_method) #=> nil
+  #
+  # +try+ returns +nil+ when called on +nil+ regardless of whether it responds
+  # to the method:
+  #
+  #   nil.try(:to_i) # => nil, rather than 0
+  #
+  # Arguments and blocks are forwarded to the method if invoked:
+  #
+  #   @posts.try(:each_slice, 2) do |a, b|
+  #     ...
+  #   end
+  #
+  # The number of arguments in the signature must match. If the object responds
+  # to the method the call is attempted and +ArgumentError+ is still raised
+  # in case of argument mismatch.
+  #
+  # If +try+ is called without arguments it yields the receiver to a given
+  # block unless it is +nil+:
+  #
+  #   @person.try do |p|
+  #     ...
+  #   end
+  #
+  # You can also call try with a block without accepting an argument, and the block
+  # will be instance_eval'ed instead:
+  #
+  #   @person.try { upcase.truncate(50) }
+  #
+  # Please also note that +try+ is defined on +Object+. Therefore, it won't work
+  # with instances of classes that do not have +Object+ among their ancestors,
+  # like direct subclasses of +BasicObject+. For example, using +try+ with
+  # +SimpleDelegator+ will delegate +try+ to the target instead of calling it on
+  # the delegator itself.
+  def try(*a, &b)
+    try!(*a, &b) if a.empty? || respond_to?(a.first)
+  end
+
+  # Same as #try, but will raise a NoMethodError exception if the receiver is not +nil+ and
+  # does not implement the tried method.
+  
+  def try!(*a, &b)
+    if a.empty? && block_given?
+      if b.arity.zero?
+        instance_eval(&b)
+      else
+        yield self
+      end
+    else
+      public_send(*a, &b)
+    end
+  end
+end
+
+class NilClass
+  # Calling +try+ on +nil+ always returns +nil+.
+  # It becomes especially helpful when navigating through associations that may return +nil+.
+  #
+  #   nil.try(:name) # => nil
+  #
+  # Without +try+
+  #   @person && @person.children.any? && @person.children.first.name
+  #
+  # With +try+
+  #   @person.try(:children).try(:first).try(:name)
+  def try(*args)
+    nil
+  end
+
+  def try!(*args)
+    nil
+  end
+end

data/opal/active_support/core_ext/string.rb

@@ -1,3 +1,5 @@
+require 'active_support/core_ext/string/inflections'
+
 class String
   def parameterize
     self.downcase.strip.gsub(/\W+/, '-')

data/opal/active_support/core_ext/string/inflections.rb

@@ -1,3 +1,5 @@
+require 'active_support/inflector'
+
 class String
   def pluralize
     ActiveSupport::Inflector.pluralize(self)
@@ -6,4 +8,8 @@ class String
   def singularize
     ActiveSupport::Inflector.singularize(self)
   end
+
+  def constantize
+    ActiveSupport::Inflector.constantize(self)
+  end
 end

data/opal/active_support/hash_with_indifferent_access.rb

@@ -0,0 +1,34 @@
+module ActiveSupport
+  class HashWithIndifferentAccess < Hash
+    # Returns +true+ so that <tt>Array#extract_options!</tt> finds members of
+    # this class.
+    def extractable_options?
+      true
+    end
+
+    def with_indifferent_access
+      dup
+    end
+
+    def nested_under_indifferent_access
+      self
+    end
+
+    def initialize(constructor = {})
+      if constructor.respond_to?(:to_hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def self.new_from_hash_copying_default(hash)
+      hash = hash.to_hash
+      new(hash).tap do |new_hash|
+        new_hash.default = hash.default
+        new_hash.default_proc = hash.default_proc if hash.default_proc
+      end
+    end
+  end
+end

data/opal/active_support/inflector/inflections.rb

@@ -1,3 +1,5 @@
+require 'set'
+
 module ActiveSupport
   module Inflector
     extend self
@@ -10,6 +12,37 @@ module ActiveSupport
       end
     end
 
+    def constantize(camel_cased_word)
+      names = camel_cased_word.split('::')
+
+      # Trigger a built-in NameError exception including the ill-formed constant in the message.
+      Object.const_get(camel_cased_word) if names.empty?
+
+      # Remove the first blank element in case of '::ClassName' notation.
+      names.shift if names.size > 1 && names.first.empty?
+
+      names.inject(Object) do |constant, name|
+        if constant == Object
+          constant.const_get(name)
+        else
+          candidate = constant.const_get(name)
+          next candidate if constant.const_defined?(name, false)
+          next candidate unless Object.const_defined?(name)
+
+          # Go down the ancestors to check if it is owned directly. The check
+          # stops when we reach Object or the end of ancestors tree.
+          constant = constant.ancestors.inject do |const, ancestor|
+            break const    if ancestor == Object
+            break ancestor if ancestor.const_defined?(name, false)
+            const
+          end
+
+          # owner is in Object, so raise
+          constant.const_get(name, false)
+        end
+      end
+    end
+
     def pluralize(word)
       apply_inflections(word, inflections.plurals)
     end

data/spec/core_ext/array/extract_options_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+# require 'abstract_unit'
+# require 'active_support/core_ext/array'
+# require 'active_support/core_ext/hash'
+
+class HashSubclass < Hash
+end
+
+class ExtractableHashSubclass < Hash
+  def extractable_options?
+    true
+  end
+end
+
+describe Array do
+  describe '#extract_options!' do
+    it 'extracts options' do
+      assert_equal({}, [].extract_options!)
+      assert_equal({}, [1].extract_options!)
+      assert_equal({ a: :b }, [{ a: :b }].extract_options!)
+      assert_equal({ a: :b }, [1, { a: :b }].extract_options!)
+    end
+
+    it 'doesnt extract hash subclasses' do
+      hash = HashSubclass.new
+      hash[:foo] = 1
+      array = [hash]
+      options = array.extract_options!
+      assert_equal({}, options)
+      assert_equal([hash], array)
+    end
+
+    it 'extracts extractable subclass' do
+      hash = ExtractableHashSubclass.new
+      hash[:foo] = 1
+      array = [hash]
+      options = array.extract_options!
+      assert_equal({ foo: 1 }, options)
+      assert_equal([], array)
+    end
+
+    it 'extracts hash with indifferent access' do
+      array = [{ foo: 1 }.with_indifferent_access]
+      options = array.extract_options!
+      assert_equal(1, options[:foo])
+    end
+  end
+end

data/spec/core_ext/class/attribute_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Class do
+  before do
+    @klass = Class.new { class_attribute :setting }
+    @sub = Class.new(@klass)
+  end
+
+  it 'defaults to nil' do
+    assert_nil @klass.setting
+    assert_nil @sub.setting
+  end
+
+  it 'inheritable' do
+    @klass.setting = 1
+    assert_equal 1, @sub.setting
+  end
+
+  it 'overridable' do
+    @sub.setting = 1
+    assert_nil @klass.setting
+
+    @klass.setting = 2
+    assert_equal 1, @sub.setting
+
+    assert_equal 1, Class.new(@sub).setting
+  end
+
+  it 'predicate method' do
+    assert_equal false, @klass.setting?
+    @klass.setting = 1
+    assert_equal true, @klass.setting?
+  end
+
+  it '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
+    object = @klass.new
+    object.setting = 1
+    assert_nil @klass.setting
+    @klass.setting = 2
+    assert_equal 1, object.setting
+  end
+
+  it 'instance predicate' do
+    object = @klass.new
+    assert_equal false, object.setting?
+    object.setting = 1
+    assert_equal true, object.setting?
+  end
+
+  it '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
+    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
+    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
+    object = @klass.new
+    object.singleton_class.setting = 'foo'
+    assert_equal 'foo', object.setting
+  end
+
+  it 'setter returns set value' do
+    val = @klass.send(:setting=, 1)
+    assert_equal 1, val
+  end
+end

data/spec/core_ext/kernel_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe 'Kernel' do
+  it 'adds class_eval to Object' do
+    o = Object.new
+    class << o; @x = 1; end
+    assert_equal 1, o.class_eval { @x }
+  end
+end

data/spec/core_ext/module/remove_method_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module RemoveMethodTests
+  class A
+    def do_something
+      return 1
+    end
+  end
+end
+
+describe Module do
+  describe '#remove_possible_method' do
+    it 'removes method from an object' do
+      RemoveMethodTests::A.class_eval{
+        self.remove_possible_method(:do_something)
+      }
+      assert !RemoveMethodTests::A.new.respond_to?(:do_something)
+    end
+  end
+
+  describe '#redefine_method' do
+    it 'redefines method in an object' do
+      RemoveMethodTests::A.class_eval{
+        self.redefine_method(:do_something) { return 100 }
+      }
+      assert_equal 100, RemoveMethodTests::A.new.do_something
+    end
+  end
+end

data/spec/core_ext/object/try_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe Object do
+  describe '#try' do
+    before do
+      @string = "Hello"
+    end
+
+    it 'nonexisting method' do
+      method = :undefined_method
+      assert !@string.respond_to?(method)
+      assert_nil @string.try(method)
+    end
+
+    it 'nonexisting method with arguments' do
+      method = :undefined_method
+      assert !@string.respond_to?(method)
+      assert_nil @string.try(method, 'llo', 'y')
+    end
+
+    it 'nonexisting method bang' do
+      method = :undefined_method
+      assert !@string.respond_to?(method)
+      assert_raise(NoMethodError) { @string.try!(method) }
+    end
+
+    it 'nonexisting method with arguments bang' do
+      method = :undefined_method
+      assert !@string.respond_to?(method)
+      assert_raise(NoMethodError) { @string.try!(method, 'llo', 'y') }
+    end
+
+    it 'valid method' do
+      assert_equal 5, @string.try(:size)
+    end
+
+    it 'argument forwarding' do
+      assert_equal 'Hey', @string.try(:sub, 'llo', 'y')
+    end
+
+    it 'block forwarding' do
+      assert_equal 'Hey', @string.try(:sub, 'llo') { |match| 'y' }
+    end
+
+    it 'nil to type' do
+      assert_nil nil.try(:to_s)
+      assert_nil nil.try(:to_i)
+    end
+
+    it 'false try' do
+      assert_equal 'false', false.try(:to_s)
+    end
+
+    it 'try only block' do
+      assert_equal @string.reverse, @string.try { |s| s.reverse }
+    end
+
+    it 'try only block bang' do
+      assert_equal @string.reverse, @string.try! { |s| s.reverse }
+    end
+
+    it 'try only block nil' do
+      ran = false
+      nil.try { ran = true }
+      assert_equal false, ran
+    end
+
+    it 'try with instance eval block' do
+      assert_equal @string.reverse, @string.try { reverse }
+    end
+
+    it 'try with instance eval block bang' do
+      assert_equal @string.reverse, @string.try! { reverse }
+    end
+
+    it 'try with private method bang' do
+      klass = Class.new do
+        private
+
+        def private_method
+          'private method'
+        end
+      end
+
+      # Opal doesn't currently support private methods
+      # assert_raise(NoMethodError) { klass.new.try!(:private_method) }
+    end
+
+    it 'try with private method' do
+      klass = Class.new do
+        private
+
+        def private_method
+          'private method'
+        end
+      end
+
+      # Opal doesn't currently support private methods
+      # assert_nil klass.new.try(:private_method)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -3,8 +3,20 @@ require 'opal-activesupport'
 require 'active_support/inflector'
 
 module TestUnitHelpers
+  def assert actual
+    expect(actual).to be_truthy
+  end
+
+  def assert_nil actual
+    expect(actual).to be_nil
+  end
+
   def assert_equal actual, expected
-    actual.should == expected
+    expect(expected).to eq(actual)
+  end
+
+  def assert_raise error, &block
+    expect(&block).to raise_error(error)
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opal-activesupport
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Elia Schito
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-02-03 00:00:00.000000000 Z
+date: 2015-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: opal
@@ -76,24 +76,41 @@ files:
 - opal-activesupport.gemspec
 - opal/active_support.rb
 - opal/active_support/core_ext.rb
+- opal/active_support/core_ext/array.rb
+- opal/active_support/core_ext/array/extract_options.rb
+- opal/active_support/core_ext/class.rb
+- opal/active_support/core_ext/class/attribute.rb
 - opal/active_support/core_ext/enumerable.rb
+- opal/active_support/core_ext/hash.rb
+- opal/active_support/core_ext/hash/indifferent_access.rb
 - opal/active_support/core_ext/integer.rb
 - opal/active_support/core_ext/integer/time.rb
+- opal/active_support/core_ext/kernel.rb
+- opal/active_support/core_ext/kernel/singleton_class.rb
+- opal/active_support/core_ext/module.rb
+- opal/active_support/core_ext/module/remove_method.rb
 - opal/active_support/core_ext/numeric.rb
 - opal/active_support/core_ext/numeric/calculations.rb
 - opal/active_support/core_ext/numeric/time.rb
 - opal/active_support/core_ext/object.rb
 - opal/active_support/core_ext/object/blank.rb
 - opal/active_support/core_ext/object/json.rb
+- opal/active_support/core_ext/object/try.rb
 - opal/active_support/core_ext/string.rb
 - opal/active_support/core_ext/string/inflections.rb
+- opal/active_support/hash_with_indifferent_access.rb
 - opal/active_support/inflections.rb
 - opal/active_support/inflector.rb
 - opal/active_support/inflector/inflections.rb
 - opal/active_support/time.rb
 - opal/opal-activesupport.rb
+- spec/core_ext/array/extract_options_spec.rb
+- spec/core_ext/class/attribute_spec.rb
+- spec/core_ext/kernel_spec.rb
+- spec/core_ext/module/remove_method_spec.rb
 - spec/core_ext/numeric_spec.rb
 - spec/core_ext/object/blank_spec.rb
+- spec/core_ext/object/try_spec.rb
 - spec/core_ext/string_spec.rb
 - spec/empty_bool.rb
 - spec/inflector_test_cases.rb
@@ -122,15 +139,19 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.4.5.1
 signing_key: 
 specification_version: 4
 summary: The port of the glorious ActiveSupport for Opal
 test_files:
+- spec/core_ext/array/extract_options_spec.rb
+- spec/core_ext/class/attribute_spec.rb
+- spec/core_ext/kernel_spec.rb
+- spec/core_ext/module/remove_method_spec.rb
 - spec/core_ext/numeric_spec.rb
 - spec/core_ext/object/blank_spec.rb
+- spec/core_ext/object/try_spec.rb
 - spec/core_ext/string_spec.rb
 - spec/empty_bool.rb
 - spec/inflector_test_cases.rb
 - spec/spec_helper.rb
-has_rdoc: