rubyexts 0.0.1

data/lib/rubyexts/module.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+# Extends the module object with module and instance accessors for class attributes, 
+# just like the native attr* accessors for instance attributes.
+#
+#  module AppConfiguration
+#    mattr_accessor :google_api_key
+#    self.google_api_key = "123456789"
+#
+#    mattr_accessor :paypal_url
+#    self.paypal_url = "www.sandbox.paypal.com"
+#  end
+#
+#  AppConfiguration.google_api_key = "overriding the api key!"
+class Module
+  def mattr_reader(*syms)
+    syms.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      EOS
+    end
+  end
+
+  def mattr_writer(*syms)
+    syms.each do |sym|
+      class_eval(<<-EOS, __FILE__, __LINE__)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+      EOS
+    end
+  end
+
+  def mattr_accessor(*syms)
+    mattr_reader(*syms)
+    mattr_writer(*syms)
+  end
+end

data/lib/rubyexts/object.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+
+class Object
+  # *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.
+  #
+  # Invokes the method identified by the symbol +method+, passing it any arguments
+  # and/or the block specified, just like the regular Ruby <tt>Object#send</tt> does.
+  #
+  # @author Botanicus
+  # @since 0.0.3
+  # @return [Object, nil] Return value of object.send(method) if object respond to method or nil
+  # @param [Symbol] Method which will be called on object if object respond to this method
+  # @param [Object, optional] Arguments for +method+ argument
+  # @yield [block, optional] Block for +method+ argument
+  # @example
+  #   @post.try(:name) # instead @post && @post.name
+  #   eBook.try(:find, 1)
+  #   @post.try(:collect) { |p| p.name }
+  def try(method, *args, &block)
+    self.send(method, *args, &block) if self.respond_to?(method)
+  end
+
+  # The opposite of <tt>#nil?</tt>.
+  #
+  # @author Botanicus
+  # @since 0.0.3
+  # @return [true, false] True if self is nil, false otherwise
+  def not_nil?
+    not self.nil?
+  end
+
+  # Defines a instance method on class of the object.
+  # 
+  # @author Botanicus
+  # @since 0.0.3
+  # @param [Symbol] Method name
+  # @param [Method, Proc, optional] +Method+ or +Proc+ which will be used as body of the method
+  # @yield [block] Block which will be used as body of the method
+  # @return [Object] First (and only) item of the array
+  # @see <tt>Module#define_singleton_method</tt> for define method on singleton class
+  # @example
+  #   class Experiment
+  #     def method_generator
+  #       define_instance_method(:new_method) do |arg|
+  #         puts "Method :new_method called with #{arg}"
+  #       end
+  #     end
+  #   end
+  #   Experiment.new.methods.include?(:new_method) # => false
+  #   Experiment.new.method_generator
+  #   Experiment.new.methods.include?(:new_method) # => true
+  def define_instance_method(*args, &block)
+    self.class.send(:define_method, *args, &block)
+  end
+end

data/lib/rubyexts/object_space.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+module ObjectSpace
+  # Returns all classes existing in runtime
+  #
+  # @author Botanicus
+  # @since 0.0.3
+  # @return [Array<Class>] List of all classes loaded into runtime
+  def self.classes
+    Array.new.tap do |objects|
+      self.each_object(Class) do |object|
+        objects << object
+      end
+    end
+  end
+end

data/lib/rubyexts/os.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+class OS
+  # Takes ENV or another hash-like object and convert it into OS instance
+  #
+  # @author Botanicus
+  # @since 0.0.3
+  # @param [ENV, Hash] ENV or another hash-like object
+  # @return [OS] Instance of OS
+  # @example
+  #   OS.parse
+  #   OS.parse("HOME" => "/Users/botanicus")
+  def self.parse(original_env = ENV)
+    input  = original_env.select { |key, value| key.match(/^[a-zA-Z][a-zA-Z_]*$/) }
+    result = Hash.new
+    input.each { |key, value| result[key.downcase.to_sym] = value }
+    self.new(result, original_env)
+  end
+
+  attr_reader :env, :original_env
+  def initialize(env, original_env = env)
+    @env, @original_env = env, original_env
+    self.keys.each do |key|
+      if key.match(/(path|lib)$/)
+        # OS.path
+        # => ["/bin", "/usr/bin", "/sbin", "/usr/sbin"]
+        define_singleton_method(key) do
+          @env[key].split(":").uniq.sort
+        end
+      elsif @env[key].match(/^\d+$/)
+        define_singleton_method(key) { @env[key].to_i }
+      elsif @env[key].empty?
+        define_singleton_method(key) { nil }
+      else
+        # OS.home
+        # => "/Users/botanicus"
+        define_singleton_method(key) do
+          case value = @env[key]
+          when /^\d+$/      then value.to_i
+          when /^\d+\.\d+$/ then value.to_f
+          when /^true$/i    then true
+          when /^false$/i   then false
+          when /^$/         then nil
+          else              value
+          end
+        end
+      end
+    end
+  end
+
+  # Get value for given key or nil
+  #
+  # @author Botanicus
+  # @since 0.0.3
+  # @param [Symbol] Key
+  # @return [OS] Instance of OS
+  # @example
+  #   os[:home]
+  def [](key)
+    self.send(key) if self.keys.include?(key.to_sym)
+  end
+
+  def ==(other)
+    same_keys = self.keys == other.keys
+    same_values = self.keys.all? { |key| self[key] == other[key] }
+    same_keys && same_values
+  end
+
+  def keys
+    @env.keys.sort
+  end
+
+  def inspect
+    string = "#<OS keys=[%s]>"
+    format = lambda { |key| "#{key}=#{self.send(key).inspect}" }
+    inner  = self.keys.sort.map(&format).join(", ")
+    string % inner
+  end
+
+  # TODO
+  def root?
+    self.uid.eql?(0)
+  end
+
+  private
+  def method_missing(name, *args, &block)
+    super(name, *args, &block) unless args.empty? && block.nil?
+  end
+end

