duranged 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a2951d10f37ccb4455790939b928f13d81f99f66
+  data.tar.gz: 86b329f53282b75ce0fcbd6b1cb0c391e6808544
+SHA512:
+  metadata.gz: 1e1561da9807d9564a2403c990f60ec5c297351bd1187f093c6fc83001440d1cd707eeb9a4155761bb79d629e4f5591156ce8852250fbb4fd5785a023873a56e
+  data.tar.gz: 776ca9e9111541289f471c0482433e86b19ed24eb1f2d47faa4a962f05b709422c20bef8a7f020c994bcc2bdd9812a024107146ff1537f443f36e4092907d723

data/lib/duranged.rb

@@ -0,0 +1,45 @@
+require 'active_support'
+require 'active_support/core_ext/enumerable'
+require 'active_support/core_ext/object'
+require 'active_support/core_ext/numeric'
+require 'active_support/core_ext/time'
+require 'canfig'
+require 'chronic_duration'
+require 'duranged/base'
+require 'duranged/duration'
+require 'duranged/interval'
+require 'duranged/occurrence'
+require 'duranged/range'
+
+module Duranged
+  include Canfig::Module
+
+  configure do |config|
+    config.formats = Canfig.new(date: '%b. %-d %Y', time: '%-l:%M%P')
+    config.logger = ActiveSupport::Logger.new(STDOUT)
+  end
+
+  def self.formats
+    configuration.formats
+  end
+
+  def self.logger
+    configuration.logger
+  end
+
+  def self.interval(interval)
+    Interval.new(interval)
+  end
+
+  def self.duration(duration)
+    Duration.new(duration)
+  end
+
+  def self.range(start_at, end_at_or_duration)
+    Range.new(start_at, end_at_or_duration)
+  end
+
+  def self.occurrence(occurrences=1, interval=nil, duration=nil)
+    Occurrence.new(occurrences, interval, duration)
+  end
+end

data/lib/duranged/base.rb

