activesupport 3.1.0 → 5.0.0

data/lib/active_support/duration/iso8601_parser.rb

@@ -0,0 +1,122 @@
+require 'strscan'
+
+module ActiveSupport
+  class Duration
+    # Parses a string formatted according to ISO 8601 Duration into the hash.
+    #
+    # See {ISO 8601}[http://en.wikipedia.org/wiki/ISO_8601#Durations] for more information.
+    #
+    # This parser allows negative parts to be present in pattern.
+    class ISO8601Parser # :nodoc:
+      class ParsingError < ::ArgumentError; end
+
+      PERIOD_OR_COMMA = /\.|,/
+      PERIOD = '.'.freeze
+      COMMA = ','.freeze
+
+      SIGN_MARKER = /\A\-|\+|/
+      DATE_MARKER = /P/
+      TIME_MARKER = /T/
+      DATE_COMPONENT = /(\-?\d+(?:[.,]\d+)?)(Y|M|D|W)/
+      TIME_COMPONENT = /(\-?\d+(?:[.,]\d+)?)(H|M|S)/
+
+      DATE_TO_PART = { 'Y' => :years, 'M' => :months, 'W' => :weeks, 'D' => :days }
+      TIME_TO_PART = { 'H' => :hours, 'M' => :minutes, 'S' => :seconds }
+
+      DATE_COMPONENTS = [:years, :months, :days]
+      TIME_COMPONENTS = [:hours, :minutes, :seconds]
+
+      attr_reader :parts, :scanner
+      attr_accessor :mode, :sign
+
+      def initialize(string)
+        @scanner = StringScanner.new(string)
+        @parts = {}
+        @mode = :start
+        @sign = 1
+      end
+
+      def parse!
+        while !finished?
+          case mode
+            when :start
+              if scan(SIGN_MARKER)
+                self.sign = (scanner.matched == '-') ? -1 : 1
+                self.mode = :sign
+              else
+                raise_parsing_error
+              end
+
+            when :sign
+              if scan(DATE_MARKER)
+                self.mode = :date
+              else
+                raise_parsing_error
+              end
+
+            when :date
+              if scan(TIME_MARKER)
+                self.mode = :time
+              elsif scan(DATE_COMPONENT)
+                parts[DATE_TO_PART[scanner[2]]] = number * sign
+              else
+                raise_parsing_error
+              end
+
+            when :time
+              if scan(TIME_COMPONENT)
+                parts[TIME_TO_PART[scanner[2]]] = number * sign
+              else
+                raise_parsing_error
+              end
+
+          end
+        end
+
+        validate!
+        parts
+      end
+
+      private
+
+      def finished?
+        scanner.eos?
+      end
+
+      # Parses number which can be a float with either comma or period.
+      def number
+        scanner[1] =~ PERIOD_OR_COMMA ? scanner[1].tr(COMMA, PERIOD).to_f : scanner[1].to_i
+      end
+
+      def scan(pattern)
+        scanner.scan(pattern)
+      end
+
+      def raise_parsing_error(reason = nil)
+        raise ParsingError, "Invalid ISO 8601 duration: #{scanner.string.inspect} #{reason}".strip
+      end
+
+      # Checks for various semantic errors as stated in ISO 8601 standard.
+      def validate!
+        raise_parsing_error('is empty duration') if parts.empty?
+
+        # Mixing any of Y, M, D with W is invalid.
+        if parts.key?(:weeks) && (parts.keys & DATE_COMPONENTS).any?
+          raise_parsing_error('mixing weeks with other date parts not allowed')
+        end
+
+        # Specifying an empty T part is invalid.
+        if mode == :time && (parts.keys & TIME_COMPONENTS).empty?
+          raise_parsing_error('time part marker is present but time part is empty')
+        end
+
+        fractions = parts.values.reject(&:zero?).select { |a| (a % 1) != 0 }
+        unless fractions.empty? || (fractions.size == 1 && fractions.last == @parts.values.reject(&:zero?).last)
+          raise_parsing_error '(only last part can be fractional)'
+        end
+
+        return true
+      end
+    end
+  end
+end