data/lib/rubyexts/platform.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+module RubyExts
+  class Platform
+    class << self
+      def match?(platform)
+        !! RUBY_PLATFORM.match(/#{platform}/i)
+      end
+
+      def windows?
+        self.match?("mswin|mingw")
+      end
+
+      def linux?
+        self.match?("linux")
+      end
+
+      def osx?
+        self.match?("-darwin")
+      end
+
+      def unix?
+        self.linux? or self.osx?
+      end
+    end
+  end
+end

data/lib/rubyexts/random.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+class Array
+  # Returns random item from the array
+  #
+  # @author Botanicus
+  # @since 0.0.2
+  # @return [Object] Random item from array
+  def rand
+    self[Kernel.rand(length)]
+  end
+  alias_method :random, :rand
+end
+
+class Range
+  # Returns random item from the array
+  #
+  # @author Botanicus
+  # @since 0.0.2
+  # @return [Object] Random item from range
+  def rand
+    self.min + Kernel.rand(self.max)
+  end
+  alias_method :random, :rand
+end

data/lib/rubyexts/string.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+
+class String
+  # Transform self into titlecased string.
+  #
+  # @author Botanicus
+  # @since 0.0.3
+  # @return [String] Titlecased string
+  # @example
+  #   "hello world!".titlecase # => "Hello World!"
+  def titlecase
+    self.gsub(/\b./) { $&.upcase }
+  end
+
+  # Transform self to +ColoredString+
+  # @since 0.0.1
+  # @example
+  #   "message".colorize.red.bold
+  # @param [type] name explanation
+  # @return [String] Transfrom self to +ColoredString+
+  def colorize
+    require_relative "colored_string"
+    ColoredString.new(self)
+  end
+
+  def remove(pattern)
+    self.gsub(pattern, "")
+  end
+
+  def remove!(pattern)
+    self.gsub!(pattern, "")
+  end
+
+  ##
+  # Convert to snake case.
+  #
+  #   "FooBar".snake_case           #=> "foo_bar"
+  #   "HeadlineCNNNews".snake_case  #=> "headline_cnn_news"
+  #   "CNN".snake_case              #=> "cnn"
+  #
+  # @return [String] Receiver converted to snake case.
+  #
+  # @api public
+  def snake_case
+    return self.downcase if self =~ /^[A-Z]+$/
+    self.gsub(/([A-Z]+)(?=[A-Z][a-z]?)|\B[A-Z]/, '_\&') =~ /_*(.*)/
+      return $+.downcase
+  end
+
+  ##
+  # Convert to camel case.
+  #
+  #   "foo_bar".camel_case          #=> "FooBar"
+  #
+  # @return [String] Receiver converted to camel case.
+  #
+  # @api public
+  def camel_case
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/
+    split('_').map{|e| e.capitalize}.join
+  end
+
+  ##
+  # Convert a path string to a constant name.
+  #
+  #   "merb/core_ext/string".to_const_string #=> "Merb::CoreExt::String"
+  #
+  # @return [String] Receiver converted to a constant name.
+  #
+  # @api public
+  def to_const_string
+    gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
+  end
+
+  ##
+  # Convert a constant name to a path, assuming a conventional structure.
+  #
+  #   "FooBar::Baz".to_const_path # => "foo_bar/baz"
+  #
+  # @return [String] Path to the file containing the constant named by receiver
+  #   (constantized string), assuming a conventional structure.
+  #
+  # @api public
+  def to_const_path
+    snake_case.gsub(/::/, "/")
+  end
+
+  # For Rack
+  # @since 0.0.2
+  # @todo Is it still required?
+  alias_method :each, :each_line
+end

data/lib/rubyexts/time.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+class Time
+  # How long it takes to run the block in seconds
+  #
+  # @author Botanicus
+  # @since 0.0.3
+  # @return [Float] How long it takes to run the block in seconds
+  # @example
+  #   Time.timer { sleep 2 } # => 2.030802
+  def self.timer(&block)
+    start = Time.now.tap { block.call }
+    return Time.now - start
+  end
+end

data/lib/rubyexts/time_dsl.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+
+# stolen from merb-helpers
+
+# Provides a a simple way of calling time units and to see the elapsed time between 2 moments
+# @example
+#   142.minutes => returns a value in seconds
+#   7.days => returns a value in seconds
+#   1.week => returns a value in seconds
+#   2.weeks.ago => returns a date
+#   1.year.since(time) => returns a date
+#   5.months.since(2.weeks.from_now) => returns a date
+module TimeDSL
+  def second
+    self * 1
+  end
+  alias_method :seconds, :second
+
+  def minute
+    self * 60
+  end
+  alias_method :minutes, :minute
+
+  def hour
+    self * 3600
+  end
+  alias_method :hours, :hour
+
+  def day
+    self * 86400
+  end
+  alias_method :days, :day
+
+  def week
+    self * 604800
+  end
+  alias_method :weeks, :week
+
+  def month
+    self * 2592000
+  end
+  alias_method :months, :month
+
+  def year
+    self * 31471200
+  end
+  alias_method :years, :year
+
+  # Reads best without arguments:  10.minutes.ago
+  def ago(time = ::Time.now)
+    time - self
+  end
+  alias :until :ago
+
+  # Reads best with argument:  10.minutes.since(time)
+  def since(time = ::Time.now)
+    time + self
+  end
+  alias :from_now :since
+end
+
+Numeric.send :include, TimeDSL