hoodie 0.3.21 → 0.4.0

data/lib/hoodie/timers.rb

@@ -0,0 +1,355 @@
+
+require 'set'
+require 'hitimes'
+require 'forwardable'
+
+module Hoodie::Timers
+  # An individual timer set to fire a given proc at a given time. A timer is
+  # always connected to a Timer::Group but it would ONLY be in @group.timers
+  # if it also has a @handle specified. Otherwise it is either PAUSED or has
+  # been FIRED and is not recurring. You can manually enter this state by
+  # calling #cancel and resume normal operation by calling #reset.
+  class Timer
+    include Comparable
+    attr_reader :interval, :offset, :recurring
+
+    def initialize(group, interval, recurring = false, offset = nil, &block)
+      @group = group
+      @interval = interval
+      @recurring = recurring
+      @block = block
+      @offset = offset
+      @handle = nil
+
+      # If a start offset was supplied, use that, otherwise use the current
+      # timers offset.
+      reset(@offset || @group.current_offset)
+    end
+
+    def paused?
+      @group.paused_timers.include? self
+    end
+
+    def pause
+      return if paused?
+      @group.timers.delete self
+      @group.paused_timers.add self
+      @handle.cancel! if @handle
+      @handle = nil
+    end
+
+    def resume
+      return unless paused?
+      @group.paused_timers.delete self
+      # This will add us back to the group:
+      reset
+    end
+    alias_method :continue, :resume
+
+    # Extend this timer
+    def delay(seconds)
+      @handle.cancel! if @handle
+      @offset += seconds
+      @handle = @group.events.schedule(@offset, self)
+    end
+
+    # Cancel this timer. Do not call while paused.
+    def cancel
+      return unless @handle
+      @handle.cancel! if @handle
+      @handle = nil
+      # This timer is no longer valid:
+      @group.timers.delete self if @group
+    end
+
+    # Reset this timer. Do not call while paused.
+    def reset(offset = @group.current_offset)
+      # This logic allows us to minimise the interaction with @group.timers.
+      # A timer with a handle is always registered with the group.
+      if @handle
+        @handle.cancel!
+      else
+        @group.timers << self
+      end
+      @offset = Float(offset) + @interval
+      @handle = @group.events.schedule(@offset, self)
+    end
+
+    # Fire the block.
+    def fire(offset = @group.current_offset)
+      if recurring == :strict
+        # ... make the next interval strictly the last offset + the interval:
+        reset(@offset)
+      elsif recurring
+        reset(offset)
+      else
+        @offset = offset
+      end
+      @block.call(offset)
+      cancel unless recurring
+    end
+    alias_method :call, :fire
+
+    # Number of seconds until next fire / since last fire
+    def fires_in
+      @offset - @group.current_offset if @offset
+    end
+
+    # Inspect a timer
+    def inspect
+      str = "#<Timers::Timer:#{object_id.to_s(16)} "
+      if @offset
+        if fires_in >= 0
+          str << "fires in #{fires_in} seconds"
+        else
+          str << "fired #{fires_in.abs} seconds ago"
+        end
+        str << ", recurs every #{interval}" if recurring
+      else
+        str << 'dead'
+      end
+      str << '>'
+    end
+  end
+
+  # An exclusive, monotonic timeout class.
+  class Wait
+    def self.for(duration, &block)
+      if duration
+        timeout = new(duration)
+        timeout.while_time_remaining(&block)
+      else
+        loop do
+          yield(nil)
+        end
+      end
+    end
+
+    def initialize(duration)
+      @duration = duration
+      @remaining = true
+    end
+
+    attr_reader :duration
+    attr_reader :remaining
+
+    # Yields while time remains for work to be done:
+    def while_time_remaining(&_block)
+      @interval = Hitimes::Interval.new
+      @interval.start
+      while time_remaining?
+        yield @remaining
+      end
+    ensure
+      @interval.stop
+      @interval = nil
+    end
+
+    private #   P R O P R I E T À   P R I V A T A   Vietato L'accesso
+
+    def time_remaining?
+      @remaining = (@duration - @interval.duration)
+      @remaining > 0
+    end
+  end
+
+  class Group
+    include Enumerable
+    extend Forwardable
+    def_delegators :@timers, :each, :empty?
+
+    def initialize
+      @events = Events.new
+      @timers = Set.new
+      @paused_timers = Set.new
+      @interval = Hitimes::Interval.new
+      @interval.start
+    end
+
+    # Scheduled events:
+    attr_reader :events
+
+    # Active timers:
+    attr_reader :timers
+
+    # Paused timers:
+    attr_reader :paused_timers
+
+    # Call the given block after the given interval. The first argument will be
+    # the time at which the group was asked to fire timers for.
+    def after(interval, &block)
+      Timer.new(self, interval, false, &block)
+    end
+
+    # Call the given block periodically at the given interval. The first
+    # argument will be the time at which the group was asked to fire timers for.
+    def every(interval, recur = true, &block)
+      Timer.new(self, interval, recur, &block)
+    end
+
+    # Wait for the next timer and fire it. Can take a block, which should behave
+    # like sleep(n), except that n may be nil (sleep forever) or a negative
+    # number (fire immediately after return).
+    def wait(&_block)
+      if block_given?
+        yield wait_interval
+
+        while interval = wait_interval and interval > 0
+          yield interval
+        end
+      else
+        while interval = wait_interval and interval > 0
+          # We cannot assume that sleep will wait for the specified time, it might be +/- a bit.
+          sleep interval
+        end
+      end
+      fire
+    end
+
+    # Interval to wait until when the next timer will fire.
+    # - nil: no timers
+    # - -ve: timers expired already
+    # -   0: timers ready to fire
+    # - +ve: timers waiting to fire
+    def wait_interval(offset = current_offset)
+      if handle = @events.first
+        return handle.time - Float(offset)
+      end
+    end
+
+    # Fire all timers that are ready.
+    def fire(offset = current_offset)
+      @events.fire(offset)
+    end
+
+    # Pause all timers.
+    def pause
+      @timers.dup.each(&:pause)
+    end
+
+    # Resume all timers.
+    def resume
+      @paused_timers.dup.each(&:resume)
+    end
+    alias_method :continue, :resume
+
+    # Delay all timers.
+    def delay(seconds)
+      @timers.each do |timer|
+        timer.delay(seconds)
+      end
+    end
+
+    # Cancel all timers.
+    def cancel
+      @timers.dup.each(&:cancel)
+    end
+
+    # The group's current time.
+    def current_offset
+      @interval.to_f
+    end
+  end
+
+  # Maintains an ordered list of events, which can be cancelled.
+  class Events
+    # Represents a cancellable handle for a specific timer event.
+    class Handle
+      def initialize(time, callback)
+        @time = time
+        @callback = callback
+      end
+
+      # The absolute time that the handle should be fired at.
+      attr_reader :time
+
+      # Cancel this timer, O(1).
+      def cancel!
+        # The simplest way to keep track of cancelled status is to nullify the
+        # callback. This should also be optimal for garbage collection.
+        @callback = nil
+      end
+
+      # Has this timer been cancelled? Cancelled timer's don't fire.
+      def cancelled?
+        @callback.nil?
+      end
+
+      def >(other)
+        @time > other.to_f
+      end
+
+      def to_f
+        @time
+      end
+
+      # Fire the callback if not cancelled with the given time parameter.
+      def fire(time)
+        if @callback
+          @callback.call(time)
+        end
+      end
+    end
+
+    def initialize
+      # A sequence of handles, maintained in sorted order, future to present.
+      # @sequence.last is the next event to be fired.
+      @sequence = []
+    end
+
+    # Add an event at the given time.
+    def schedule(time, callback)
+      handle = Handle.new(time.to_f, callback)
+      index = bisect_left(@sequence, handle)
+      # Maintain sorted order, O(logN) insertion time.
+      @sequence.insert(index, handle)
+      handle
+    end
+
+    # Returns the first non-cancelled handle.
+    def first
+      while handle = @sequence.last
+        if handle.cancelled?
+          @sequence.pop
+        else
+          return handle
+        end
+      end
+    end
+
+    # Returns the number of pending (possibly cancelled) events.
+    def size
+      @sequence.size
+    end
+
+    # Fire all handles for which Handle#time is less than the given time.
+    def fire(time)
+      pop(time).reverse_each do |handle|
+        handle.fire(time)
+      end
+    end
+
+    private #   P R O P R I E T À   P R I V A T A   Vietato L'accesso
+
+    # Efficiently take k handles for which Handle#time is less than the given
+    # time.
+    def pop(time)
+      index = bisect_left(@sequence, time)
+      @sequence.pop(@sequence.size - index)
+    end
+
+    # Return the left-most index where to insert item e, in a list a, assuming
+    # a is sorted in descending order.
+    def bisect_left(a, e, l = 0, u = a.length)
+      while l < u
+        m = l + (u - l).div(2)
+        if a[m] > e
+          l = m + 1
+        else
+          u = m
+        end
+      end
+      l
+    end
+  end
+end

