opal-activesupport 0.3.1 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab212ff0639ad0d73aa14079bee64d887be2a76cda925d7b06f714f0c6dbca83
-  data.tar.gz: 85681bc3a9c4baaf2e8ef296e7b78e0bed6c517e1d9799a86f446970dbb90a39
+  metadata.gz: 7b194f0cee109c7a300653dc94711e9a9ce0b2d5d99e83f6ef48c23b3e126c48
+  data.tar.gz: 32d323abd0065e8b6f3c577959403f27cc630e11c9ffa3e69991f1b7d6b6b30e
 SHA512:
-  metadata.gz: c95184d0f80dfd759498b94be051c527eec9bd918d72f37e3fbe493df5fc8c417ce4a5659afa0d55208d3bec0be85ec7210efce55715d4440f6763941d285a28
-  data.tar.gz: aa831820632011e8ff2f6879fc5a2d8073da35e96d2a904d73ffc9162089ad1ad2b1ddcef3e24ea5e2ac8fb80e28b8e2a6ef3b1c4540c50f5980632e7654e8b4
+  metadata.gz: 80fdb487f5bc4ccedd111843959084276649820c8f308871b54c005049589aa26c78b975674c2cecb44fbc627931d3852e5fe11696d4a2868e3f7657b8113b14
+  data.tar.gz: 1d08de6d0ae15c2f2c043f72e3941e8e9355f53c3e476c1947d21001ee273a9dd4563fd71dbdba51f91cb5442e6511b5191cd7fecd37d0b29e1688f1825e5d53

data/CHANGELOG.md

