rango 0.0.3

data/lib/rango/ext.rb

@@ -0,0 +1,14 @@
+# coding: utf-8
+
+require_relative "ext/class"
+require_relative "ext/attribute"
+require_relative "ext/core_ext"
+require_relative "ext/kernel"
+require_relative "ext/path"
+require_relative "ext/hash"
+require_relative "ext/string"
+require_relative "ext/colored_string"
+require_relative "ext/random"
+require_relative "ext/try"
+require_relative "ext/object_space"
+require_relative "ext/time_dsl"

data/lib/rango/ext/attribute.rb

@@ -0,0 +1,140 @@
+# coding: utf-8
+
+# TODO: refactor similar as attr_accessor_with_default from active support
+# see http://noobkit.com/show/ruby/rails/rails-stable/activesupport/module/attr_accessor_with_default.html
+
+require "extlib"
+
+# default value for attr
+module AttributeMixin
+  # @since 0.0.1
+  # @example
+  #   class Post
+  #     attribute :title, "Rango rulez!"
+  #   end
+  # Post.new.title
+  # # => "Rango rulez!"
+  # @param [Symbol] name Name of object variable which will be set. If you have <tt>attribute :title</tt>, then the +@title+ variable will be defined. It also create +#title+ and +#title=+ accessors.
+  # @param [Object, @optional] default_value Default value of the variable.
+  # @return [name] Returns given default value or if default value.
+  # @see #hattribute
+  def attribute(name, default_value = nil)
+    # define reader method
+    define_method(name) do
+      if instance_variable_get("@#{name}").nil?
+        # lazy loading
+        # TODO: why is it lazy loaded?
+        default_value = default_value.call if default_value.is_a?(Proc)
+        instance_variable_set("@#{name}", default_value.try_dup) # dup is terribly important, otherwise all the objects will points to one object. If it is for example array, all of the objects will push into one array.
+      end
+      instance_variable_get("@#{name}")
+    end
+
+    # define writer method
+    define_method("#{name}=") do |value|
+      instance_variable_set("@#{name}", value)
+      # TODO: here should be rewritten the reader for cases when user want to do foo.bar = nil because now it will still returns the default value
+    end
+
+    return default_value
+  end
+
+  # This will also define title and title= methods, but it doesn't define @title variable,
+  # but @__hattributes__ hash with all the attributes
+
+  # @since 0.0.1
+  # @example
+  #   class Post
+  #     hattribute :title, "Rango rulez!"
+  #   end
+  #   Post.new.title
+  #   # => "Rango rulez!"
+  # @param [Symbol] name Name of attribute his accessor methods will be defined. It's similar as +#attribute+, but it doesn't define +@name+ variable, but it will be key in +@__hattributes__+ hash. It's useful when you don't like to mess the object namespace with many variables or if you like to separate the attributes from the instance variables.
+  # @param [Object, @optional] default_value Default value of the variable.
+  # @return [name] Returns given default value or if default value.
+  # @see #attribute
+  def default_hattribute_names
+    # this can't be hash because in case the value will be lambda, we can't call it,
+    # because lambda is evaluated in scope of instance
+    @default_hattribute_names ||= Array.new
+  end
+
+  def hattribute(name, default_value = nil)
+    self.default_hattribute_names.push(name)
+
+    define_method(:hattributes) do
+      @__hattributes__ ||= Hash.new
+      # this is importat for initialization @__hattributes__
+      self.class.default_hattribute_names.each do |hattribute|
+        self.send(hattribute)
+      end
+      return @__hattributes__
+    end
+
+    # define reader method
+    if default_value.is_a?(Proc)
+      define_method(name) do
+        properties = instance_variable_get("@__hattributes__") || Hash.new
+        if properties[name].nil?
+          # instance_variable_set("@#{name}", default_value)
+          # lazy loading
+          properties[name] = self.instance_eval(&default_value)
+        end
+        # instance_variable_get("@#{name}")
+        properties[name]
+      end
+    else
+      define_method(name) do
+        properties = instance_variable_get("@__hattributes__") || Hash.new
+        # properties = @__hattributes__
+        if properties[name].nil?
+          # instance_variable_set("@#{name}", default_value)
+          # lazy loading
+          properties[name] = default_value.try_dup
+        end
+        # instance_variable_get("@#{name}")
+        properties[name]
+      end
+    end
+
+    # define writer method
+    define_method("#{name}=") do |value|
+      instance_variable_set("@__hattributes__", Hash.new) unless instance_variable_get("@__hattributes__")
+      instance_variable_get("@__hattributes__")[name] = value
+    end
+
+    return default_value
+  end
+
+  # class << self.class
+  #   def hattributes
+  #     raise "Y"
+  #   end
+  # end
+
+  # class Post
+  #   questionable :updated, true
+  # end
+  # Post.new.updated?
+  # # => true
+  # @since 0.0.2
+  def questionable(name, default_value)
+    define_method("#{name}?") do
+      unless self.instance_variables.include?(name.to_sym)
+        self.instance_variable_set("@#{name}", default_value)
+      end
+      self.instance_variable_get("@#{name}")
+    end
+  end
+end
+
+Class.send(:include, AttributeMixin)
+Module.send(:include, AttributeMixin)
+
+# class Test
+#   hattribute :bar, -> { "value" }
+# end
+#
+# t = Test.new
+# p t.bar
+# p t.hattributes