data/lib/hoodie/utils.rb

@@ -17,118 +17,249 @@
 # limitations under the License.
 #
 
-module Hoodie
-  # Returns an aligned_string of text relative to the size of the terminal
-  # window. If a line in the string exceeds the width of the terminal window
-  # the line will be chopped off at the whitespace chacter closest to the
-  # end of the line and prepended to the next line, keeping all indentation.
-  #
-  # The terminal size is detected by default, but custom line widths can
-  # passed. All strings will also be left aligned with 5 whitespace characters
-  # by default.
-  def self.align_text(text, console_cols = nil, preamble = 5)
-    unless console_cols
-      console_cols = terminal_dimensions[0]
 
-      # if unknown size we default to the typical unix default
-      console_cols = 80 if console_cols == 0
+require 'securerandom'
+require 'time'
+
+module Hoodie::Utils
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+  private_class_method :included
+
+  module ClassMethods
+    def callable(call_her)
+      call_her.respond_to?(:call) ? call_her : lambda { call_her }
     end
 
-    console_cols -= preamble
+    def camelize(underscored_word)
+      underscored_word.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }
+    end
 
-    # Return unaligned text if console window is too small
-    return text if console_cols <= 0
+    def classify(table_name)
+      camelize singularize(table_name.to_s.sub(/.*\./, ''))
+    end
 