data/lib/active_support/duration/iso8601_serializer.rb

@@ -0,0 +1,51 @@
+require 'active_support/core_ext/object/blank'
+require 'active_support/core_ext/hash/transform_values'
+
+module ActiveSupport
+  class Duration
+    # Serializes duration to string according to ISO 8601 Duration format.
+    class ISO8601Serializer
+      def initialize(duration, precision: nil)
+        @duration = duration
+        @precision = precision
+      end
+
+      # Builds and returns output string.
+      def serialize
+        output = 'P'
+        parts, sign = normalize
+        output << "#{parts[:years]}Y"   if parts.key?(:years)
+        output << "#{parts[:months]}M"  if parts.key?(:months)
+        output << "#{parts[:weeks]}W"   if parts.key?(:weeks)
+        output << "#{parts[:days]}D"    if parts.key?(:days)
+        time = ''
+        time << "#{parts[:hours]}H"     if parts.key?(:hours)
+        time << "#{parts[:minutes]}M"   if parts.key?(:minutes)
+        if parts.key?(:seconds)
+          time << "#{sprintf(@precision ? "%0.0#{@precision}f" : '%g', parts[:seconds])}S"
+        end
+        output << "T#{time}"  if time.present?
+        "#{sign}#{output}"
+      end
+
+      private
+
+        # Return pair of duration's parts and whole duration sign.
+        # Parts are summarized (as they can become repetitive due to addition, etc).
+        # Zero parts are removed as not significant.
+        # If all parts are negative it will negate all of them and return minus as a sign.
+        def normalize
+          parts = @duration.parts.each_with_object(Hash.new(0)) do |(k,v),p|
+            p[k] += v  unless v.zero?
+          end
+          # If all parts are negative - let's make a negative duration
+          sign = ''
+          if parts.values.all? { |v| v < 0 }
+            sign = '-'
+            parts.transform_values!(&:-@)
+          end
+          [parts, sign]
+        end
+    end
+  end
+end

data/lib/active_support/duration.rb

@@ -1,16 +1,16 @@
-require 'active_support/basic_object'
 require 'active_support/core_ext/array/conversions'
 require 'active_support/core_ext/object/acts_like'
 
 module ActiveSupport
   # Provides accurate date and time measurements using Date#advance and
   # Time#advance, respectively. It mainly supports the methods on Numeric.
-  # Example:
   #
-  #   1.month.ago       # equivalent to Time.now.advance(:months => -1)
-  class Duration < BasicObject
+  #   1.month.ago       # equivalent to Time.now.advance(months: -1)
+  class Duration
     attr_accessor :value, :parts
-    delegate :duplicable?, :to => :value # required when using ActiveSupport's BasicObject on 1.8
+
+    autoload :ISO8601Parser,     'active_support/duration/iso8601_parser'
+    autoload :ISO8601Serializer, 'active_support/duration/iso8601_serializer'
 
     def initialize(value, parts) #:nodoc:
       @value, @parts = value, parts
@@ -41,8 +41,12 @@ module ActiveSupport
     end
     alias :kind_of? :is_a?
 
-    # Returns true if <tt>other</tt> is also a Duration instance with the
-    # same <tt>value</tt>, or if <tt>other == value</tt>.
+    def instance_of?(klass) # :nodoc:
+      Duration == klass || value.instance_of?(klass)
+    end
+
+    # Returns +true+ if +other+ is also a Duration instance with the
+    # same +value+, or if <tt>other == value</tt>.
     def ==(other)
       if Duration === other
         other.value == value
@@ -51,6 +55,48 @@ module ActiveSupport
       end
     end
 