data/lib/rango/ext/class.rb

@@ -0,0 +1,99 @@
+# coding: utf-8
+
+# class Test
+#   extend Rango::Hookable
+#   install_hook do |instance|
+#     p instance
+#   end
+#
+#   def initialize
+#     p self
+#   end
+# end
+#
+# Test.new
+
+class Rango
+  module Hookable
+    def new(*args)
+      instance = super(*args)
+      self.hooks.each { |hook| hook.call(instance) }
+      return instance
+    end
+
+    def hooks
+      @hooks ||= Array.new
+    end
+
+    def install_hook(&block)
+      self.hooks.push(block)
+    end
+  end
+end
+
+# from merb-core
+class Rango
+  module Chainable
+    # Allows the definition of methods on a class that will be available via
+    # super.
+    #
+    # ==== Examples
+    #     class Foo
+    #       extend Rango::Chainable
+    #       chainable do
+    #         def hello
+    #           "hello"
+    #         end
+    #       end
+    #     end
+    #
+    #     class Foo
+    #       def hello
+    #         super + " Merb!"
+    #       end
+    #     end
+    #
+    # # Example with mixin:
+    # module TestMixin
+    #   extend Rango::Chainable
+    #   chainable do
+    #     def test
+    #       "from mixin!"
+    #     end
+    #   end
+    # end
+    #
+    # class Test
+    #   include TestMixin
+    #   def test
+    #     "hello " + super
+    #   end
+    # end
+    #
+    # puts Test.new.test
+    #
+    #
+    # Foo.new.hello #=> "hello Merb!"
+    #
+    # ==== Parameters
+    # &block::
+    #   a block containing method definitions that should be
+    #   marked as chainable
+    #
+    # ==== Returns
+    # Module:: The anonymous module that was created
+    def chainable(method = nil, &block)
+      if method.nil? && block_given?
+        mixin = Module.new(&block)
+        include mixin
+        return mixin
+      elsif method && ! block_given?
+        # TODO
+        # def test
+        #   # ...
+        # end
+        # chainable :test
+      end
+    end
+  end
+end

data/lib/rango/ext/colored_string.rb

@@ -0,0 +1,105 @@
+# coding: utf-8
+
+require "delegate"
+require "extlib"
+require_relative "string"
+require_relative "attribute"
+
+class ColoredString
+  ATTRIBUTES = {
+    clear: 0,
+    reset: 0,         # synonym for :clear
+    bold: 1,
+    dark: 2,
+    italic: 3,        # not widely implemented
+    underline: 4,
+    underscore: 4,    # synonym for :underline
+    blink: 5,
+    rapid_blink: 6,   # not widely implemented
+    negative: 7,      # no reverse because of String#reverse
+    concealed: 8,
+    strikethrough: 9, # not widely implemented
+    black: 30,
+    red: 31,
+    green: 32,
+    yellow: 33,
+    blue: 34,
+    magenta: 35,
+    cyan: 36,
+    white: 37,
+    on_black: 40,
+    on_red: 41,
+    on_green: 42,
+    on_yellow: 43,
+    on_blue: 44,
+    on_magenta: 45,
+    on_cyan: 46,
+    on_white: 47,
+  }
+
+  class << self
+    # ColoredString.coloring?
+    # Returns true, if the coloring function of this module
+    # is switched on, false otherwise.
+    #
+    # ColoredString.coloring = boolean
+    # Turns the coloring on or off globally, so you can easily do
+    # this for example:
+    #  Term::ANSIColor::coloring = STDOUT.isatty
+    questionable :coloring, true
+
+    # <red.bold>Title</red.bold>
+    # - u, i/em, b/strong
+    def template(string)
+      return string # TODO
+    end
+  end
+
+  attr_accessor :colors
+  def initialize(string = "")
+    @string = string
+    @colors = Array.new
+  end
+
+  ATTRIBUTES.each do |color, code|
+    define_method(color) do
+      @colors.push(color)
+      self
+    end
+  end
+
+  def to_s
+    if ! @colors.empty? && self.class.coloring?
+      sequences = ""
+      @colors.each do |name|
+        code = ATTRIBUTES[name]
+        sequences << "\e[#{code}m"
+      end
+      return "#{sequences}#{@string}\e[0m"
+    else
+      @string
+    end
+  end
+
+  def inspect
+    "#<ColoredString:#@string>"
+  end
+
+  def raw
+    @string
+  end
+
+  def method_missing(method, *args, &block)
+    returned = @string.send(method, *args, &block)
+    # Bang methods like upcase!
+    if returned.is_a?(String) and @string.equal?(returned) # same object
+      @string.replace(returned)
+      return self
+    # upcase
+    elsif returned.is_a?(String) and not @string.equal?(returned) # different object
+      return self.class.new(returned)
+    else # not string, String#split etc
+      return returned
+    end
+  end
+end