-    # If console is 0 this implies unknown so we assume the common
-    # minimal unix configuration of 80 characters
-    console_cols = 80 if console_cols <= 0
+    def class_name
+      demodulize(self.class)
+    end
 
-    text = text.split("\n")
-    piece = ''
-    whitespace = 0
+    def caller_name
+      caller_locations(2, 1).first.label
+    end
 
-    text.each_with_index do |line, i|
-      whitespace = 0
+    def demodulize(class_name_in_module)
+      class_name_in_module.to_s.sub(/^.*::/, '')
+    end
 
-      while whitespace < line.length && line[whitespace].chr == ' '
-        whitespace += 1
-      end
+    def pluralize(word)
+      word.to_s.sub(/([^s])$/, '\1s')
+    end
 
-      # If the current line is empty, indent it so that a snippet
-      # from the previous line is aligned correctly.
-      if line == ""
-        line = (" " * whitespace)
-      end
+    def singularize(word)
+      word.to_s.sub(/s$/, '').sub(/ie$/, 'y')
+    end
 
-      # If text was snipped from the previous line, prepend it to the
-      # current line after any current indentation.
-      if piece != ''
-        # Reset whitespaces to 0 if there are more whitespaces than there are
-        # console columns
-        whitespace = 0 if whitespace >= console_cols
-
-        # If the current line is empty and being prepended to, create a new
-        # empty line in the text so that formatting is preserved.
-        if text[i + 1] && line == (" " * whitespace)
-          text.insert(i + 1, "")
-        end
-
-        # Add the snipped text to the current line
-        line.insert(whitespace, "#{piece} ")
-      end
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, '/')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr! '-', '_'
+      word.downcase!
+      word
+    end
 
