garcun 0.0.2

data/lib/garcon/core_ext/pathname.rb

@@ -0,0 +1,152 @@
+# 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.
+#
+
+module Garcon
+  # Expand a path with late-evaluated segments.
+  # Calls expand_path -- '~' becomes $HOME, '..' is expanded, etc.
+  #
+  # @example
+  #   A symbol represents a segment to expand
+  #     Pathname.register_path(:conf_dir, '/etc/openldap')
+  #     Pathname.path_to(:conf_dir)            # => '/etc/openldap'
+  #     Pathname.path_to(:conf_dir, ldap.conf) # => '/etc/openldap/ldap.conf'
+  #
+  # @example
+  #   References aren't expanded until they're read
+  #     Pathname.register_path(:conf_dir, '/etc/openldap')
+  #     Pathname.register_path(:ldap, :conf_dir, 'ldap.conf')
+  #     Pathname.path_to(:ldap)                # => '/etc/openldap/ldap.conf'
+  #
+  # @example
+  #   If we change the conf_dir, everything under it changes as well
+  #     Pathname.register_path(:conf_dir, '~/.openldap.d')
+  #     Pathname.path_to(:ldap)                # => '/root/openldap.d/ldap.conf'
+  #
+  # @exampl
+  #   References can be relative, and can hold symbols themselves
+  #     Pathname.register_path(:conf_dir, '/etc', :appname, :environment)
+  #     Pathname.register_path(:appname, 'app_awesome')
+  #     Pathname.register_path(:environment, 'dev')
+  #     Pathname.path_to(:conf_dir)            # => '/etc/app_awesome/dev'
+  #
+  module Pathref
+    ROOT_PATHS = Hash.new unless defined?(ROOT_PATHS)
+    extend self
+
+    # @param [Array<[String,Symbol]>] pathsegs
+    #   Any mixture of strings (literal sub-paths) and symbols (interpreted
+    #   as references).
+    #
+    # @return [Pathname]
+    #   A single expanded Pathname
+    #
+    # @api public
+    def of(*pathsegs)
+      relpath_to(*pathsegs).expand_path
+    end
+    alias_method :path_to, :of
+
+    # @api public
+    def register_path(handle, *pathsegs)
+      ArgumentError.arity_at_least!(pathsegs, 1)
+      ROOT_PATHS[handle.to_sym] = pathsegs
+    end
+
+    # @api public
+    def register_paths(handle_paths = {})
+      handle_paths.each_pair do |handle, pathsegs|
+        register_path(handle, *pathsegs)
+      end
+    end
+
+    # @api public
+    def register_default_paths(handle_paths = {})
+      handle_paths.each_pair do |handle, pathsegs|
+        unless ROOT_PATHS.has_key?(handle.to_sym)
+          register_path(handle, *pathsegs)
+        end
+      end
+    end
+
+    # @api public
+    def unregister_path(handle)
+      ROOT_PATHS.delete handle.to_sym
+    end
+
+    # Expand a path with late-evaluated segments @see `.path_to`. Calls
+    # cleanpath (removing `//` double slashes and useless `..`s), but does not
+    # reference the filesystem or make paths absolute.
+    #
+    # @api public
+    def relpath_to(*pathsegs)
+      ArgumentError.arity_at_least!(pathsegs, 1)
+      pathsegs = pathsegs.flatten.map { |ps| expand_pathseg(ps) }.flatten
+      self.new(File.join(*pathsegs)).cleanpath(true)
+    end
+    alias_method :relative_path_to, :relpath_to
+
+    protected #      A T T E N Z I O N E   A R E A   P R O T E T T A
+
+    # Recursively expand a path handle.
+    #
+    # @return [Array<String>]
+    #   An array of path segments, suitable for .join
+    #
+    # @api public
+    def expand_pathseg(handle)
+      return handle unless handle.is_a?(Symbol)
+      pathsegs = ROOT_PATHS[handle] or raise ArgumentError,
+        "Don't know how to expand path reference '#{handle.inspect}'."
+      pathsegs.map { |ps| expand_pathseg(ps) }.flatten
+    end
+  end
+end
+
+class Pathname
+  extend Garcon::Pathref
+
+  class << self; alias_method :new_pathname, :new; end
+
+  # Like find, but returns an enumerable
+  #
+  def find_all
+    Enumerator.new{|yielder| find{|path| yielder << path } }
+  end
+
+  def self.receive(obj)
+    return obj if obj.nil?
+    obj.is_a?(self) ? obj : new(obj)
+  end
+
+  # @return [Pathname]
+  #   The basename without extension (using self.extname as the extension).
+  #
+  # @api public
+  def corename
+    basename(self.extname)
+  end
+
+  # @return [String]
+  #   Compact string rendering
+  #
+  # @api public
+  def inspect_compact() to_path.dump ; end
+
+  alias_method :to_str, :to_path
+end

