garcun 0.0.2

data/lib/garcon/core_ext/module.rb

@@ -0,0 +1,92 @@
+# 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 Module
+
+  # Create an instance of Object and extend it with +self+.
+  #
+  #   mod = Module.new do
+  #     def foo; "foo"; end
+  #   end
+  #
+  #   obj = mod.to_obj
+  #
+  #   obj.foo #=> "foo"
+  #
+  def to_obj
+    o = Object.new
+    o.extend self
+    o
+  end
+
+  # Creates a new method wrapping the previous of the same name.
+  # Reference to the old method is passed into the new definition
+  # block as the first parameter.
+  #
+  #   class WrapExample
+  #     def foo
+  #       "foo"
+  #     end
+  #
+  #     wrap_method(:foo) do |old_meth, *args|
+  #       old_meth.call + '!'
+  #     end
+  #   end
+  #
+  #   example = WrapExample.new
+  #   example.foo #=> 'foo!'
+  #
+  # Keep in mind that this cannot be used to wrap methods
+  # that take a block.
+  #
+  def wrap_method( sym, &blk )
+    old = instance_method(sym)
+    define_method(sym) { |*args| blk.call(old.bind(self), *args) }
+  end
+  alias_method :wrap, :wrap_method
+
+  unless method_defined?(:set)
+    # Sets an option to the given value. If the value is a proc,
+    # the proc will be called every time the option is accessed.
+    #
+    def set(option, value=self, &block)
+      raise ArgumentError if block && value != self
+      value = block if block
+      if value.kind_of?(Proc)
+        if value.arity == 1
+          yield self
+        else
+          (class << self; self; end).module_eval do
+            define_method(option, &value)
+            define_method("#{option}?"){ !!__send__(option) }
+            define_method("#{option}="){ |val| set(option, Proc.new{val}) }
+          end
+        end
+      elsif value == self
+        option.each{ |k,v| set(k, v) }
+      elsif respond_to?("#{option}=")
+        __send__("#{option}=", value)
+      else
+        set(option, Proc.new{value})
+      end
+      self
+    end
+  end
+end
+

data/lib/garcon/core_ext/nil.rb

@@ -0,0 +1,53 @@
+# 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 NilClass class.
+class NilClass
+  # Nil is always blank
+  #
+  # @example
+  #   nil.blank?        # =>  true
+  #
+  # @return [TrueClass]
+  #
+  # @api public
+  def blank?
+    true
+  end
+
+  # Calling `try` on `nil` always returns `nil`. It becomes especially helpful
+  # when navigating through associations that may return `nil`.
+  #
+  def try(*args)
+    nil
+  end
+
+  def try!(*args)
+    nil
+  end
+
+  # Since NilClass is immutable it cannot be duplicated.
+  # For this reason #try_dup returns +self+.
+  #
+  #   nil.dup!  #=> nil
+  #
+  def dup!   ; self  ; end
+  def dup?   ; false ; end
+  def clone? ; false ; end
+end

data/lib/garcon/core_ext/numeric.rb

@@ -0,0 +1,44 @@
+# 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 Numeric class.
+class Numeric
+  # Numerics are never blank
+  #
+  # @example
+  #   0.blank?          # =>  false
+  #   1.blank?          # =>  false
+  #   6.54321.blank?    # =>  false
+  #
+  # @return [FalseClass]
+  #
+  # @api public
+  def blank?
+    false
+  end
+
+  # Since Numeric is immutable it cannot be duplicated.
+  # For this reason #try_dup returns +self+.
+  #
+  #   1.dup!  #=> 1
+  #
+  def dup!   ; self  ; end
+  def dup?   ; false ; end
+  def clone? ; false ; end
+end

data/lib/garcon/core_ext/object.rb