data/lib/rango/ext/core_ext.rb

@@ -0,0 +1,52 @@
+# coding: utf-8
+
+# TODO: spec it
+class Hash
+  # @since 0.0.2
+  def to_html_attrs
+    self.map { |key, value| "#{key}='#{value}'" }.join(" ")
+  end
+
+  def symbolize_keys
+    output = Hash.new
+    self.each do |key, value|
+      output[key.to_sym] = value
+    end
+    return output
+  end
+
+  def symbolize_keys!
+    self.replace(self.symbolize_keys)
+  end
+
+  def deep_symbolize_keys
+    output = Hash.new
+    self.each do |key, value|
+      if value.is_a?(Hash)
+        output[key.to_sym] = value.symbolize_keys
+      else
+        output[key.to_sym] = value
+      end
+    end
+    return output
+  end
+
+  def deep_symbolize_keys!
+    self.replace(self.deep_symbolize_keys)
+  end
+
+  # Returns the value of self for each argument and deletes those entries.
+  #
+  # ==== Parameters
+  # *args:: the keys whose values should be extracted and deleted.
+  #
+  # ==== Returns
+  # Array[Object]:: The values of the provided arguments in corresponding order.
+  #
+  # :api: public
+  def extract!(*args)
+    args.map do |arg|
+      self.delete(arg)
+    end
+  end
+end

data/lib/rango/ext/hash.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+
+class Hash
+  def to_url_attrs
+    self.map { |key, value| "#{key}=#{value}" }.join("&")
+  end
+
+  def to_native
+    self.each do |key, value|
+      value = case value
+      when "true" then true
+      when "false" then false
+      when "nil" then nil
+      when /^\d+$/ then value.to_i
+      when /^\d+\.\d+$/ then value.to_f
+      else value end
+      self[key.to_sym] = value
+    end
+    return self
+  end
+end

data/lib/rango/ext/kernel.rb

@@ -0,0 +1,74 @@
+# coding: utf-8
+
+module Kernel
+  # @since 0.0.2
+  def metaclass
+    class << self
+      self
+    end
+  end
+
+  # @since 0.0.1
+  # @example
+  #   try_require "term/ansicolor", "term-ansicolor"
+  # @param [String] library Library to require.
+  # @param [String, @optional] gemname Name of gem which contains required library. Will be used for displaying message.
+  # @return [Boolean] True if require was successful, false otherwise.
+  def try_require(library, gemname = library)
+    begin
+      require library
+    rescue LoadError
+      message = "Gem #{gemname} isn't installed. Run sudo gem install #{gemname}."
+      if defined?(Rango.logger)
+        Rango.logger.warn(message)
+        return false
+      else
+        puts(message)
+        return false
+      end
+    end
+  end
+
+  def command(command)
+    puts command
+    puts %x[#{command}]
+  end
+
+  def quiet(&block)
+    old_stdout = STDOUT.dup
+    STDOUT.reopen("/dev/null")
+    returned = block.call
+    STDOUT.reopen(old_stdout)
+    return returned
+  end
+
+  def quiet!(&block)
+    old_stderr = STDERR.dup
+    STDERR.reopen("/dev/null", "a")
+    returned = quiet(&block)
+    STDERR.reopen(old_stderr)
+    return returned
+  end
+
+
+  # TODO: try_require and try_require_gem (diff require 'readline' vs require 'term/ansicolor')
+
+  # for quick inspection
+  # @since 0.0.2
+  def puts_and_return(*args)
+    puts(*args)
+    return *args
+  end
+
+  # @since 0.0.2
+  def p_and_return(*args)
+    p(*args)
+    return *args
+  end
+end
+
+class Class
+  def controller?
+    false
+  end
+end