data/lib/garcon/core_ext/process.rb

@@ -0,0 +1,41 @@
+# 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.
+#
+
+module Process
+
+  # Turns the current script into a daemon process
+  # that detaches from the console. It can be shut
+  # down with a TERM signal.
+  #
+  def self.daemon(nochdir = nil, noclose = nil)
+    exit if fork
+    Process.setsid
+    exit if fork
+    Dir.chdir '/' unless nochdir
+    File.umask 0000
+    unless noclose
+      STDIN.reopen  '/dev/null'
+      STDOUT.reopen '/dev/null', 'a'
+      STDERR.reopen '/dev/null', 'a'
+    end
+    trap('TERM') { exit }
+    return 0
+  end unless respond_to?(:daemon)
+end
+

data/lib/garcon/core_ext/random.rb

@@ -0,0 +1,497 @@
+# 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 'securerandom'
+require_relative 'hash'
+require_relative 'string'
+require_relative 'kernel'
+
+# This library extends Array, String, Hash and other classes with randomization
+# methods. Most of the methods are of one of two kinds. Either they "pick" a
+# random element from the reciever or they randomly "shuffle" the reciever.
+#
+# The most common example is Array#shuffle, which simply randmomizes the
+# order of an array's elements.
+#
+#   [1,2,3].shuffle  # => [2,3,1]
+#
+# The other methods do similar things for their respective classes.
+#
+# The classes are all extended via mixins which have been created within
+# Ruby's Random class.
+#
+class Random
+  class << self
+    # Alias for Kernel#rand.
+    alias_method :number, :rand
+
+    public :number
+  end
+
+  # Module method to generate a random letter.
+  #
+  # @example
+  #   Random.letter  # => "q"
+  #   Random.letter  # => "r"
+  #   Random.letter  # => "a"
+  #
+  # @return [String]
+  #   A random letter
+  #
+  # @api public
+  def self.letter
+    (SecureRandom.random_number(26) +
+    (SecureRandom.random_number(2) == 0 ? 65 : 97)).chr
+  end
+
+  # Random extensions for Range class.
+  #
+  module RangeExtensions
+    # Return a random element from the range.
+    #
+    # @example
+    #   (1..4).at_rand           # => 2
+    #   (1..4).at_rand           # => 4
+    #
+    #   (1.5..2.5).at_rand       # => 2.06309842754533
+    #   (1.5..2.5).at_rand       # => 1.74976944931541
+    #
+    #   ('a'..'z').at_rand       # => 'q'
+    #   ('a'..'z').at_rand       # => 'f'
+    #
+    # @return [String]
+    #   A random element from range
+    #
+    # @api public
+    def at_rand
+      first, last = first(), last()
+      if first.respond_to?(:random_delta)
+        begin
+          first.random_delta(last, exclude_end?)
+        rescue
+          to_a.at_rand
+        end
+      else
+        to_a.at_rand
+      end
+    end
+  end
+
+  # Random extensions fo Integer class.
+  #
+  module IntegerExtensions
+    #
+    def random_delta(last, exclude_end)
+      first = self
+      last -= 1 if exclude_end
+      return nil if last < first
+      SecureRandom.random_number(last - first + 1) + first
+    end
+  end
+
+  # Random extensions for Numeric class.
+  #
+  module NumericExtensions
+    #
+    def random_delta(last, exclude_end)
+      first = self
+      return nil if last < first
+      return nil if exclude_end && last == first
+      (last - first) * SecureRandom.random_number + first
+    end
+  end
+
+  # Random extensions for Array class.
+  #
+  module ArrayExtensions
+    # Return a random element from the array.
+    #
+    # @example
+    #   [1, 2, 3, 4].at_rand           # => 2
+    #   [1, 2, 3, 4].at_rand           # => 4
+    #
+    def at_rand
+      at(SecureRandom.random_number(size))
+    end
+
+    # Same as #at_rand, but acts in place removing a random element from the
+    # array.
+    #
+    # @example
+    #   a = [1,2,3,4]
+    #   a.at_rand!       # => 2
+    #   a                # => [1,3,4]
+    #
+    def at_rand!
+      delete_at(SecureRandom.random_number(size))
+    end
+
+    # Similar to #at_rand, but will return an array of randomly picked exclusive
+    # elements if given a number.
+    def pick(n = nil)
+      if n
+        a = self.dup
+        a.pick!(n)
+      else
+        at(SecureRandom.random_number(size))
+      end
+    end
+
+    # Similar to #at_rand!, but given a number will return an array of exclusive
+    # elements.
+    def pick!(n = nil)
+      if n
+        if n > self.size
+          r = self.dup
+          self.replace([])
+          r
+        else
+          r = []
+          n.times { r << delete_at(SecureRandom.random_number(size)) }
+          r
+        end
+      else
+        delete_at(SecureRandom.random_number(size))
+      end
+    end
+
+    # Random index.
+    #
+    def rand_index
+      SecureRandom.random_number(size)
+    end
+
+    # Returns a random subset of an Array. If a _number_ of elements is
+    # specified then returns that number of elements, otherwise returns a random
+    # number of elements upto the size of the Array.
+    #
+    # By defualt the returned values are exclusive of each other, but if
+    # _exclusive_ is set to `false`, the same values can be choosen more than
+    # once.
+    #
+    # When _exclusive_ is <tt>true</tt> (the default) and the _number_ given is
+    # greater than the size of the array, then all values are returned.
+    #
+    # @example
+    #   [1, 2, 3, 4].rand_subset(1)        # => [2]
+    #   [1, 2, 3, 4].rand_subset(4)        # => [2, 1, 3, 4]
+    #   [1, 2, 3, 4].rand_subset           # => [1, 3, 4]
+    #   [1, 2, 3, 4].rand_subset           # => [2, 3]
+    #
+    def rand_subset(number = nil, exclusive = true)
+      number = SecureRandom.random_number(size) unless number
+      number = number.to_int
+      return sort_by{rand}.slice(0,number) if exclusive
+      ri =[]; number.times { |n| ri << SecureRandom.random_number(size) }
+      return values_at(*ri)
+    end
+
+    # Generates random subarrays. Uses random numbers and bit-fiddling to assure
+    # performant uniform distributions even for large arrays.
+    #
+    # @example
+    #   a = *1..5
+    #   a.rand_subarrays(2) # => [[3, 4, 5], []]
+    #   a.rand_subarrays(3) # => [[1], [1, 4, 5], [2, 3]]
+    #
+    def rand_subarrays(n = 1)
+      raise ArgumentError, 'negative argument' if n < 0
+      (1..n).map do
+        r = rand(2**self.size)
+        self.select.with_index { |_, i| r[i] == 1 }
+      end
+    end
+
+    # Randomize the order of an array.
+    #
+    # @example
+    #   [1,2,3,4].shuffle  # => [2,4,1,3]
+    #
+    def shuffle
+      dup.shuffle!
+    end
+
+    # As with #shuffle but modifies the array in place.
+    # The algorithm used here is known as a Fisher-Yates shuffle.
+    #
+    # @example
+    #   a = [1,2,3,4]
+    #   a.shuffle!
+    #   a  # => [2,4,1,3]
+    #
+    def shuffle!
+      s = size
+      each_index do |j|
+        i = SecureRandom.random_number(s-j)
+        tmp = self[j]
+        self[j] = self[j+i]
+        self[j+i] = tmp
+      end
+      self
+    end
+  end
+
+  # Random extensions for Hash class.
+  #
+  module HashExtensions
+    # Returns a random key.
+    #
+    # @example
+    #   {:one => 1, :two => 2, :three => 3}.pick_key  # => :three
+    #
+    def rand_key
+      keys.at(SecureRandom.random_number(keys.size))
+    end
+
+    # Delete a random key-value pair, returning the key.
+    #
+    # @example
+    #   a = {:one => 1, :two => 2, :three => 3}
+    #   a.rand_key!  # => :two
+    #   a            # => {:one => 1, :three => 3}
+    #
+    def rand_key!
+      k,v = rand_pair
+      delete(k)
+      return k
+    end
+
+    alias_method :pick_key, :rand_key!
+
+    # Returns a random key-value pair.
+    #
+    # @example
+    #   {:one => 1, :two => 2, :three => 3}.pick  # => [:one, 1]
+    #
+    def rand_pair
+      k = rand_key
+      return k, fetch(k)
+    end
+
+    # Deletes a random key-value pair and returns that pair.
+    #
+    # @example
+    #   a = {:one => 1, :two => 2, :three => 3}
+    #   a.rand_pair!  # => [:two, 2]
+    #   a             # => {:one => 1, :three => 3}
+    #
+    def rand_pair!
+      k,v = rand_pair
+      delete(k)
+      return k,v
+    end
+
+    alias_method :pick_pair, :rand_pair!
+
+    # Returns a random hash value.
+    #
+    # @example
+    #   {:one => 1, :two => 2, :three => 3}.rand_value  # => 2
+    #   {:one => 1, :two => 2, :three => 3}.rand_value  # => 1
+    #
+    def rand_value
+      fetch(rand_key)
+    end
+
+    # Deletes a random key-value pair and returns the value.
+    #
+    # @example
+    #   a = {:one => 1, :two => 2, :three => 3}
+    #   a.at_rand!  # => 2
+    #   a           # => {:one => 1, :three => 3}
+    #
+    def rand_value!
+      k,v = rand_pair
+      delete(k)
+      return v
+    end
+
+    alias_method :pick,     :rand_value!
+    alias_method :at_rand,  :rand_value
+    alias_method :at_rand!, :rand_value!
+
+    # Returns a copy of the hash with _values_ arranged in new random order.
+    #
+    # @example
+    #   h = {:a=>1, :b=>2, :c=>3}
+    #   h.shuffle  # => {:b=>2, :c=>1, :a>3}
+    #
+    def shuffle
+      ::Hash.zip(
+        keys.sort_by   { SecureRandom.random_number },
+        values.sort_by { SecureRandom.random_number })
+    end
+
+    # Destructive shuffle_hash. Arrange the values in a new random order.
+    #
+    # @example
+    #   h = {:a => 1, :b => 2, :c => 3}
+    #   h.shuffle!
+    #   h  # => {:b=>2, :c=>1, :a=>3}
+    #
+    def shuffle!
+      self.replace(shuffle)
+    end
+
+  end
+
+  # Random extensions for String class.
+  #
+  module StringExtensions
+
+    def self.included(base)
+      base.extend(Self)
+    end
+
+    # Class-level methods.
+    module Self
+      # Returns a randomly generated string. One possible use is
+      # password initialization. Takes a max legnth of characters
+      # (default 8) and an optional valid char Regexp (default /\w\d/).
+      #
+      # @example
+      #   String.random    # => 'dd4qed4r'
+      #
+      def random(max_length = 8, char_re = /[\w\d]/)
+        unless char_re.is_a?(Regexp)
+          raise ArgumentError, 'second argument must be a regular expression'
+        end
+        string = ''
+        while string.length < max_length
+            ch = SecureRandom.random_number(255).chr
+            string << ch if ch =~ char_re
+        end
+        return string
+      end
+
+      # Generate a random binary string of +n_bytes+ size.
+      #
+      def random_binary(n_bytes)
+        #(Array.new(n_bytes) { rand(0x100) }).pack('c*')
+        SecureRandom.random_bytes(64)
+      end
+
+      # Create a random String of given length, using given character set
+      #
+      # Examples
+      #
+      #     String.random
+      #     => "D9DxFIaqR3dr8Ct1AfmFxHxqGsmA4Oz3"
+      #
+      #     String.ran(10)
+      #     => "t8BIna341S"
+      #
+      #     String.ran(10, ['a'..'z'])
+      #     => "nstpvixfri"
+      #
+      #     String.ran(10, ['0'..'9'] )
+      #     => "0982541042"
+      #
+      #     String.ran(10, ['0'..'9','A'..'F'] )
+      #     => "3EBF48AD3D"
+      #
+      def ran(len = 32, character_set = ["A".."Z", "a".."z", "0".."9"])
+        chars = character_set.map(&:to_a).flatten
+        Array.new(len){ chars.sample }.join
+      end
+    end
+
+    # Return a random separation of the string. Default separation is by
+    # charaacter.
+    #
+    # @example
+    #   "Ruby rules".at_rand(' ')  # => ["Ruby"]
+    #
+    def at_rand(separator = //)
+      self.split(separator, -1).at_rand
+    end
+
+    # Return a random separation while removing it from the string. Default
+    # separation is by character.
+    #
+    # @example
+    #   s = "Ruby rules"
+    #   s.at_rand!(' ')    # => "Ruby"
+    #   s                  # => "rules"
+    #
+    def at_rand!(separator = //)
+      a = self.shatter(separator)
+      w = []; a.each_with_index { |s, i| i % 2 == 0 ? w << s : w.last << s }
+      i = SecureRandom.random_number(w.size)
+      r = w.delete_at(i)
+      self.replace(w.join(''))
+      return r
+    end
+
+    # Return a random byte of _self_.
+    #
+    # @example
+    #   "Ruby rules".rand_byte  # => 121
+    #
+    def rand_byte
+      self[SecureRandom.random_number(size)]
+    end
+
+    # Destructive rand_byte. Delete a random byte of _self_ and return it.
+    #
+    # @example
+    #   s = "Ruby rules"
+    #   s.rand_byte!      # => 121
+    #   s                 # => "Rub rules"
+    #
+    def rand_byte!
+      i = SecureRandom.random_number(size)
+      rv = self[i,1]
+      self[i,1] = ''
+      rv
+    end
+
+    # Return a random string index.
+    #
+    # @example
+    #   "Ruby rules".rand_index  # => 3
+    #
+    def rand_index
+      SecureRandom.random_number(size)
+    end
+
+    # Return the string with seperated sections arranged in a random order. The
+    # default seperation is by character.
+    #
+    # @example
+    #   "Ruby rules".shuffle  # => "e lybRsuur"
+    #
+    def shuffle(separator = //)
+      split(separator).shuffle.join('')
+    end
+
+    # In place version of shuffle.
+    #
+    def shuffle!(separator = //)
+      self.replace(shuffle(separator))
+    end
+  end
+end
+
+Hash.send(:include,    Random::HashExtensions)
+Array.send(:include,   Random::ArrayExtensions)
+Range.send(:include,   Random::RangeExtensions)
+String.send(:include,  Random::StringExtensions)
+Integer.send(:include, Random::IntegerExtensions)
+Numeric.send(:include, Random::NumericExtensions)