garcun 0.0.2

data/lib/garcon/core_ext/boolean.rb

@@ -0,0 +1,66 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# Add #blank? method to TrueClass class.
+class TrueClass
+  # True is never blank.
+  #
+  # @example
+  #   true.blank?       # =>  false
+  #
+  # @return [FalseClass]
+  #
+  # @api public
+  def blank?
+    false
+  end
+
+  # Since TrueClass is immutable it cannot be duplicated.
+  # For this reason #try_dup returns +self+.
+  #
+  #   true.dup!  #=> true
+  #
+  def dup!   ; self  ; end
+  def dup?   ; false ; end
+  def clone? ; false ; end
+end
+
+# Add #blank? method to FalseClass class.
+class FalseClass
+  # False is always blank.
+  #
+  # @example
+  #   false.blank?      # =>  true
+  #
+  # @return [TrueClass]
+  #
+  # @api public
+  def blank?
+    true
+  end
+
+  # Since FalseClass is immutable it cannot be duplicated.
+  # For this reason #try_dup returns +self+.
+  #
+  #   false.dup!  #=> false
+  #
+  def dup!   ; self  ; end
+  def dup?   ; false ; end
+  def clone? ; false ; end
+end

data/lib/garcon/core_ext/duration.rb

@@ -0,0 +1,271 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+class Duration
+  include Comparable
+
+  SECOND =   1
+  MINUTE =  60 * SECOND
+  HOUR   =  60 * MINUTE
+  DAY    =  24 * HOUR
+  WEEK   =   7 * DAY
+  YEAR   = 365 * DAY
+
+  SEGMENTS = %w{years weeks days hours minutes seconds}.collect{ |s| s.to_sym }
+
+  def self.[](seconds, *segments)
+    new(seconds, *segments)
+  end
+
+  def initialize(seconds=0, *segments)
+    @seconds = seconds.to_i
+    reset_segments(*segments)
+  end
+
+  def segments; @segments; end
+
+  def reset_segments(*segments)
+    case segments.size
+    when 0
+      @segments = [:days, :hours, :minutes, :seconds]
+    when 1
+      case segments = segments[0]
+      when Array
+        @segments = segments.collect { |p| (p.to_s.downcase.chomp('s') + 's').to_sym }
+        raise ArgumentError unless @segments.all? { |s| SEGMENTS.include?(s) }
+      else
+        f = SEGMENTS.index(segments)
+        @segments = SEGMENTS[f..0]
+      end
+    when 2
+      f = SEGMENTS.index(segments[0])
+      t = SEGMENTS.index(segments[1])
+      @segments = SEGMENTS[f..t]
+    else
+      raise ArgumentError
+    end
+  end
+
+  def inspect
+    h = to_h
+    segments.reverse.collect do |l|
+      "#{h[l.to_sym]} #{l}"
+    end.join(' ')
+  end
+
+  def to_i ; @seconds.to_i ; end
+  def to_f ; @seconds.to_f ; end
+
+  public
+
+  def to_a
+    a, s = [], @seconds
+    a[5], s = *s.divmod(YEAR)   if @segments.include?(:years)
+    a[4], s = *s.divmod(WEEK)   if @segments.include?(:weeks)
+    a[3], s = *s.divmod(DAY)    if @segments.include?(:days)
+    a[2], s = *s.divmod(HOUR)   if @segments.include?(:hours)
+    a[1], s = *s.divmod(MINUTE) if @segments.include?(:minutes)
+    a[0], s = *s.divmod(SECOND) if @segments.include?(:seconds)
+    a.compact.reverse
+  end
+
+  def to_h
+    h, s = {}, @seconds
+    h[:years],   s = *s.divmod(YEAR)   if @segments.include?(:years)
+    h[:weeks],   s = *s.divmod(WEEK)   if @segments.include?(:weeks)
+    h[:days],    s = *s.divmod(DAY)    if @segments.include?(:days)
+    h[:hours],   s = *s.divmod(HOUR)   if @segments.include?(:hours)
+    h[:minutes], s = *s.divmod(MINUTE) if @segments.include?(:minutes)
+    h[:seconds], s = *s.divmod(SECOND) if @segments.include?(:seconds)
+    h
+  end
+
+  def to_s
+    h = to_h
+    segments.reverse.collect do |l|
+      "#{h[l.to_sym]} #{l}"
+    end.join(' ')
+  end
+
+  def ==(other)
+    if Duration === other
+      other.seconds == seconds
+    else
+      other == seconds
+    end
+  end
+
+  def <=>(other)
+    @seconds <=> other.to_i
+  end
+
+  def years   ; to_h[:years]   ; end
+  def weeks   ; to_h[:weeks]   ; end
+  def days    ; to_h[:days]    ; end
+  def hours   ; to_h[:hours]   ; end
+  def minutes ; to_h[:minutes] ; end
+  def seconds ; to_h[:seconds] ; end
+
+  def total ; seconds ; end
+
+  def +(other)
+    self.class.new(@seconds + other.to_i, segments)
+  end
+
+  def -(other)
+    self.class.new(@seconds - other.to_i, segments)
+  end
+
+  def *(other)
+    self.class.new(@seconds * other.to_i, segments)
+  end
+
+  def /(other)
+    self.class.new(@seconds / other.to_i, segments)
+  end
+
+  def segmented(*segments)
+    self.class.new(@seconds, segments)
+  end
+
+  # Format duration.
+  #
+  # *Identifiers*
+  #
+  #     %w -- Number of weeks
+  #     %d -- Number of days
+  #     %h -- Number of hours
+  #     %m -- Number of minutes
+  #     %s -- Number of seconds
+  #     %t -- Total number of seconds
+  #     %x -- Duration#to_s
+  #     %% -- Literal `%' character
+  #
+  # *Example*
+  #
+  #     d = Duration.new(:weeks => 10, :days => 7)
+  #     => #<Duration: 11 weeks>
+  #     d.strftime("It's been %w weeks!")
+  #     => "It's been 11 weeks!"
+  #
+  def strftime(fmt)
+    h = to_h
+    hx = {
+     'y' => h[:years]  ,
+     'w' => h[:weeks]  ,
+     'd' => h[:days]   ,
+     'h' => h[:hours]  ,
+     'm' => h[:minutes],
+     's' => h[:seconds],
+     't' => total,
+     'x' => to_s
+    }
+    fmt.gsub(/%?%(w|d|h|m|s|t|x)/) do |match|
+      hx[match[1..1]]
+    end.gsub('%%', '%')
+  end
+
+  def -@
+    self.class.new(-@seconds)
+  end
+
+  def +@
+    self.class.new(+@seconds)
+  end
+
+  def before(time)
+    @seconds.before(time)
+  end
+
+  def after(time)
+    @seconds.after(time)
+  end
+
+
+  # = Numeric Extensions for Durations
+  #
+  module Numeric
+
+    # Enables the use of time calculations and declarations,
+    # like 45.minutes + 2.hours + 4.years. The base unit for
+    # all of these Numeric time methods is seconds.
+    def seconds ; Duration[self] ; end
+    alias_method :second, :seconds
+
+    # Converts minutes into seconds.
+    def minutes ; Duration[self * 60] ; end
+    alias_method :minute, :minutes
+
+    # Converts hours into seconds.
+    def hours ; Duration[self * 3600] ; end
+    alias_method :hour, :hours
+    #def as_hours ; self / 60.minutes ; end
+
+    # Converts days into seconds.
+    def days ; Duration[self * 86400] ; end
+    alias_method :day, :days
+
+    # Converts weeks into seconds.
+    def weeks ; Duration[self * 604800] ; end
+    alias_method :week, :weeks
+
+    # Converts fortnights into seconds.
+    # (A fortnight is 2 weeks)
+    def fortnights ; Duration[self * 1209600] ; end
+    alias_method :fortnight, :fortnights
+
+    # Converts months into seconds.
+    # WARNING: This is not exact as it assumes 30 days to a month.
+    def months ; Duration[self * 30 * 86400] ; end
+    alias_method :month, :months
+
+    # Converts years into seconds.
+    # WARNING: This is not exact as it assumes 365 days to a year.
+    #          ie. It doesn not account for leap years.
+    def years ; Duration[self * 365 * 86400, :years] ; end
+    alias_method :year, :years
+
+  end
+
+  # Time#duration has been added to convert the UNIX timestamp into a Duration.
+  # See Time#duration for an example.
+  #
+  module Time
+    # Create a Duration object from the UNIX timestamp.
+    #
+    # *Example*
+    #
+    #   Time.now.duration
+    #   => #<Duration: 1898 weeks, 6 days, 1 hour, 12 minutes and 1 second>
+    #
+    def duration
+      Duration[to_i]
+    end
+  end
+
+end
+
+class Numeric
+  include Duration::Numeric
+end
+
+class Time
+  include Duration::Time
+end
+