-      piece = ''
+    # Return the date and time in "HTTP-date" format as defined by RFC 7231.
+    #
+    # @return [Date,Time] in "HTTP-date" format
+    def utc_httpdate
+      Time.now.utc.httpdate
+    end
 
-      # Compare the line length to the allowed line length.
-      # If it exceeds it, snip the offending text from the line
-      # and store it so that it can be prepended to the next line.
-      if line.length > (console_cols + preamble)
-        reverse = console_cols
+    def request_id
+      SecureRandom.uuid
+    end
 
-        while line[reverse].chr != ' '
-          reverse -= 1
-        end
+    def twenty_four_hours_ago
+      Time.now - ( 60 * 60 * 24)
+    end
 
-        piece = line.slice!(reverse, (line.length - 1)).lstrip
+    def verify_options(accepted, actual) # @private
+      return unless debug || $DEBUG
+      unless (act=Set[*actual.keys]).subset?(acc=Set[*accepted])
+        raise Croesus::Errors::UnknownOption,
+          "\nDetected unknown option(s): #{(act - acc).to_a.inspect}\n" <<
+          "Accepted options are: #{accepted.inspect}"
       end
+      yield if block_given?
+    end
+  end # module ClassMethods
 
-      # If a snippet exists when all the columns in the text have been
-      # updated, create a new line and append the snippet to it, using
-      # the same left alignment as the last line in the text.
-      if piece != '' && text[i+1].nil?
-        text[i+1] = "#{' ' * (whitespace)}#{piece}"
-        piece = ''
-      end
+  # ============================================================================
 
-      # Add the preamble to the line and add it to the text
-      line = ((' ' * preamble) + line)
-      text[i] = line
-    end
+  def callable(call_her)
+    call_her.respond_to?(:call) ? call_her : lambda { call_her }
+  end
+
+  def camelize(underscored_word)
+    underscored_word.to_s.gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
+
+  def classify(table_name)
+    camelize singularize(table_name.to_s.sub(/.*\./, ''))
+  end
+
+  def class_name
+    demodulize(self.class)
+  end
+
+  def caller_name
+    caller_locations(2, 1).first.label
+  end
+
+  def demodulize(class_name_in_module)
+    class_name_in_module.to_s.sub(/^.*::/, '')
+  end
 
-    text.join("\n")
+  def pluralize(word)
+    word.to_s.sub(/([^s])$/, '\1s')
   end
 
-  # Figures out the columns and lines of the current tty
+  def singularize(word)
+    word.to_s.sub(/s$/, '').sub(/ie$/, 'y')
+  end
+
+  def underscore(camel_cased_word)
+    word = camel_cased_word.to_s.dup
+    word.gsub!(/::/, '/')
+    word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+    word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+    word.tr! '-', '_'
+    word.downcase!
+    word
+  end
+
+  # Return the date and time in "HTTP-date" format as defined by RFC 7231.
   #
-  # Returns [0, 0] if it can't figure it out or if you're
-  # not running on a tty
-  def self.terminal_dimensions(stdout = STDOUT, environment = ENV)
-    return [0, 0] unless stdout.tty?
+  # @return [Date,Time] in "HTTP-date" format
+  def utc_httpdate
+    Time.now.utc.httpdate
+  end
+
+  def request_id
+    SecureRandom.uuid
+  end
 
-    return [80, 40] if Util.windows?
+  def twenty_four_hours_ago
+    Time.now - ( 60 * 60 * 24)
+  end
 
-    if environment["COLUMNS"] && environment["LINES"]
-      return [environment["COLUMNS"].to_i, environment["LINES"].to_i]
+  def verify_options(accepted, actual) # @private
+    return unless debug || $DEBUG
+    unless (act=Set[*actual.keys]).subset?(acc=Set[*accepted])
+      raise Croesus::Errors::UnknownOption,
+        "\nDetected unknown option(s): #{(act - acc).to_a.inspect}\n" <<
+        "Accepted options are: #{accepted.inspect}"
+    end
+    yield if block_given?
+  end
 