+    # Returns the amount of seconds a duration covers as a string.
+    # For more information check to_i method.
+    #
+    #   1.day.to_s # => "86400"
+    def to_s
+      @value.to_s
+    end
+
+    # Returns the number of seconds that this Duration represents.
+    #
+    #   1.minute.to_i   # => 60
+    #   1.hour.to_i     # => 3600
+    #   1.day.to_i      # => 86400
+    #
+    # Note that this conversion makes some assumptions about the
+    # duration of some periods, e.g. months are always 30 days
+    # and years are 365.25 days:
+    #
+    #   # equivalent to 30.days.to_i
+    #   1.month.to_i    # => 2592000
+    #
+    #   # equivalent to 365.25.days.to_i
+    #   1.year.to_i     # => 31557600
+    #
+    # In such cases, Ruby's core
+    # Date[http://ruby-doc.org/stdlib/libdoc/date/rdoc/Date.html] and
+    # Time[http://ruby-doc.org/stdlib/libdoc/time/rdoc/Time.html] should be used for precision
+    # date and time arithmetic.
+    def to_i
+      @value.to_i
+    end
+
+    # Returns +true+ if +other+ is also a Duration instance, which has the
+    # same parts as this one.
+    def eql?(other)
+      Duration === other && other.value.eql?(value)
+    end
+
+    def hash
+      @value.hash
+    end
+
     def self.===(other) #:nodoc:
       other.is_a?(Duration)
     rescue ::NoMethodError
@@ -72,19 +118,40 @@ module ActiveSupport
     alias :until :ago
 
     def inspect #:nodoc:
-      consolidated = parts.inject(::Hash.new(0)) { |h,part| h[part.first] += part.last; h }
-      parts = [:years, :months, :days, :minutes, :seconds].map do |length|
-        n = consolidated[length]
-        "#{n} #{n == 1 ? length.to_s.singularize : length.to_s}" if n.nonzero?
-      end.compact
-      parts = ["0 seconds"] if parts.empty?
-      parts.to_sentence(:locale => :en)
+      parts.
+        reduce(::Hash.new(0)) { |h,(l,r)| h[l] += r; h }.
+        sort_by {|unit,  _ | [:years, :months, :weeks, :days, :hours, :minutes, :seconds].index(unit)}.
+        map     {|unit, val| "#{val} #{val == 1 ? unit.to_s.chop : unit.to_s}"}.
+        to_sentence(locale: ::I18n.default_locale)
     end
 
     def as_json(options = nil) #:nodoc:
       to_i
     end
 
+    def respond_to_missing?(method, include_private=false) #:nodoc:
+      @value.respond_to?(method, include_private)
+    end
+
+    # Creates a new Duration from string formatted according to ISO 8601 Duration.
+    #
+    # See {ISO 8601}[http://en.wikipedia.org/wiki/ISO_8601#Durations] for more information.
+    # This method allows negative parts to be present in pattern.
+    # If invalid string is provided, it will raise +ActiveSupport::Duration::ISO8601Parser::ParsingError+.
+    def self.parse(iso8601duration)
+      parts = ISO8601Parser.new(iso8601duration).parse!
+      time  = ::Time.current
+      new(time.advance(parts) - time, parts)
+    end
+
+    # Build ISO 8601 Duration string for this duration.
+    # The +precision+ parameter can be used to limit seconds' precision of duration.
+    def iso8601(precision: nil)
+      ISO8601Serializer.new(self, precision: precision).serialize
+    end
+
+    delegate :<=>, to: :value
+
     protected
 
       def sum(sign, time = ::Time.current) #:nodoc:
@@ -92,6 +159,10 @@ module ActiveSupport
           if t.acts_like?(:time) || t.acts_like?(:date)
             if type == :seconds
               t.since(sign * number)
+            elsif type == :minutes
+              t.since(sign * number * 60)
+            elsif type == :hours
+              t.since(sign * number * 3600)
             else
               t.advance(type => sign * number)
             end

data/lib/active_support/evented_file_update_checker.rb