@@ -0,0 +1,182 @@
+module Duranged
+  class Base
+    include Comparable
+    attr_reader :value
+
+    PARTS = [:years, :months, :weeks, :days_after_weeks, :days, :hours, :minutes, :seconds]
+    FORMATTERS = { 's' => -> (pad,with) { pad_value seconds, pad, with },
+                   'm' => -> (pad,with) { pad_value minutes, pad, with },
+                   'h' => -> (pad,with) { pad_value hours, pad, with },
+                   'd' => -> (pad,with) { pad_value days, pad, with },
+                   'D' => -> (pad,with) { pad_value days_after_weeks, pad, with },
+                   'w' => -> (pad,with) { pad_value weeks, pad, with },
+                   'M' => -> (pad,with) { pad_value months, pad, with },
+                   'y' => -> (pad,with) { pad_value years, pad, with } }
+
+    class << self
+      def dump(obj)
+        return if obj.nil?
+        obj.to_json
+      end
+
+      def load(json)
+        value = JSON.load(json)
+        new(value)
+      end
+    end
+
+    def initialize(value)
+      if value.is_a?(Hash)
+        @value = parse_hash(value)
+      elsif value.is_a?(String) && value.to_i.to_s != value
+        @value = ChronicDuration.parse(value, keep_zero: true).to_i
+      else
+        @value = value.to_i
+      end
+    end
+
+    def years
+      (value.to_f / 60 / 60 / 24 / 365.25).to_i
+    end
+
+    def months
+      ((value - years.years) / 60 / 60 / 24 / 30).floor
+    end
+
+    def weeks
+      (((value - months.months - years.years) / 60 / 60 / 24).floor / 7).floor
+    end
+
+    def days_after_weeks
+      ((value - weeks.weeks - months.months - years.years) / 60 / 60 / 24).floor
+    end
+
+    def days
+      ((value - months.months - years.years) / 60 / 60 / 24).floor
+    end
+
+    def hours
+      ((value - days.days - months.months - years.years) / 60 / 60).floor
+    end
+
+    def minutes
+      ((value - hours.hours - days.days - months.months - years.years) / 60).floor
+    end
+
+    def seconds
+      (value - minutes.minutes - hours.hours - days.days - months.months - years.years).floor
+    end
+
+    def +(other)
+      if other.is_a?(Duration) || other.is_a?(Interval)
+        Duranged.logger.warn "Warning: You are adding a #{other.class.name} to a #{self.class.name}, which will result in a #{self.class.name}. If you would like a #{other.class.name} object to be returned you must add your #{self.class.name} to your #{other.class.name} instead." if other.is_a?(Range)
+        self.class.new(value + other.value)
+      elsif other.is_a?(Integer)
+        self.class.new(value + other)
+      else
+        raise ArgumentError, "value must be an Integer, Duranged::Duration or Duranged::Interval"
+      end
+    end
+
+    def -(other)
+      if other.is_a?(Duration) || other.is_a?(Interval)
+        Duranged.logger.warn "Warning: You are subtracting a #{other.class.name} from a #{self.class.name}, which will result in a #{self.class.name}. If you would like a #{other.class.name} object to be returned you must subtract your #{self.class.name} from your #{other.class.name} instead." if other.is_a?(Range)
+        self.class.new(value - other.value)
+      elsif other.is_a?(Integer)
+        self.class.new(value - other)
+      else
+        raise ArgumentError, "value must be an Integer, Duranged::Duration or Duranged::Interval"
+      end
+    end
+
+    def as_json(options=nil)
+      value
+    end
+
+    def to_h
+      PARTS.map do |part|
+        [part, send(part)]
+      end.to_h
+    end
+
+    def to_s
+      ChronicDuration.output(value, format: :long, joiner: ', ').to_s
+    end
+
+    def strfdur(format)
+      str = format.to_s
+
+      # :years(%Y years, ):months(%N months, )%D :days
+      PARTS.each do |part|
+        while matches = str.match(/:(#{part})(\((.+)\))?/i) do
+          if matches[3]
+            # only replaces if the value is > 0, otherwise blank
+            matched = ''
+            depth = 0
+            matches[3].chars.to_a.each do |char|
+              depth += 1 if char == '('
+              depth -= 1 if char == ')'
+              break if depth == -1
+              matched += char
+            end
+            value = send(part) > 0 ? strfdur(matched.dup) : ''
+            str.gsub!(":#{part}(#{matched})", value)
+          else
+            # if no nested format was passed, replace with a singular
+            # or plural part name as appropriate
+            value = send(part) == 1 ? matches[1].to_s.singularize : matches[1].to_s
+            str.gsub!(matches[0], value)
+          end
+        end
+      end
+
+      FORMATTERS.each do |conversion, block|
+        while matches = str.match(/%([-_])?([0-9]+)?(#{conversion})/) do
+          pad_with = matches[1] == '_' ? :space : :zero
+          value = instance_exec(matches[2] || 2, pad_with, &block)
+          value = value.to_i.to_s.lstrip if matches[1] == '-'
+
+          str.gsub!(matches[0], value)
+        end
+      end
+
+      str
+    end
+
+    def to_i
+      value
+    end
+
+    def <=>(other)
+      if value < other.to_i
+        -1
+      elsif value > other.to_i
+        1
+      else
+        0
+      end
+    end
+
+    def call
+      value
+    end
+
+    protected
+
+    def parse_hash(hash)
+      hash.sum { |k,v| v.to_i.send(k.to_sym) }
+    end
+
+    def pad_value(value, pad=2, with=:zero)
+      send("#{with}_pad".to_sym, value, pad)
+    end
+
+    def zero_pad(value, pad=2)
+      "%0#{pad}d" % value
+    end
+
+    def space_pad(value, pad=2)
+      "%#{pad}d" % value
+    end
+  end
+end

data/lib/duranged/duration.rb

@@ -0,0 +1,6 @@
+module Duranged
+  class Duration < Base
+    alias_attribute :duration, :value
+    alias_method :duration_string, :to_s
+  end
+end

data/lib/duranged/interval.rb

@@ -0,0 +1,6 @@
+module Duranged
+  class Interval < Base
+    alias_attribute :interval, :value
+    alias_method :interval_string, :to_s
+  end
+end

data/lib/duranged/occurrence.rb

@@ -0,0 +1,124 @@
+module Duranged
+  class Occurrence
+    attr_reader :occurrences, :interval, :duration, :range
+
+    class << self
+      def dump(obj)
+        return if obj.nil?
+        obj.to_json
+      end
+
+      def load(json)
+        hash = JSON.load(json)
+        args = [hash['occurrences'], hash['interval'], hash['duration']]
+        args.concat [hash['range']['start_at'].to_datetime, hash['range']['end_at'].to_datetime] if hash.key?('range')
+        new(*args)
+      end
+    end
+
+    def initialize(occurrences=1, interval=nil, duration=nil, range_start=nil, range_end_or_duration=nil)
+      if occurrences.class <= Enumerable
+        @occurrences = occurrences.count
+      else
+        @occurrences = occurrences.to_i
+      end
+
+      @interval = Interval.new(interval) if interval
+      @duration = Duration.new(duration) if duration
+      if range_start.present?
+        if range_end_or_duration.nil?
+          range_end_or_duration = range_start.to_datetime
+          range_end_or_duration = range_end_or_duration + (@interval.value * (occurrences - 1)).seconds if @interval
+          range_end_or_duration = range_end_or_duration + (@duration.value * occurrences).seconds if @duration
+        end
+        @range = Range.new(range_start, range_end_or_duration)
+      end
+    end
+
+    def occurrences_string
+      case occurrences
+      when 0
+        "never"
+      when 1
+        "once"
+      when 2
+        "twice"
+      else
+        "#{occurrences} times"
+      end
+    end
+
+    def as_json(options=nil)
+      hash = { occurrences: occurrences }
+      hash[:interval] = interval.as_json(options) if interval
+      hash[:duration] = duration.as_json(options) if duration
+      hash[:range] = range.as_json(options) if range
+      hash
+    end
+    alias_method :to_h, :as_json
+
+    def to_s
+      return occurrences_string if occurrences == 0
+
+      str = [occurrences_string]
+
+      if duration.present? && duration > 0
+        str << "for"
+        str << duration.to_s
+      end
+
+      if interval.present? && interval > 0
+        str << "every"
+        str << interval.to_s
+      end
+
+      if range.present?
+        if range.same_day?
+          str << range.strfrange("on :start_at(#{Duranged.configuration.formats.date}) between :start_at(#{Duranged.configuration.formats.time}) and :end_at(#{Duranged.configuration.formats.time})")
+        else
+          str << range.strfrange("between :start_at(#{Duranged.configuration.formats.date} #{Duranged.configuration.formats.time}) and :end_at(#{Duranged.configuration.formats.date} #{Duranged.configuration.formats.time})")
+        end
+      end
+
+      str.join(' ')
+    end
+
+    def strfocc(format)
+      str = format.to_s
+
+      while matches = str.match(/:occurrence[s]?/) do
+        str.gsub!(matches[0], occurrences.to_s)
+      end
+      
+      if range
+        while matches = str.match(/:range(\((.+)\))?/) do
+          if matches[2]
+            matched = ''
+            depth = 0
+            matches[2].chars.to_a.each do |char|
+              depth += 1 if char == '('
+              depth -= 1 if char == ')'
+              break if depth == -1
+              matched += char
+            end
+            value = range.strfrange(matched.dup)
+            str.gsub!(":range(#{matched})", value)
+          else
+            value = range.to_s
+            str.gsub!(matches[0], value)
+          end
+        end
+      end
+
+      if duration || interval
+        while matches = str.match(/:(duration|interval)(\(([^\)]+)\))/) do
+          matched = send(matches[1])
+          value = matched.nil? ? '' : matched.strfdur(matches[3])
+          str.gsub!(matches[0], value)
+        end
+      end
+
+      str
+    end
+  end
+end

data/lib/duranged/range.rb

@@ -0,0 +1,111 @@
+module Duranged
+  class Range < Duration
+    class << self
+      def load(json)
+        hash = JSON.load(json)
+        new(hash['start_at'].to_datetime, hash['end_at'].to_datetime)
+      end
+    end
+
+    # Range.new(Time.now, 1.hour)
+    # Range.new(Time.now, 1.hour.from_now)
+    # Range.new(Time.now, (Time.now + 1.hour))
+    # Range.new(1.hour)                         # start_at defaults to now
+    # Range.new(1.hour.from_now)                # start_at defaults to now
+    # Range.new(Time.now + 1.hour)              # start_at defaults to now
+    def initialize(*args)
+      if args.length == 2
+        start_at, end_at_or_duration = *args
+      elsif args.length == 1
+        start_at = DateTime.now
+        end_at_or_duration = args.first
+      else
+        raise ArgumentError, "wrong number of arguments (#{args.length} for 1..2)"
+      end
+
+      @start_at = start_at.to_datetime
+      if end_at_or_duration.is_a?(Integer) || end_at_or_duration.is_a?(ActiveSupport::Duration)
+        super(end_at_or_duration.to_i)
+        @end_at = (@start_at + duration.seconds).to_datetime
+      elsif end_at_or_duration.is_a?(Hash) || end_at_or_duration.is_a?(String)
+        super(end_at_or_duration)
+        @end_at = (@start_at + duration.seconds).to_datetime
+      else
+        @end_at = end_at_or_duration.to_datetime
+        super(@end_at.to_i - @start_at.to_i)
+      end
+    end
+
+    def start_at(format=nil)
+      format.nil? ? @start_at : @start_at.strftime(format).strip
+    end
+    alias_method :start_date, :start_at
+    alias_method :start_time, :start_at
+
+    def end_at(format=nil)
+      format.nil? ? @end_at : @end_at.strftime(format).strip
+    end
+    alias_method :end_date, :end_at
+    alias_method :end_time, :end_at
+
+    def +(other)
+      if other.is_a?(Duration) || other.is_a?(Interval)
+        self.class.new(start_at, value + other.value)
+      elsif other.is_a?(Integer)
+        self.class.new(start_at, value + other)
+      else
+        raise ArgumentError, "value must be an Integer, Duranged::Duration or Duranged::Interval"
+      end
+    end
+
+    def -(other)
+      if other.is_a?(Duration) || other.is_a?(Interval)
+        self.class.new(start_at, value - other.value)
+      elsif other.is_a?(Integer)
+        self.class.new(start_at, value - other)
+      else
+        raise ArgumentError, "value must be an Integer, Duranged::Duration or Duranged::Interval"
+      end
+    end
+
+    def to_duration
+      Duration.new(duration)
+    end
+
+    def as_json(options=nil)
+      { start_at: start_at.as_json,
+        end_at: end_at.as_json }
+    end
+    alias_method :to_h, :as_json
+
+    def to_s
+      if same_day?
+        "#{start_at("#{Duranged.formats.date} #{Duranged.formats.time}")} to #{end_at("#{Duranged.formats.time}")}"
+      else
+        "#{start_at("#{Duranged.formats.date} #{Duranged.formats.time}")} (#{super()})"
+      end
+    end
+
+    def strfrange(format)
+      str = format.to_s
+
+      while matches = str.match(/:(start_at|end_at|)\((([^\)]+))\)/) do
+        str.gsub!(matches[0], send(matches[1], matches[2]))
+      end
+
+      while matches = str.match(/:duration\(([^\)]+)\)/) do
+        str.gsub!(matches[0], strfdur(matches[1]))
+      end
+
+      str
+    end
+
+    def call
+      to_s
+    end
+
+    def same_day?
+      start_at('%j') == end_at('%j')
+    end
+  end
+end