garcun 0.0.2 → 0.0.3

data/lib/garcon/core_ext/lazy.rb

@@ -1,222 +0,0 @@
-# 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.
-#
-
-# Lazy ass Ruby.
-#
-module Lazy
-  # Raised when a demanded computation diverges (e.g. if it tries to directly
-  # use its own result)
-  #
-  class DivergenceError < Exception
-    def initialize(message = 'Computation diverges')
-      super(message)
-    end
-  end
-
-  # Wraps an exception raised by a lazy computation.
-  #
-  # The reason we wrap such exceptions in LazyException is that they need to
-  # be distinguishable from similar exceptions which might normally be raised
-  # by whatever strict code we happen to be in at the time.
-  #
-  class LazyException < DivergenceError
-    attr_reader :reason
-
-    def initialize(reason)
-      @reason = reason
-      super "Exception in lazy computation: #{reason} (#{reason.class})"
-      set_backtrace(reason.backtrace.dup) if reason
-    end
-  end
-
-  # A handle for a promised computation.  They are transparent, so that in
-  # most cases, a promise can be used as a proxy for the computation's result
-  # object.  The one exception is truth testing -- a promise will always look
-  # true to Ruby, even if the actual result object is nil or false.
-  #
-  # If you want to test the result for truth, get the unwrapped result object
-  # via Kernel.demand.
-  #
-  class Promise
-    alias __class__ class
-    instance_methods.each do |method|
-      undef_method method unless method =~ /^(__|object_|instance_)/
-    end
-
-    def initialize(&computation)
-      @computation = computation
-    end
-
-    def __synchronize__
-      yield
-    end
-
-    # Create this once here, rather than creating a proc object for every
-    # evaluation.
-    DIVERGES = lambda { raise DivergenceError.new }
-
-    # Differentiate inspection of DIVERGES lambda.
-    def DIVERGES.inspect
-      'DIVERGES'
-    end
-
-    def __result__
-      __synchronize__ do
-        if @computation
-          raise LazyException.new(@exception) if @exception
-
-          computation  = @computation
-          @computation = DIVERGES
-
-          begin
-            @result = demand(computation.call(self))
-            @computation = nil
-          rescue DivergenceError
-            raise
-          rescue Exception => e
-            @exception = e
-            raise LazyException.new(@exception)
-          end
-        end
-
-        @result
-      end
-    end
-
-    def inspect
-      __synchronize__ do
-        if @computation
-          "#<#{__class__} computation=#{@computation.inspect}>"
-        else
-          @result.inspect
-        end
-      end
-    end
-
-    def respond_to?(message)
-      message  = message.to_sym
-      message == :__result__ or
-      message == :inspect    or
-      __result__.respond_to? message
-    end
-
-    def method_missing(*args, &block)
-      __result__.__send__(*args, &block)
-    end
-  end
-
-  # Thread safe version of Promise class.
-  #
-  class PromiseSafe < Promise
-    def __synchronize__
-      current = Thread.current
-
-      Thread.critical = true
-      unless @computation
-        Thread.critical = false
-        yield
-      else
-        if @owner == current
-          Thread.critical = false
-          raise DivergenceError.new
-        end
-        while @owner
-          Thread.critical = false
-          Thread.pass
-          Thread.critical = true
-        end
-        @owner = current
-        Thread.critical = false
-
-        begin
-          yield
-        ensure
-          @owner = nil
-        end
-      end
-    end
-  end
-
-  # Future class subclasses PromiseSafe.
-  #
-  class Future < PromiseSafe
-    def initialize(&computation)
-      result    = nil
-      exception = nil
-      thread    = Thread.new do
-        begin
-          result = computation.call(self)
-        rescue Exception => exception
-        end
-      end
-
-      super do
-        raise DivergenceError.new if Thread.current == thread
-        thread.join
-        raise exception if exception
-        result
-      end
-    end
-  end
-end
-
-module Kernel
-  # The promise() function is used together with demand() to implement
-  # lazy evaluation.  It returns a promise to evaluate the provided
-  # block at a future time.  Evaluation can be demanded and the block's
-  # result obtained via the demand() function.
-  #
-  # Implicit evaluation is also supported: the first message sent to it will
-  # demand evaluation, after which that message and any subsequent messages
-  # will be forwarded to the result object.
-  #
-  # As an aid to circular programming, the block will be passed a promise
-  # for its own result when it is evaluated.  Be careful not to force
-  # that promise during the computation, lest the computation diverge.
-  #
-  def promise(&computation)
-    Lazy::Promise.new(&computation)
-  end
-
-  # Forces the result of a promise to be computed (if necessary) and returns
-  # the bare result object.  Once evaluated, the result of the promise will
-  # be cached.  Nested promises will be evaluated together, until the first
-  # non-promise result.
-  #
-  # If called on a value that is not a promise, it will simply return it.
-  #
-  def demand(promise)
-    if promise.respond_to? :__result__
-      promise.__result__
-    else
-      promise
-    end
-  end
-
-  # Schedules a computation to be run asynchronously in a background thread
-  # and returns a promise for its result.  An attempt to demand the result of
-  # the promise will block until the computation finishes.
-  #
-  # As with Kernel.promise, this passes the block a promise for its own result.
-  # Use wisely.
-  #
-  def future(&computation)
-    Lazy::Future.new(&computation)
-  end
-end