@@ -0,0 +1,194 @@
+require 'set'
+require 'pathname'
+require 'concurrent/atomic/atomic_boolean'
+
+module ActiveSupport
+  # Allows you to "listen" to changes in a file system.
+  # The evented file updater does not hit disk when checking for updates
+  # instead it uses platform specific file system events to trigger a change
+  # in state.
+  #
+  # The file checker takes an array of files to watch or a hash specifying directories
+  # and file extensions to watch. It also takes a block that is called when
+  # EventedFileUpdateChecker#execute is run or when EventedFileUpdateChecker#execute_if_updated
+  # is run and there have been changes to the file system.
+  #
+  # Note: Forking will cause the first call to `updated?` to return `true`.
+  #
+  # Example:
+  #
+  #     checker = EventedFileUpdateChecker.new(["/tmp/foo"], -> { puts "changed" })
+  #     checker.updated?
+  #     # => false
+  #     checker.execute_if_updated
+  #     # => nil
+  #
+  #     FileUtils.touch("/tmp/foo")
+  #
+  #     checker.updated?
+  #     # => true
+  #     checker.execute_if_updated
+  #     # => "changed"
+  #
+  class EventedFileUpdateChecker #:nodoc: all
+    def initialize(files, dirs = {}, &block)
+      @ph    = PathHelper.new
+      @files = files.map { |f| @ph.xpath(f) }.to_set
+
+      @dirs = {}
+      dirs.each do |dir, exts|
+        @dirs[@ph.xpath(dir)] = Array(exts).map { |ext| @ph.normalize_extension(ext) }
+      end
+
+      @block      = block
+      @updated    = Concurrent::AtomicBoolean.new(false)
+      @lcsp       = @ph.longest_common_subpath(@dirs.keys)
+      @pid        = Process.pid
+      @boot_mutex = Mutex.new
+
+      if (@dtw = directories_to_watch).any?
+        # Loading listen triggers warnings. These are originated by a legit
+        # usage of attr_* macros for private attributes, but adds a lot of noise
+        # to our test suite. Thus, we lazy load it and disable warnings locally.
+        silence_warnings do
+          begin
+            require 'listen'
+          rescue LoadError => e
+            raise LoadError, "Could not load the 'listen' gem. Add `gem 'listen'` to the development group of your Gemfile", e.backtrace
+          end
+        end
+      end
+      boot!
+    end
+
+    def updated?
+      @boot_mutex.synchronize do
+        if @pid != Process.pid
+          boot!
+          @pid = Process.pid
+          @updated.make_true
+        end
+      end
+      @updated.true?
+    end
+
+    def execute
+      @updated.make_false
+      @block.call
+    end
+
+    def execute_if_updated
+      if updated?
+        yield if block_given?
+        execute
+        true
+      end
+    end
+
+    private
+      def boot!
+        Listen.to(*@dtw, &method(:changed)).start
+      end
+
+      def changed(modified, added, removed)
+        unless updated?
+          @updated.make_true if (modified + added + removed).any? { |f| watching?(f) }
+        end
+      end
+
+      def watching?(file)
+        file = @ph.xpath(file)
+
+        if @files.member?(file)
+          true
+        elsif file.directory?
+          false
+        else
+          ext = @ph.normalize_extension(file.extname)
+
+          file.dirname.ascend do |dir|
+            if @dirs.fetch(dir, []).include?(ext)
+              break true
+            elsif dir == @lcsp || dir.root?
+              break false
+            end
+          end
+        end
+      end
+
+      def directories_to_watch
+        dtw = (@files + @dirs.keys).map { |f| @ph.existing_parent(f) }
+        dtw.compact!
+        dtw.uniq!
+
+        @ph.filter_out_descendants(dtw)
+      end
+
+    class PathHelper
+      def xpath(path)
+        Pathname.new(path).expand_path
+      end
+
+      def normalize_extension(ext)
+        ext.to_s.sub(/\A\./, '')
+      end
+
+      # Given a collection of Pathname objects returns the longest subpath
+      # common to all of them, or +nil+ if there is none.
+      def longest_common_subpath(paths)
+        return if paths.empty?
+
+        lcsp = Pathname.new(paths[0])
+
+        paths[1..-1].each do |path|
+          until ascendant_of?(lcsp, path)
+            if lcsp.root?
+              # If we get here a root directory is not an ascendant of path.
+              # This may happen if there are paths in different drives on
+              # Windows.
+              return
+            else
+              lcsp = lcsp.parent
+            end
+          end
+        end
+
+        lcsp
+      end
+
+      # Returns the deepest existing ascendant, which could be the argument itself.
+      def existing_parent(dir)
+        dir.ascend do |ascendant|
+          break ascendant if ascendant.directory?
+        end
+      end
+
+      # Filters out directories which are descendants of others in the collection (stable).
+      def filter_out_descendants(dirs)
+        return dirs if dirs.length < 2
+
+        dirs_sorted_by_nparts = dirs.sort_by { |dir| dir.each_filename.to_a.length }
+        descendants = []
+
+        until dirs_sorted_by_nparts.empty?
+          dir = dirs_sorted_by_nparts.shift
+
+          dirs_sorted_by_nparts.reject! do |possible_descendant|
+            ascendant_of?(dir, possible_descendant) && descendants << possible_descendant
+          end
+        end
+
+        # Array#- preserves order.
+        dirs - descendants
+      end
+
+      private
+
+        def ascendant_of?(base, other)
+          base != other && other.ascend do |ascendant|
+            break true if base == ascendant
+          end
+        end
+    end
+  end
+end

