garcun 0.0.2

data/lib/garcon/core_ext/filetest.rb

@@ -0,0 +1,62 @@
+# 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 FileTest
+
+  SEPARATOR_PATTERN = (
+    if File::ALT_SEPARATOR
+      /[#{Regexp.quote File::ALT_SEPARATOR}#{Regexp.quote File::SEPARATOR}]/
+    else
+      /#{Regexp.quote File::SEPARATOR}/
+    end
+  ).freeze
+
+  module_function
+
+  # Predicate method for testing whether a path is absolute.
+  # It returns +true+ if the pathname begins with a slash.
+  def absolute?(path)
+    !relative?(path)
+  end
+
+  # The opposite of #absolute?
+  def relative?(path)
+    while r = chop_basename(path.to_s)
+      path, _ = r
+    end
+    path == ''
+  end
+
+  # List File.split, but preserves the file separators.
+  #
+  #   FileTest.chop_basename('/usr/lib') #=> ['/usr/', 'lib']
+  #   FileTest.chop_basename('/') #=> nil
+  #
+  # Returns Array of `[pre-basename, basename]` or `nil`.
+  #
+  # This method is here simply to support the #relative? and #absolute? methods.
+  def chop_basename(path)
+    base = File.basename(path)
+    if /\A#{SEPARATOR_PATTERN}?\z/ =~ base
+      return nil
+    else
+      return path[0, path.rindex(base)], base
+    end
+  end
+end

data/lib/garcon/core_ext/hash.rb

@@ -0,0 +1,279 @@
+# 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 Hash
+
+  # Turn a hash into a method arguments.
+  #
+  #   h = { :list => [1,2], :base => "HI" }
+  #
+  # Without an argument field.
+  #
+  #   h.argumentize #=> [ { :list => [1,2], :base => "HI" } ]
+  #
+  # With an argument field.
+  #
+  #   h.argumentize(:list)   #=> [ 1, 2, { :base => "HI" } ]
+  #   h.argumentize(:base)   #=> [ "HI", { :list => [1,2] } ]
+  #
+  def argumentize(args_field = nil)
+    config = dup
+    if args_field
+      args = [config.delete(args_field)].flatten.compact
+    else
+      args = []
+    end
+    args << config
+    return args
+  end
+
+  # A method to convert a Hash into a Struct.
+  #
+  #   h = { :name => "Earl", "age" => 20, "sex" => "lots", "worries" => "none" }
+  #   s = h.to_struct("Foo")
+  #
+  def to_struct(struct_name)
+    Struct.new(struct_name,*keys).new(*values)
+  end
+
+  # Get or set state of object. You can think of #object_state as an in-code
+  # form of marshalling.
+  #
+  def object_state(data=nil)
+    data ? replace(data) : dup
+  end
+
+  # A hash is blank if it's empty:
+  #
+  # @example
+  #   {}.blank?                # => true
+  #   { key: 'value' }.blank?  # => false
+  #
+  # @api public
+  alias_method :blank?, :empty?
+
+  # Returns a compacted copy (contains no key/value pairs having
+  # nil? values)
+  #
+  # @example
+  #   hash = { a: 100, b: nil, c: false, d: '' }
+  #   hash.compact   # => { a: 100, c: false, d: '' }
+  #   hash           # => { a: 100, b: nil, c: false, d: '' }
+  #
+  # @return [Hash]
+  #
+  # @api public
+  def compact
+    select { |_, value| !value.nil? }
+  end
+
+  # Returns a new hash with all keys converted using the block operation.
+  #
+  # @example
+  #   hash = { name: 'Tiggy', age: '15' }
+  #   hash.transform_keys{ |key| key.to_s.upcase }
+  #     # => { "AGE" => "15", "NAME" => "Tiggy" }
+  #
+  # @return [Hash]
+  #
+  # @api public
+  def transform_keys
+    enum_for(:transform_keys) unless block_given?
+    result = self.class.new
+    each_key do |key|
+      result[yield(key)] = self[key]
+    end
+    result
+  end
+
+  # Returns a new hash, recursively converting all keys by the
+  # block operation.
+  #
+  # @return [Hash]
+  #
+  def recursively_transform_keys(&block)
+    _recursively_transform_keys_in_object(self, &block)
+  end
+
+  # Returns a new hash with all keys downcased and converted
+  # to symbols.
+  #
+  # @return [Hash]
+  #
+  def normalize_keys
+    transform_keys { |key| key.downcase.to_sym rescue key }
+  end
+
+  # Returns a new Hash, recursively downcasing and converting all
+  # keys to symbols.
+  #
+  # @return [Hash]
+  #
+  def recursively_normalize_keys
+    recursively_transform_keys { |key| key.downcase.to_sym rescue key }
+  end
+
+  # Returns a new hash with all keys converted to symbols.
+  #
+  # @return [Hash]
+  #
+  def symbolize_keys
+    transform_keys { |key| key.to_sym rescue key }
+  end
+
+  # Returns a new Hash, recursively converting all keys to symbols.
+  #
+  # @return [Hash]
+  #
+  def recursively_symbolize_keys
+    recursively_transform_keys { |key| key.to_sym rescue key }
+  end
+
+  # Returns a new hash with all keys converted to strings.
+  #
+  # @return [Hash]
+  #
+  def stringify_keys
+    transform_keys { |key| key.to_s rescue key }
+  end
+
+  # Returns a new Hash, recursively converting all keys to strings.
+  #
+  # @return [Hash]
+  #
+  def recursively_stringify_key
+    recursively_transform_keys { |key| key.to_s rescue key }
+  end
+
+  # Returns a new hash with all keys converted to strings and the
+  # first letter capitalized.
+  #
+  # @return [Hash]
+  #
+  def capitalize_keys
+    transform_keys { |key| key.to_s.capitalize rescue key }
+  end
+
+  # Returns a new Hash, recursively converting all keys to strings
+  # and the first letter capitalized.
+  #
+  # @return [Hash]
+  #
+  def recursively_capitalize_key
+    recursively_transform_keys { |key| key.to_s.capitalize rescue key }
+  end
+
+  # Creates a new hash from two separate arrays, a +keys+ array and
+  # a +values+ array.
+  #
+  # @example
+  #   Hash.zip(['a','b','c'], [1,2,3])
+  #   # => { "a"=>1, "b"=>2, "c"=>3 }
+  #
+  def zip(col1, col2)
+    col1.zip(col2).inject({}) { |r, i| r[i[0]] = i[1]; r }
+  end
+
+  # Create a hash with *only* key/value pairs in receiver and +allowed+
+  #
+  #   { :one => 1, :two => 2, :three => 3 }.only(:one)    # => { :one => 1 }
+  #
+  # @param [Array[String, Symbol]] *allowed The hash keys to include.
+  #
+  # @return [Hash] A new hash with only the selected keys.
+  #
+  # @api public
+  def only(*allowed)
+    hash = {}
+    allowed.each {|k| hash[k] = self[k] if self.has_key?(k) }
+    hash
+  end
+
+  # Create a hash with all key/value pairs in receiver *except* +rejected+
+  #
+  #    { :one => 1, :two => 2, :three => 3 }.except(:one)
+  #     # => { :two => 2, :three => 3 }
+  #
+  # @param [Array[String, Symbol]] *rejected The hash keys to exclude.
+  #
+  # @return [Hash] A new hash without the selected keys.
+  #
+  # @api public
+  def except(*rejected)
+    hash = self.dup
+    rejected.each {|k| hash.delete(k) }
+    hash
+  end
+
+  class UndefinedPathError < StandardError; end
+  # Recursively searchs a nested datastructure for a key and returns
+  # the value. If a block is provided its value will be returned if
+  # the key does not exist
+  #
+  # @example
+  #     options = { server: { location: { row: { rack: 34 } } } }
+  #     options.recursive_fetch :server, :location, :row, :rack
+  #                 # => 34
+  #     options.recursive_fetch(:non_existent_key) { 'default' }
+  #                 # => "default"
+  #
+  # @return [Hash, Array, String] value for key
+  #
+  def recursive_fetch(*args, &block)
+    args.reduce(self) do |obj, arg|
+      begin
+        arg = Integer(arg) if obj.is_a? Array
+        obj.fetch(arg)
+      rescue ArgumentError, IndexError, NoMethodError => e
+        break block.call(arg) if block
+        raise UndefinedPathError,
+          "Could not fetch path (#{args.join(' > ')}) at #{arg}", e.backtrace
+      end
+    end
+  end
+
+  def recursive_merge(other)
+    hash = self.dup
+    other.each do |key, value|
+      myval = self[key]
+      if value.is_a?(Hash) && myval.is_a?(Hash)
+        hash[key] = myval.recursive_merge(value)
+      else
+        hash[key] = value
+      end
+    end
+    hash
+  end
+
+  private #   P R O P R I E T À   P R I V A T A   divieto di accesso
+
+  # support methods for recursively transforming nested hashes and arrays
+  def _recursively_transform_keys_in_object(object, &block)
+    case object
+    when Hash
+      object.each_with_object({}) do |(key, val), result|
+        result[yield(key)] = _recursively_transform_keys_in_object(val, &block)
+      end
+    when Array
+      object.map { |e| _recursively_transform_keys_in_object(e, &block) }
+    else
+      object
+    end
+  end
+end

data/lib/garcon/core_ext/kernel.rb

@@ -0,0 +1,159 @@
+# 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 #maybe
+module Kernel
+
+  # Random generator that returns true or false. Can also take a block that has
+  # a 50/50 chance to being executed.
+  #
+  def maybe(chance = 0.5, &block)
+    if block
+      yield if rand < chance
+    else
+      rand < chance
+    end
+  end
+
+  # Like #respond_to? but returns the result of the call if it does respond.
+  #
+  #   class RespondExample
+  #     def f; "f"; end
+  #   end
+  #
+  #   x = RespondExample.new
+  #   x.respond(:f)  # => "f"
+  #   x.respond(:g)  # => nil
+  #
+  # This method was known as #try until Rails defined #try
+  # to be something more akin to #ergo.
+  #
+  def respond(sym = nil, *args, &blk)
+    if sym
+      return nil unless respond_to?(sym)
+      __send__(sym, *args, &blk)
+    else
+      MsgFromGod.new(&method(:respond).to_proc)
+    end
+  end
+
+  # The opposite of #nil?.
+  #
+  #   "hello".not_nil?     # -> true
+  #   nil.not_nil?         # -> false
+  #
+  def not_nil?
+    ! nil?
+  end
+
+  # Temporarily set variables while yielding a block, then return the
+  # variables to their original settings when complete.
+  #
+  #   temporarily('$VERBOSE'=>false) do
+  #     $VERBOSE.assert == false
+  #   end
+  #
+  def temporarily(settings)
+    cache = {}
+    settings.each do |var, val|
+      cache[var] = eval("#{var}")
+      eval("proc{ |v| #{var} = v }").call(val)
+    end
+    yield
+  ensure
+    cache.each do |var, val|
+      eval("proc{ |v| #{var} = v }").call(val)
+    end
+  end
+
+  # Invokes the method identified by the symbol +method+, passing it any
+  # arguments  and/or the block specified, just like the regular Ruby
+  # `Object#send` does.
+  #
+  # *Unlike* that method however, a `NoMethodError` exception will *not*
+  # be raised and +nil+ will be returned instead, if the receiving object
+  # is a `nil` object or NilClass.
+  #
+  # For example, without try
+  #
+  #   @example = Struct.new(:name).new("bob")
+  #
+  #   @example && @example.name
+  #
+  # or:
+  #
+  #   @example ? @example.name : nil
+  #
+  # But with try
+  #
+  #   @example.try(:name)  #=> "bob"
+  #
+  # or
+  #
+  #   @example.try.name    #=> "bob"
+  #
+  # It also accepts arguments and a block, for the method it is trying:
+  #
+  #   @people.try(:collect){ |p| p.name }
+  #
+  def try(method=nil, *args, &block)
+    if method
+      __send__(method, *args, &block)
+    else
+      self
+    end
+  end
+
+  # Parse a caller string and break it into its components,
+  # returning an array composed of:
+  #
+  # * file (String)
+  # * lineno (Integer)
+  # * method (Symbol)
+  #
+  # For example, from irb
+  #
+  #     callstack(1)
+  #
+  # _produces_ ...
+  #
+  #     [["(irb)", 2, :irb_binding],
+  #       ["/usr/lib/ruby/1.8/irb/workspace.rb", 52, :irb_binding],
+  #       ["/usr/lib/ruby/1.8/irb/workspace.rb", 52, nil]]
+  #
+  # Note: If the user decides to redefine caller() to output data
+  # in a different format, _prior_ to requiring this, then the
+  # results will be indeterminate.
+  #
+  def callstack(level = 1)
+    call_str_array = pp_callstack(level)
+    stack = []
+    call_str_array.each{ |call_str|
+      file, lineno, method = call_str.split(':')
+      if method =~ /in `(.*)'/ then
+        method = $1.intern()
+      end
+      stack << [file, lineno.to_i, method]
+    }
+    stack
+  end
+  alias_method :call_stack, :callstack
+  alias_method :pp_callstack,  :caller
+  alias_method :pp_call_stack, :caller
+end