data/lib/garcon/core_ext/process.rb

@@ -1,41 +0,0 @@
-# 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/utility/ansi.rb

@@ -1,199 +0,0 @@
-# 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
-
-  # ANSI Mixin Module
-  #
-  # Standard use is to mix this module into String.
-  #
-  # @example Mix this module into String to enable easy ANSI coloring methods
-  # like:
-  #   "bold red".red.bold
-  #
-  # @example Or
-  #   "green".green
-  #
-  module ANSI
-    extend self
-
-    # Defines our ANSI color codes
-    ANSI_COLORS = {
-      black:   30,
-      red:     31,
-      green:   32,
-      yellow:  33,
-      blue:    34,
-      magenta: 35,
-      cyan:    36,
-      white:   37
-    }
-
-    # @!method black(string=nil, &block)
-    #   Sets the foreground color to black for the supplied string.
-    #   @param [String] string The string to operate on.
-    #   @yieldreturn [String] The string to operate on.
-    #   @return [String] The colored string.
-    #
-    # @!method red(string=nil, &block)
-    #   Sets the foreground color to red for the supplied string.
-    #   @param [String] string The string to operate on.
-    #   @yieldreturn [String] The string to operate on.
-    #   @return [String] The colored string.
-    #
-    # @!method green(string=nil, &block)
-    #   Sets the foreground color to green for the supplied string.
-    #   @param [String] string The string to operate on.
-    #   @yieldreturn [String] The string to operate on.
-    #   @return [String] The colored string.
-    #
-    # @!method yellow(string=nil, &block)
-    #   Sets the foreground color to yellow for the supplied string.
-    #   @param [String] string The string to operate on.
-    #   @yieldreturn [String] The string to operate on.
-    #   @return [String] The colored string.
-    #
-    # @!method blue(string=nil, &block)
-    #   Sets the foreground color to blue for the supplied string.
-    #   @param [String] string The string to operate on.
-    #   @yieldreturn [String] The string to operate on.
-    #   @return [String] The colored string.
-    #
-    # @!method magenta(string=nil, &block)
-    #   Sets the foreground color to magenta for the supplied string.
-    #   @param [String] string The string to operate on.
-    #   @yieldreturn [String] The string to operate on.
-    #   @return [String] The colored string.
-    #
-    # @!method cyan(string=nil, &block)
-    #   Sets the foreground color to cyan for the supplied string.
-    #   @param [String] string The string to operate on.
-    #   @yieldreturn [String] The string to operate on.
-    #   @return [String] The colored string.
-    #
-    # @!method white(string=nil, &block)
-    #   Sets the foreground color to white for the supplied string.
-    #   @param [String] string The string to operate on.
-    #   @yieldreturn [String] The string to operate on.
-    #   @return [String] The colored string.
-
-    # Defines our ANSI attribute codes
-    ANSI_ATTRIBUTES = {
-      normal: 0,
-      bold:   1
-    }
-
-    # @!method normal(string=nil, &block)
-    #   Sets the foreground color to normal for the supplied string.
-    #   @param [String] string The string to operate on.
-    #   @yieldreturn [String] The string to operate on.
-    #   @return [String] The colored string.
-    #
-    # @!method bold(string=nil, &block)
-    #   Sets the foreground color to bold for the supplied string.
-    #   @param [String] string The string to operate on.
-    #   @yieldreturn [String] The string to operate on.
-    #   @return [String] The colored string.
-
-    # Defines a RegEx for stripping ANSI codes from strings
-    ANSI_REGEX = /\e\[([0-9]{1,2}(;[0-9]{1,2})?)?[m|K]/
-
-    # Dynamicly constructs ANSI methods for the color methods based on the ANSI
-    # code hash passed in.
-    #
-    # @param [Hash] hash
-    #   A hash where the keys represent the method names and the values are the
-    #   ANSI codes.
-    #
-    # @return [Boolean]
-    #   True if successful.
-    #
-    def build_ansi_methods(hash)
-      hash.each do |key, value|
-
-        define_method(key) do |string=nil, &block|
-          result = Array.new
-
-          result << %(\e[#{value}m)
-          if block_given?
-            result << block.call
-          elsif string.respond_to?(:to_str)
-            result << string.to_str
-          elsif respond_to?(:to_str)
-            result << to_str
-          else
-            return result
-          end
-          result << %(\e[0m)
-
-          result.join
-        end
-      end
-
-      true
-    end
-
-    # Removes ANSI code sequences from a string.
-    #
-    # @param [String] string
-    #   The string to operate on.
-    #
-    # @yieldreturn [String]
-    #   The string to operate on.
-    #
-    # @return [String]
-    #   The supplied string stripped of ANSI codes.
-    #
-    def uncolor(string = nil, &block)
-      if block_given?
-        block.call.to_str.gsub(ANSI_REGEX, '')
-      elsif string.respond_to?(:to_str)
-        string.to_str.gsub(ANSI_REGEX, '')
-      elsif respond_to?(:to_str)
-        to_str.gsub(ANSI_REGEX, '')
-      else
-        ''
-      end
-    end
-
-    def reset(string = nil, &block)
-      result = Array.new
-
-      result << %(\e[2J)
-      if block_given?
-        result << block.call
-      elsif string.respond_to?(:to_str)
-        result << string.to_str
-      elsif respond_to?(:to_str)
-        result << to_str
-      else
-        return result
-      end
-
-      result.join
-    end
-
-    def goto(x=0, y=0)
-      %(\e[#{x};#{y}H)
-    end
-
-    build_ansi_methods(ANSI_COLORS)
-    build_ansi_methods(ANSI_ATTRIBUTES)
-  end
-end

data/lib/garcon/utility/equalizer.rb

@@ -1,146 +0,0 @@
-# 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
-  # Define equality, equivalence and inspection methods.
-  #
-  class Equalizer
-
-    # Initialize an Equalizer with the given keys.
-    #
-    # Will use the keys with which it is initialized to define #cmp?,
-    # #hash, and #inspect
-    #
-    # @param [String] name
-    #
-    # @param [Array<Symbol>] keys
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def initialize(name, keys = [])
-      @name = name.dup.freeze
-      @keys = keys.dup
-      define_methods
-      include_comparison_methods
-    end
-
-    # Append a key and compile the equality methods.
-    #
-    # @return [Equalizer] self
-    #
-    # @api private
-    def <<(key)
-      @keys << key
-      self
-    end
-
-    private #        P R O P R I E T À   P R I V A T A   Vietato L'accesso
-
-    # Define the equalizer methods based on #keys.
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def define_methods
-      define_cmp_method
-      define_hash_method
-      define_inspect_method
-    end
-
-    # Define an #cmp? method based on the instance's values identified by #keys.
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def define_cmp_method
-      keys = @keys
-      define_method(:cmp?) do |comparator, other|
-        keys.all? { |key| send(key).send(comparator, other.send(key)) }
-      end
-    end
-
-    # Define a #hash method based on the instance's values identified by #keys.
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def define_hash_method
-      keys = @keys
-      define_method(:hash) do
-        keys.map { |key| send(key) }.push(self.class).hash
-      end
-    end
-
-    # Define an inspect method that reports the values of the instance's keys.
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def define_inspect_method
-      name, keys = @name, @keys
-      define_method(:inspect) do
-        "#<#{name}#{keys.map { |key| " #{key}=#{send(key).inspect}" }.join}>"
-      end
-    end
-
-    # Include the #eql? and #== methods
-    #
-    # @return [undefined]
-    #
-    # @api private
-    def include_comparison_methods
-      module_eval { include Methods }
-    end
-
-    # The comparison methods
-    module Methods
-
-      # Compare the object with other object for equality.
-      #
-      # @example
-      #   object.eql?(other)  # => true or false
-      #
-      # @param [Object] other
-      #   the other object to compare with
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def eql?(other)
-        instance_of?(other.class) && cmp?(__method__, other)
-      end
-
-      # Compare the object with other object for equivalency.
-      #
-      # @example
-      #   object == other  # => true or false
-      #
-      # @param [Object] other
-      #   the other object to compare with
-      #
-      # @return [Boolean]
-      #
-      # @api public
-      def ==(other)
-        other.kind_of?(self.class) && cmp?(__method__, other)
-      end
-    end
-  end
-end

data/lib/garcon/utility/msg_from_god.rb

@@ -1,62 +0,0 @@
-
-# God speaks in Ruby, not Python!! MsgFromGod is an implementation of a
-# Higher-Order-Message. Essentally, a MsgFromGod can vary its behavior
-# accorrding to the operation applied to it.
-#
-# @example
-#   g = MsgFromGod.new { |op, x| x.send(op, x) }
-#   (g + 1)  # => 2
-#   (g + 2)  # => 4
-#   (g + 3)  # => 6
-#   (g * 1)  # => 1
-#   (g * 2)  # => 4
-#   (g * 3)  # => 9
-#
-class MsgFromGod
-
-  # MsgFromGod can be somewhat inefficient if a new MsgFromGod is frequently
-  # recreated for the same use. So this cache can be used to speed things up.
-  #
-  # The key will always be an array, wich makes it easier to cache MsgFromGod
-  # for multiple factors.
-  #
-  def self.cache(*key, &function)
-    @cache ||= {}
-    if function
-      @cache[key] = new(&function)
-    else
-      @cache[key]
-    end
-  end
-
-  EXCEPTIONS = [:binding, :inspect, :object_id]
-  if defined?(::BasicObject)
-    EXCEPTIONS.concat(::BasicObject.instance_methods)
-    EXCEPTIONS.uniq!
-    EXCEPTIONS.map! { |m| m.to_sym }
-  end
-
-  alias :__class__ :class
-
-  # Privatize all methods except vital methods and #binding.
-  instance_methods(true).each do |m|
-    next if m.to_s =~ /^__/
-    next if EXCEPTIONS.include?(m.to_sym)
-    undef_method(m)
-  end
-
-  def initialize(&function)
-    @function = function
-  end
-
-  def to_proc
-    @function
-  end
-
-  private #        P R O P R I E T À   P R I V A T A   Vietato L'accesso
-
-  # Any action against the MsgFromGod is processesd by the function.
-  def method_missing(op, *args, &blk)
-    @function.call(op, *args, &blk)
-  end
-end