@@ -0,0 +1,47 @@
+### 0.3.2 - unreleased
+
+[Changes](https://github.com/opal/opal-activesupport/compare/v0.3.2...HEAD)
+
+### 0.3.2 - 2019-04-27
+
+[Changes](https://github.com/opal/opal-activesupport/compare/v0.3.1...v0.3.2)
+
+- Added `ActiveSupport::Concern` (#19).
+- Added `String#truncate` (#22).
+- Properly backported: (#21).
+    + `ActiveSupport::Inflector.pluralize` and `String#pluralize`
+    + `ActiveSupport::Inflector.singularize` and `String#singularize`
+    + `ActiveSupport::Inflector.constantize` and `String#constantize`
+    + `ActiveSupport::Inflector.safe_constantize` and `String#safe_constantize`
+    + `ActiveSupport::Inflector.camelize` and `String#camelize`
+    + `ActiveSupport::Inflector.titleize` and `String#titleize`
+    + `ActiveSupport::Inflector.underscore` and `String#underscore`
+    + `ActiveSupport::Inflector.dasherize` and `String#dasherize`
+    + `ActiveSupport::Inflector.demodulize` and `String#demodulize`
+    + `ActiveSupport::Inflector.deconstantize` and `String#deconstantize`
+    + `ActiveSupport::Inflector.tableize` and `String#tableize`
+    + `ActiveSupport::Inflector.classify` and `String#classify`
+    + `ActiveSupport::Inflector.humanize` and `String#humanize`
+    + `ActiveSupport::Inflector.upcase_first` and `String#upcase_first`
+    + `ActiveSupport::Inflector.foreign_key` and `String#foreign_key`
+
+### 0.3.1 - 2018-01-28
+
+[Changes](https://github.com/opal/opal-activesupport/compare/v0.3.0...v0.3.1)
+
+- Fix `Inflections.irregular`
+- Fix `Inflector.apply_inflections`
+- Fix `Inflector.inflections`
+- Fix `return` handling of x-string for Opal v0.11
+
+### 0.3.0 - 2015-12-23
+
+[Changes](https://github.com/opal/opal-activesupport/compare/v0.2.0...v0.3.0)
+
+### 0.2.0 - 2015-10-08
+
+[Changes](https://github.com/opal/opal-activesupport/compare/v0.1.0...v0.2.0)
+
+### 0.1.0 - 2015-02-03
+
+_the fogs of the past 🌫_

data/README.md

@@ -1,8 +1,11 @@
 # Opal: ActiveSupport
 
-_@dhh [6:44 PM - Oct 23, 2012](https://twitter.com/dhh/status/260783823254601728):_
+[![Build Status](https://travis-ci.org/opal/opal-activesupport.svg?branch=master)](https://travis-ci.org/opal/opal-activesupport)
+
 > @AstonJ But it's vanilla Ruby. It's not like you have ActiveSupport available, which somewhat defeats it for me.
 
+_[@dhh 6:44 PM - Oct 23, 2012](https://twitter.com/dhh/status/260783823254601728)_
+
 
 ## Installation
 

data/Rakefile

@@ -1,15 +1,31 @@
 require 'bundler'
 Bundler.require
+require 'bundler/gem_tasks'
 
-require 'opal/minitest/rake_task'
-# Opal::Minitest::RakeTask.new
 
 task :test do
+  require 'opal'
+  require 'opal/cli_runners'
+  require 'opal/minitest'
+
   Opal::Config.arity_check_enabled = true
-  files = Dir['test/**/*_test.rb'].map {|f| "-r #{f.chomp('.rb').sub(/^test\//, '')}"}
-  sh "bundle exec ruby -r opal/minitest -S opal -Dwarning -Itest -Iopal #{files.join(' ')} -e puts"
+  Opal::Config.dynamic_require_severity = :warning
+
+  Opal.append_path 'opal'
+  Opal.append_path 'test'
+
+  builder = Opal::Builder.new
+  builder.build 'opal'
+  builder.build 'opal/platform'
+  builder.build 'minitest'
+  Dir['test/**/*_test.rb'].map do |file|
+    builder.build file.sub(%r{^test/}, '')
+  end
+  builder.build_str 'Minitest.run', 'minitest-runner.rb'
+
+  runner_name = ENV['RUNNER'] || 'nodejs'
+  runner_class = Opal::CliRunners.const_get(runner_name.capitalize)
+  runner_class.new(output: $stdout).run(builder.to_s, [])
 end
 
 task default: :test
-
-require 'bundler/gem_tasks'

data/lib/opal/activesupport/version.rb

@@ -1,5 +1,5 @@
 module Opal
   module Activesupport
-    VERSION = '0.3.1'
+    VERSION = '0.3.2'
   end
 end

data/opal-activesupport.gemspec

@@ -22,5 +22,6 @@ Gem::Specification.new do |gem|
 
   gem.add_dependency 'opal', ['>= 0.5.0', '< 1.0.0']
   gem.add_development_dependency 'opal-minitest'
+  gem.add_development_dependency 'opal-sprockets'
   gem.add_development_dependency 'rake'
 end

data/opal/active_support/concern.rb

@@ -0,0 +1,152 @@
+module ActiveSupport
+  # A typical module looks like this:
+  #
+  #   module M
+  #     def self.included(base)
+  #       base.extend ClassMethods
+  #       base.class_eval do
+  #         scope :disabled, -> { where(disabled: true) }
+  #       end
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # By using <tt>ActiveSupport::Concern</tt> the above module could instead be
+  # written as:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module M
+  #     extend ActiveSupport::Concern
+  #
+  #     included do
+  #       scope :disabled, -> { where(disabled: true) }
+  #     end
+  #
+  #     class_methods do
+  #       ...
+  #     end
+  #   end
+  #
+  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module
+  # and a +Bar+ module which depends on the former, we would typically write the
+  # following:
+  #
+  #   module Foo
+  #     def self.included(base)
+  #       base.class_eval do
+  #         def self.method_injected_by_foo
+  #           ...
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Foo # We need to include this dependency for Bar
+  #     include Bar # Bar is the module that Host really needs
+  #   end
+  #
+  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We
+  # could try to hide these from +Host+ directly including +Foo+ in +Bar+:
+  #
+  #   module Bar
+  #     include Foo
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar
+  #   end
+  #
+  # Unfortunately this won't work, since when +Foo+ is included, its base
+  # is the +Bar+ module, not the +Host+ class. With ActiveSupport::Concern,
+  # module dependencies are properly resolved:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module Foo
+  #     extend ActiveSupport::Concern
+  #     included do
+  #       def self.method_injected_by_foo
+  #         ...
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     extend ActiveSupport::Concern
+  #     include Foo
+  #
+  #     included do
+  #       self.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar # It works, now Bar takes care of its dependencies
+  #   end
+  module Concern
+    class MultipleIncludedBlocks < StandardError #:nodoc:
+      # Opal 0.11 always passes an argument to Exception.exception
+      def initialize(_)
+        super "Cannot define multiple 'included' blocks for a Concern"
+      end
+    end
+
+    def self.extended(base) #:nodoc:
+      base.instance_variable_set(:@_dependencies, [])
+    end
+
+    def append_features(base)
+      if base.instance_variable_defined?(:@_dependencies)
+        base.instance_variable_get(:@_dependencies) << self
+        false
+      else
+        return false if base < self
+        @_dependencies.each { |dep| base.include(dep) }
+        super
+        base.extend const_get(:ClassMethods) if const_defined?(:ClassMethods)
+        # if instance_variable_defined?(:@_included_block)
+        #   base.class_eval(&@_included_block)
+        # end
+        if @_included_block
+          base.class_eval(&@_included_block)
+        end
+      end
+    end
+
+    def included(base = nil, &block)
+      if base.nil?
+        if instance_variable_defined?(:@_included_block)
+          raise MultipleIncludedBlocks
+        end
+
+        @_included_block = block
+      else
+        super
+      end
+    end
+
+    def class_methods(&class_methods_module_definition)
+      mod = if const_defined?(:ClassMethods, false)
+              const_get(:ClassMethods)
+            else
+              const_set(:ClassMethods, Module.new)
+            end
+
+      mod.module_eval(&class_methods_module_definition)
+    end
+  end
+end

data/opal/active_support/core_ext/string.rb

@@ -1,45 +1,8 @@
+require 'active_support/core_ext/string/filters'
 require 'active_support/core_ext/string/inflections'
 
 class String
   def parameterize
     self.downcase.strip.gsub(/\W+/, '-')
   end
-
-  def dasherize
-    result = `#{self}.replace(/[-_\s]+/g, '-')
-            .replace(/([A-Z\d]+)([A-Z][a-z])/g, '$1-$2')
-            .replace(/([a-z\d])([A-Z])/g, '$1-$2')
-            .toLowerCase()`
-    result
-  end
-
-  def demodulize
-    %x{
-      var idx = #{self}.lastIndexOf('::');
-
-      if (idx > -1) {
-        return #{self}.substr(idx + 2);
-      }
-
-      return #{self};
-    }
-  end
-
-  def underscore
-    result = `#{self}.replace(/[-\s]+/g, '_')
-            .replace(/([A-Z\d]+)([A-Z][a-z])/g, '$1_$2')
-            .replace(/([a-z\d])([A-Z])/g, '$1_$2')
-            .replace(/-/g, '_')
-            .toLowerCase()`
-    result
-  end
-
-  def camelize(first_letter = :upper)
-    result = `#{underscore}.replace(/(^|_)([^_]+)/g, function(match, pre, word, index) {
-      var capitalize = #{first_letter} === #{:upper} || index > 0;
-      return capitalize ? word.substr(0,1).toUpperCase()+word.substr(1) : word;
-    })`
-    result
-  end
-  alias_method :camelcase, :camelize
 end

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

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+class String
+  # Returns the string, first removing all whitespace on both ends of
+  # the string, and then changing remaining consecutive whitespace
+  # groups into one space each.
+  #
+  # Note that it handles both ASCII and Unicode whitespace.
+  #
+  #   %{ Multi-line
+  #      string }.squish                   # => "Multi-line string"
+  #   " foo   bar    \n   \t   boo".squish # => "foo bar boo"
+  # def squish
+  #   dup.squish!
+  # end
+
+  # Performs a destructive squish. See String#squish.
+  #   str = " foo   bar    \n   \t   boo"
+  #   str.squish!                         # => "foo bar boo"
+  #   str                                 # => "foo bar boo"
+  # def squish!
+  #   gsub!(/[[:space:]]+/, " ")
+  #   strip!
+  #   self
+  # end
+
+  # Returns a new string with all occurrences of the patterns removed.
+  #   str = "foo bar test"
+  #   str.remove(" test")                 # => "foo bar"
+  #   str.remove(" test", /bar/)          # => "foo "
+  #   str                                 # => "foo bar test"
+  # def remove(*patterns)
+  #   dup.remove!(*patterns)
+  # end
+
+  # Alters the string by removing all occurrences of the patterns.
+  #   str = "foo bar test"
+  #   str.remove!(" test", /bar/)         # => "foo "
+  #   str                                 # => "foo "
+  # def remove!(*patterns)
+  #   patterns.each do |pattern|
+  #     gsub! pattern, ""
+  #   end
+  #
+  #   self
+  # end
+
+  # Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
+  #
+  #   'Once upon a time in a world far far away'.truncate(27)
+  #   # => "Once upon a time in a wo..."
+  #
+  # Pass a string or regexp <tt>:separator</tt> to truncate +text+ at a natural break:
+  #
+  #   'Once upon a time in a world far far away'.truncate(27, separator: ' ')
+  #   # => "Once upon a time in a..."
+  #
+  #   'Once upon a time in a world far far away'.truncate(27, separator: /\s/)
+  #   # => "Once upon a time in a..."
+  #
+  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
+  # for a total length not exceeding <tt>length</tt>:
+  #
+  #   'And they found that many people were sleeping better.'.truncate(25, omission: '... (continued)')
+  #   # => "And they f... (continued)"
+  def truncate(truncate_at, options = {})
+    return dup unless length > truncate_at
+
+    omission = options[:omission] || "..."
+    length_with_room_for_omission = truncate_at - omission.length
+    stop = \
+      if options[:separator]
+                   rindex(options[:separator], length_with_room_for_omission) || length_with_room_for_omission
+      else
+        length_with_room_for_omission
+      end
+
+    "#{self[0, stop]}#{omission}"
+  end
+
+  # Truncates +text+ to at most <tt>bytesize</tt> bytes in length without
+  # breaking string encoding by splitting multibyte characters or breaking
+  # grapheme clusters ("perceptual characters") by truncating at combining
+  # characters.
+  #
+  #   >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".size
+  #   => 20
+  #   >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".bytesize
+  #   => 80
+  #   >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".truncate_bytes(20)
+  #   => "🔪🔪🔪🔪…"
+  #
+  # The truncated text ends with the <tt>:omission</tt> string, defaulting
+  # to "…", for a total length not exceeding <tt>bytesize</tt>.
+  # def truncate_bytes(truncate_at, omission: "…")
+  #   omission ||= ""
+  #
+  #   case
+  #   when bytesize <= truncate_at
+  #     dup
+  #   when omission.bytesize > truncate_at
+  #     raise ArgumentError, "Omission #{omission.inspect} is #{omission.bytesize}, larger than the truncation length of #{truncate_at} bytes"
+  #   when omission.bytesize == truncate_at
+  #     omission.dup
+  #   else
+  #     self.class.new.tap do |cut|
+  #       cut_at = truncate_at - omission.bytesize
+  #
+  #       scan(/\X/) do |grapheme|
+  #         if cut.bytesize + grapheme.bytesize <= cut_at
+  #           cut << grapheme
+  #         else
+  #           break
+  #         end
+  #       end
+  #
+  #       cut << omission
+  #     end
+  #   end
+  # end
+
+  # Truncates a given +text+ after a given number of words (<tt>words_count</tt>):
+  #
+  #   'Once upon a time in a world far far away'.truncate_words(4)
+  #   # => "Once upon a time..."
+  #
+  # Pass a string or regexp <tt>:separator</tt> to specify a different separator of words:
+  #
+  #   'Once<br>upon<br>a<br>time<br>in<br>a<br>world'.truncate_words(5, separator: '<br>')
+  #   # => "Once<br>upon<br>a<br>time<br>in..."
+  #
+  # The last characters will be replaced with the <tt>:omission</tt> string (defaults to "..."):
+  #
+  #   'And they found that many people were sleeping better.'.truncate_words(5, omission: '... (continued)')
+  #   # => "And they found that many... (continued)"
+  # def truncate_words(words_count, options = {})
+  #   sep = options[:separator] || /\s+/
+  #   sep = Regexp.escape(sep.to_s) unless Regexp === sep
+  #   if self =~ /\A((?>.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m
+  #     $1 + (options[:omission] || "...")
+  #   else
+  #     dup
+  #   end
+  # end
+end
+