lazy_record 0.1.0

data/vendor/bundle/gems/activesupport-5.0.2/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/vendor/bundle/gems/activesupport-5.0.2/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/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/execution_wrapper.rb

@@ -0,0 +1,126 @@
+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
+
+    class RunHook < Struct.new(:hook) # :nodoc:
+      def before(target)
+        hook_state = target.send(:hook_state)
+        hook_state[hook] = hook.run
+      end
+    end
+
+    class CompleteHook < Struct.new(:hook) # :nodoc:
+      def before(target)
+        hook_state = target.send(:hook_state)
+        if hook_state.key?(hook)
+          hook.complete hook_state[hook]
+        end
+      end
+      alias after before
+    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
+        to_run RunHook.new(hook), prepend: true
+        to_complete :after, CompleteHook.new(hook)
+      else
+        to_run RunHook.new(hook)
+        to_complete CompleteHook.new(hook)
+      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/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/executor.rb

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

data/vendor/bundle/gems/activesupport-5.0.2/lib/active_support/file_update_checker.rb

@@ -0,0 +1,157 @@
+require 'active_support/core_ext/time/calculations'
+
+module ActiveSupport
+  # FileUpdateChecker specifies the API used by Rails to watch files
+  # and control reloading. The API depends on four methods:
+  #
+  # * +initialize+ which expects two parameters and one block as
+  #   described below.
+  #
+  # * +updated?+ which returns a boolean if there were updates in
+  #   the filesystem or not.
+  #
+  # * +execute+ which executes the given block on initialization
+  #   and updates the latest watched files and timestamp.
+  #
+  # * +execute_if_updated+ which just executes the block if it was updated.
+  #
+  # After initialization, a call to +execute_if_updated+ must execute
+  # the block only if there was really a change in the filesystem.
+  #
+  # This class is used by Rails to reload the I18n framework whenever
+  # they are changed upon a new request.
+  #
+  #   i18n_reloader = ActiveSupport::FileUpdateChecker.new(paths) do
+  #     I18n.reload!
+  #   end
+  #
+  #   ActiveSupport::Reloader.to_prepare do
+  #     i18n_reloader.execute_if_updated
+  #   end
+  class FileUpdateChecker
+    # It accepts two parameters on initialization. The first is an array
+    # of files and the second is an optional hash of directories. The hash must
+    # have directories as keys and the value is an array of extensions to be
+    # watched under that directory.
+    #
+    # This method must also receive a block that will be called once a path
+    # changes. The array of files and list of directories cannot be changed
+    # after FileUpdateChecker has been initialized.
+    def initialize(files, dirs = {}, &block)
+      @files = files.freeze
+      @glob  = compile_glob(dirs)
+      @block = block
+
+      @watched    = nil
+      @updated_at = nil
+
+      @last_watched   = watched
+      @last_update_at = updated_at(@last_watched)
+    end
+
+    # Check if any of the entries were updated. If so, the watched and/or
+    # updated_at values are cached until the block is executed via +execute+
+    # or +execute_if_updated+.
+    def updated?
+      current_watched = watched
+      if @last_watched.size != current_watched.size
+        @watched = current_watched
+        true
+      else
+        current_updated_at = updated_at(current_watched)
+        if @last_update_at < current_updated_at
+          @watched    = current_watched
+          @updated_at = current_updated_at
+          true
+        else
+          false
+        end
+      end
+    end
+
+    # Executes the given block and updates the latest watched files and
+    # timestamp.
+    def execute
+      @last_watched   = watched
+      @last_update_at = updated_at(@last_watched)
+      @block.call
+    ensure
+      @watched = nil
+      @updated_at = nil
+    end
+
+    # Execute the block given if updated.
+    def execute_if_updated
+      if updated?
+        yield if block_given?
+        execute
+        true
+      else
+        false
+      end
+    end
+
+    private
+
+    def watched
+      @watched || begin
+        all = @files.select { |f| File.exist?(f) }
+        all.concat(Dir[@glob]) if @glob
+        all
+      end
+    end
+
+    def updated_at(paths)
+      @updated_at || max_mtime(paths) || Time.at(0)
+    end
+
+    # This method returns the maximum mtime of the files in +paths+, or +nil+
+    # if the array is empty.
+    #
+    # Files with a mtime in the future are ignored. Such abnormal situation
+    # can happen for example if the user changes the clock by hand. It is
+    # healthy to consider this edge case because with mtimes in the future
+    # reloading is not triggered.
+    def max_mtime(paths)
+      time_now = Time.now
+      max_mtime = nil
+
+      # Time comparisons are performed with #compare_without_coercion because
+      # AS redefines these operators in a way that is much slower and does not
+      # bring any benefit in this particular code.
+      #
+      # Read t1.compare_without_coercion(t2) < 0 as t1 < t2.
+      paths.each do |path|
+        mtime = File.mtime(path)
+
+        next if time_now.compare_without_coercion(mtime) < 0
+
+        if max_mtime.nil? || max_mtime.compare_without_coercion(mtime) < 0
+          max_mtime = mtime
+        end
+      end
+
+      max_mtime
+    end
+
+    def compile_glob(hash)
+      hash.freeze # Freeze so changes aren't accidentally pushed
+      return if hash.empty?
+
+      globs = hash.map do |key, value|
+        "#{escape(key)}/**/*#{compile_ext(value)}"
+      end
+      "{#{globs.join(",")}}"
+    end
+
+    def escape(key)
+      key.gsub(',','\,')
+    end
+
+    def compile_ext(array)
+      array = Array(array)
+      return if array.empty?
+      ".{#{array.join(",")}}"
+    end
+  end
+end