data/lib/garcon/core_ext/enumerable.rb

@@ -0,0 +1,34 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# Add #exclude
+module Enumerable
+  unless method_defined?(:exclude?)
+    # The inverse of #include?.
+    #
+    # @example
+    #  [:a, :b].exclude?(:c)  # => true
+    #  [:a, :b].exclude?(:a)  # => false
+    #
+    # @api public
+    def exclude?(object)
+      !include?(object)
+    end
+  end
+end

data/lib/garcon/core_ext/file.rb

@@ -0,0 +1,127 @@
+# encoding: UTF-8
+#
+# Author:    Stefano Harding <riddopic@gmail.com>
+# License:   Apache License, Version 2.0
+# Copyright: (C) 2014-2015 Stefano Harding
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'thread'    unless defined?(Thread)
+require 'tempfile'  unless defined?(Tempfile)
+require 'fileutils' unless defined?(FileUtils)
+
+class File
+
+  def self.atomic_id
+    @atomic_id ||= 0
+    @atomic_id += 1
+  end
+
+  # Same as `File.open`, but acts on a temporary copy of named
+  # file, copying the file back to the original on completion.
+  #
+  # @uncommon
+  #   require 'facets/fileutils/atomic_open'
+  #
+  def self.atomic_open(file_name, mode="r", temp_dir=nil, &block)
+    temp_dir  = temp_dir || Dir.tmpdir
+    temp_file = Tempfile.new("#{aomtic_id}-" + basename(file_name), temp_dir)
+
+    if File.exist?(file_name)
+      FileUtils.cp(file_name, temp_file)
+    end
+
+    open(temp_file, mode, &block)
+
+    FileUtils.cp(temp_file, file_name)
+  end
+
+  # Write to a file atomically. Useful for situations where you don't
+  # want other processes or threads to see half-written files.
+  #
+  #   File.atomic_write("important.txt") do |file|
+  #     file.write("hello")
+  #   end
+  #
+  # If your temporary directory is not on the same filesystem as the file you're
+  # trying to write, you can provide a different temporary directory.
+  #
+  #   File.atomic_write("important.txt", "tmp") do |file|
+  #     file.write("hello")
+  #   end
+  #
+  # NOTE: This method is not a common core extension and is not
+  # loaded automatically when using <code>require 'facets'</code>.
+  #
+  # CREDIT: David Heinemeier Hansson
+  #
+  # @uncommon
+  #   require 'facets/fileutils/atomic_write'
+  #
+  def self.atomic_write(file_name, temp_dir=nil)
+    temp_dir  = temp_dir || Dir.tmpdir
+    temp_file = Tempfile.new(basename(file_name), temp_dir)
+
+    yield temp_file
+    temp_file.close
+
+    begin
+      ## Get original file permissions
+      old_stat = stat(file_name)
+    rescue Errno::ENOENT
+      ## No old permissions, write a temp file to determine the defaults
+      check_name = join(dirname(file_name), ".permissions_check.#{Thread.current.object_id}.#{Process.pid}.#{rand(1000000)}")
+      open(check_name, "w") { }
+      old_stat = stat(check_name)
+      unlink(check_name)
+    end
+
+    ## Overwrite original file with temp file
+    FileUtils.mv(temp_file.path, file_name)
+
+    ## Set correct permissions on new file
+    chown(old_stat.uid, old_stat.gid, file_name)
+    chmod(old_stat.mode, file_name)
+  end
+
+  # Reads in a file, removes blank lines and removes lines starting
+  # with '#' and then returns an array of all the remaining lines.
+  #
+  # Thr remark indicator can be overridden via the +:omit:+ option, which
+  # can be a regualar expression or a string that is match against the
+  # start of a line.
+  #
+  # CREDIT: Trans
+
+  def self.read_list(filepath, options={})
+    chomp = options[:chomp]
+    omit  = case options[:omit]
+            when Regexp
+              omit
+            when nil
+              /^\s*\#/
+            else
+              /^\s*#{Regexp.escape(omit)}/
+            end
+
+    list = []
+    readlines(filepath).each do |line|
+      line = line.strip.chomp(chomp)
+      next if line.empty?
+      next if omit === line
+      list << line
+    end
+    list
+  end
+end