data/lib/active_support/execution_wrapper.rb

@@ -0,0 +1,117 @@
+require 'active_support/callbacks'
+
+module ActiveSupport
+  class ExecutionWrapper
+    include ActiveSupport::Callbacks
+
+    Null = Object.new # :nodoc:
+    def Null.complete! # :nodoc:
+    end
+
+    define_callbacks :run
+    define_callbacks :complete
+
+    def self.to_run(*args, &block)
+      set_callback(:run, *args, &block)
+    end
+
+    def self.to_complete(*args, &block)
+      set_callback(:complete, *args, &block)
+    end
+
+    # Register an object to be invoked during both the +run+ and
+    # +complete+ steps.
+    #
+    # +hook.complete+ will be passed the value returned from +hook.run+,
+    # and will only be invoked if +run+ has previously been called.
+    # (Mostly, this means it won't be invoked if an exception occurs in
+    # a preceding +to_run+ block; all ordinary +to_complete+ blocks are
+    # invoked in that situation.)
+    def self.register_hook(hook, outer: false)
+      if outer
+        run_args = [prepend: true]
+        complete_args = [:after]
+      else
+        run_args = complete_args = []
+      end
+
+      to_run(*run_args) do
+        hook_state[hook] = hook.run
+      end
+      to_complete(*complete_args) do
+        if hook_state.key?(hook)
+          hook.complete hook_state[hook]
+        end
+      end
+    end
+
+    # Run this execution.
+    #
+    # Returns an instance, whose +complete!+ method *must* be invoked
+    # after the work has been performed.
+    #
+    # Where possible, prefer +wrap+.
+    def self.run!
+      if active?
+        Null
+      else
+        new.tap do |instance|
+          success = nil
+          begin
+            instance.run!
+            success = true
+          ensure
+            instance.complete! unless success
+          end
+        end
+      end
+    end
+
+    # Perform the work in the supplied block as an execution.
+    def self.wrap
+      return yield if active?
+
+      instance = run!
+      begin
+        yield
+      ensure
+        instance.complete!
+      end
+    end
+
+    class << self # :nodoc:
+      attr_accessor :active
+    end
+
+    def self.inherited(other) # :nodoc:
+      super
+      other.active = Concurrent::Hash.new
+    end
+
+    self.active = Concurrent::Hash.new
+
+    def self.active? # :nodoc:
+      @active[Thread.current]
+    end
+
+    def run! # :nodoc:
+      self.class.active[Thread.current] = true
+      run_callbacks(:run)
+    end
+
+    # Complete this in-flight execution. This method *must* be called
+    # exactly once on the result of any call to +run!+.
+    #
+    # Where possible, prefer +wrap+.
+    def complete!
+      run_callbacks(:complete)
+    ensure
+      self.class.active.delete Thread.current
+    end
+
+    private
+      def hook_state
+        @_hook_state ||= {}
+      end
+  end
+end

data/lib/active_support/executor.rb

@@ -0,0 +1,6 @@
+require 'active_support/execution_wrapper'
+
+module ActiveSupport
+  class Executor < ExecutionWrapper
+  end
+end