-    elsif environment["TERM"] && command_in_path?("tput")
-      return [`tput cols`.to_i, `tput lines`.to_i]
+  # Returns the columns and lines of the current tty.
+  #
+  # @return [Integer]
+  #   number of columns and lines of tty, returns [0, 0] if no tty is present.
+  #
+  # @api public
+  def terminal_dimensions
+    [0, 0] unless  STDOUT.tty?
+    [80, 40] if OS.windows?
 
+    if ENV['COLUMNS'] && ENV['LINES']
+      [ENV['COLUMNS'].to_i, ENV['LINES'].to_i]
+    elsif ENV['TERM'] && command_in_path?('tput')
+      [`tput cols`.to_i, `tput lines`.to_i]
     elsif command_in_path?('stty')
-      return `stty size`.scan(/\d+/).map {|s| s.to_i }
+      `stty size`.scan(/\d+/).map {|s| s.to_i }
     else
-      return [0, 0]
+      [0, 0]
     end
   rescue
     [0, 0]
   end
+
+  # Checks in PATH returns true if the command is found
+  def command_in_path?(command)
+    found = ENV['PATH'].split(File::PATH_SEPARATOR).map do |p|
+      File.exist?(File.join(p, command))
+    end
+    found.include?(true)
+  end
+
+  # Runs a code block, and retries it when an exception occurs. Should the
+  # number of retries be reached without success, the last exception will be
+  # raised.
+  #
+  # @param opts [Hash{Symbol => Value}]
+  # @option opts [Fixnum] :tries
+  #   number of attempts to retry before raising the last exception
+  # @option opts [Fixnum] :sleep
+  #   number of seconds to wait between retries, use lambda to exponentially
+  #   increasing delay between retries
+  # @option opts [Array(Exception)] :on
+  #   the type of exception(s) to catch and retry on
+  # @option opts [Regex] :matching
+  #   match based on the exception message
+  # @option opts [Block] :ensure
+  #   ensure a block of code is executed, regardless of whether an exception
+  #   is raised
+  #
+  # @return [Block]
+  #
+  def retrier(opts = {}, &block)
+    defaults = {
+      tries:    2,
+      sleep:    1,
+      on:       StandardError,
+      matching: /.*/,
+      :ensure => Proc.new {}
+    }
+
+    check_for_invalid_options(opts, defaults)
+    defaults.merge!(opts)
+
+    return if defaults[:tries] == 0
+
+    on_exception, tries = [defaults[:on]].flatten, defaults[:tries]
+    retries = 0
+    retry_exception = nil
+
+    begin
+      yield retries, retry_exception
+    rescue *on_exception => exception
+      raise unless exception.message =~ defaults[:matching]
+      raise if retries+1 >= defaults[:tries]
+
+      # Interrupt Exception could be raised while sleeping
+      begin
+        sleep defaults[:sleep].respond_to?(:call) ?
+          defaults[:sleep].call(retries) : defaults[:sleep]
+      rescue *on_exception
+      end
+
+      retries += 1
+      retry_exception = exception
+      retry
+    ensure
+      defaults[:ensure].call(retries)
+    end
+  end
+
+  private #   P R O P R I E T À   P R I V A T A   Vietato L'accesso
+
+  def check_for_invalid_options(custom_options, defaults)
+    invalid_options = defaults.merge(custom_options).keys - defaults.keys
+    raise ArgumentError.new('[Retrier] Invalid options: ' \
+      "#{invalid_options.join(", ")}") unless invalid_options.empty?
+  end
 end

data/lib/hoodie/version.rb

@@ -18,5 +18,5 @@
 #
 
 module Hoodie
-  VERSION = '0.3.21'
+  VERSION = '0.4.0'
 end

data/lib/hoodie.rb

@@ -19,9 +19,11 @@
 
 require 'hoodie/stash/mem_store'
 require 'hoodie/stash/disk_store'
+require 'hoodie/identity_map'
 require 'hoodie/memoizable'
 require 'hoodie/obfuscate'
 require 'hoodie/version'
+require 'hoodie/timers'
 require 'hoodie/utils'
 require 'hoodie/stash'
 require 'hoodie/blank'