@@ -0,0 +1,342 @@
+# 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?, #present?, #try and #try! methods to Object class.
+class Object
+
+  # Returns true if the object is nil or empty (if applicable)
+  #
+  # @example
+  #   [].blank?         # =>  true
+  #   [1].blank?        # =>  false
+  #   [nil].blank?      # =>  false
+  #
+  # @return [Boolean]
+  #
+  def blank?
+    nil? || (respond_to?(:empty?) && empty?)
+  end
+
+  # Returns true if the object is NOT nil or empty
+  #
+  # @example
+  #   [].present?         # =>  false
+  #   [1].present?        # =>  true
+  #   [nil].present?      # =>  true
+  #
+  # @return [Boolean]
+  #
+  def present?
+    !blank?
+  end
+
+  # Invokes the public method whose name goes as first argument just like
+  # `public_send` does, except that if the receiver does not respond to it the
+  # call returns `nil` rather than raising an exception.
+  #
+  # @note
+  #   `try` is defined on `Object`. Therefore, it won't work with instances
+  #   of classes that do not have `Object` among their ancestors, like direct
+  #   subclasses of `BasicObject`.
+  #
+  # @param [String] object
+  #
+  # @param [Symbol] method
+  #
+  # @return [Object]
+  #
+  def try(*a, &b)
+    try!(*a, &b) if a.empty? || respond_to?(a.first)
+  end
+
+  # Same as #try, but will raise a NoMethodError exception if the receiver is
+  # not `nil` and does not implement the tried method.
+  #
+  # @raise NoMethodError
+  #   If the receiver is not `nil` and does not implement the tried method.
+  #
+  # @return [Object]
+  #
+  def try!(*a, &b)
+    if a.empty? && block_given?
+      if b.arity.zero?
+        instance_eval(&b)
+      else
+        yield self
+      end
+    else
+      public_send(*a, &b)
+    end
+  end
+
+  # If receiver is callable, calls it and returns result. If not, just returns
+  # receiver itself.
+  #
+  # @return [Object]
+  #
+  def try_call(*args)
+    if self.respond_to?(:call)
+      self.call(*args)
+    else
+      self
+    end
+  end
+
+  # An identity method that provides access to an object's 'self'.
+  #
+  # Example
+  #   [1,2,3,4,5,1,2,2,3].group_by(&:itself)
+  #   #=> {1=>[1, 1], 2=>[2, 2, 2], 3=>[3, 3], 4=>[4], 5=>[5]}
+  #
+  def itself
+    self
+  end
+
+  # Override this in a child class if it cannot be dup'ed.
+  #
+  #   obj1 = Object.new
+  #   obj2 = obj1.dup!
+  #   obj2.equal?(obj1)    #=> false
+  #
+  # @return [Object]
+  #
+  def dup!
+    dup
+  end
+
+  # Alternative name for #dup!
+  #
+  # @return [Object]
+  #
+  def try_dup
+    dup!
+  end
+
+  # Can you safely call #dup on this object?
+  #
+  # Returns `false` for `nil`, `false`, `true`, symbols, and numbers;
+  # `true` otherwise.
+  #
+  # @return [Object]
+  #
+  def dup?   ; true ; end
+  def clone? ; true ; end
+
+  # Extracts the singleton class, so that metaprogramming can be done on it.
+  #
+  # @example [Setup]
+  #   class MyString < String; end
+  #
+  #   MyString.instance_eval do
+  #     define_method :foo do
+  #       puts self
+  #     end
+  #   end
+  #
+  #   MyString.meta_class.instance_eval do
+  #     define_method :bar do
+  #       puts self
+  #     end
+  #   end
+  #
+  #   def String.add_meta_var(var)
+  #     self.meta_class.instance_eval do
+  #       define_method var do
+  #         puts "HELLO"
+  #       end
+  #     end
+  #   end
+  #
+  # @example
+  #   MyString.new("Hello").foo # => "Hello"
+  #
+  # @example
+  #   MyString.new("Hello").bar
+  #     # => NoMethodError: undefined method `bar' for "Hello":MyString
+  #
+  # @example
+  #   MyString.foo
+  #     # => NoMethodError: undefined method `foo' for MyString:Class
+  #
+  # @example
+  #   MyString.bar
+  #     # => MyString
+  #
+  # @example
+  #   String.bar
+  #     # => NoMethodError: undefined method `bar' for String:Class
+  #
+  # @example
+  #   MyString.add_meta_var(:x)
+  #   MyString.x # => HELLO
+  #
+  # @details [Description of Examples]
+  #   As you can see, using #meta_class allows you to execute code (and here,
+  #   define a method) on the metaclass itself. It also allows you to define
+  #   class methods that can be run on subclasses, and then be able to execute
+  #   code on the metaclass of the subclass (here MyString).
+  #
+  #   In this case, we were able to define a class method (add_meta_var) on
+  #   String that was executable by the MyString subclass. It was then able to
+  #   define a method on the subclass by adding it to the MyString metaclass.
+  #
+  # @return [Class]
+  #   The meta class.
+  #
+  def meta_class() class << self; self end end
+
+  # @param [String] name
+  #   The name of the constant to get, e.g. "Garcon::Check".
+  #
+  # @return [Object]
+  #   The constant corresponding to the name.
+  #
+  def full_const_get(name)
+    list = name.split('::')
+    list.shift if list.first.blank?
+    obj = self
+    list.each do |x|
+      obj = obj.const_defined?(x) ? obj.const_get(x) : obj.const_missing(x)
+    end
+    obj
+  end
+
+  # @param [String] name
+  #   The name of the constant to get, e.g. "Garcon::Check".
+  #
+  # @param [Object] value
+  #   The value to assign to the constant.
+  #
+  # @return [Object]
+  #   The constant corresponding to the name.
+  #
+  def full_const_set(name, value)
+    list = name.split('::')
+    toplevel = list.first.blank?
+    list.shift if toplevel
+    last = list.pop
+    obj = list.empty? ? Object : Object.full_const_get(list.join('::'))
+    obj.const_set(last, value) if obj && !obj.const_defined?(last)
+  end
+
+  # Defines module from a string name (e.g. Foo::Bar::Baz). If module already
+  # exists, no exception raised.
+  #
+  # @param [String] name
+  #   The name of the full module name to make
+  #
+  # @return [nil]
+  #
+  def make_module(string)
+    current_module = self
+    string.split('::').each do |part|
+      current_module = if current_module.const_defined?(part)
+        current_module.const_get(part)
+      else
+        current_module.const_set(part, Module.new)
+      end
+    end
+    current_module
+  end
+
+  # @param [Symbol, Class, Array] duck
+  #   The thing to compare the object to.
+  #
+  # @note
+  #   The behavior of the method depends on the type of duck as follows:
+  #   Symbol:: Check whether the object respond_to?(duck).
+  #   Class::  Check whether the object is_a?(duck).
+  #   Array::  Check whether the object quacks_like? at least one of the
+  #            options in the array.
+  #
+  # @return [Boolean]
+  #   True if the object quacks like a duck.
+  #
+  def quacks_like?(duck)
+    case duck
+    when Symbol
+      self.respond_to?(duck)
+    when Class
+      self.is_a?(duck)
+    when Array
+      duck.any? { |d| self.quacks_like?(d) }
+    else
+      false
+    end
+  end
+
+  # @example 1.in?([1,2,3]) # => true
+  #
+  # @example 1.in?(1,2,3) # => true
+  #
+  # @param [#include?] arrayish
+  #   Container to check, to see if it includes the object.
+  #
+  # @param [Array] *more
+  #   additional args, will be flattened into arrayish
+  #
+  # @return [Boolean]
+  #   True if the object is included in arrayish (+ more)
+  #
+  def in?(arrayish, *more)
+    arrayish = more.unshift(arrayish) unless more.empty?
+    arrayish.include?(self)
+  end
+
+  # Get or set state of object. You can think of #object_state as an in-code
+  # form of marshalling.
+  #
+  #   class StateExample
+  #     attr_reader :a, :b
+  #     def initialize(a,b)
+  #       @a, @b = a, b
+  #     end
+  #   end
+  #
+  #   obj = StateExample.new(1,2)
+  #   obj.a  #=> 1
+  #   obj.b  #=> 2
+  #
+  #   obj.object_state  #=> {:a=>1, :b=>2}
+  #
+  #   obj.object_state(:a=>3, :b=>4)
+  #   obj.a  #=> 3
+  #   obj.b  #=> 4
+  #
+  # For most object's this is essentially the same as `instance.to_h`.
+  # But for data structures like Array and Hash it returns a snapshot of their
+  # contents, not the state of their instance variables.
+  #
+  def object_state(data = nil)
+    if data
+      instance_variables.each do |iv|
+        name = iv.to_s.sub(/^[@]/, '').to_sym
+        instance_variable_set(iv, data[name])
+      end
+    else
+      data = {}
+      instance_variables.each do |iv|
+        name = iv.to_s.sub(/^[@]/, '').to_sym
+        data[name] = instance_variable_get(iv)
+      end
+      data
+    end
+  end
+end