rubyexts 0.0.1

data/lib/rubyexts/colored_string.rb

@@ -0,0 +1,103 @@
+# encoding: utf-8
+
+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/rubyexts/enumerable.rb

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Enumerable
+  # Enumerable#none? is the logical opposite of the builtin method Enumerable#any?. It
+  # returns +true+ if and only if _none_ of the elements in the collection satisfy the
+  # predicate.
+  #
+  # If no predicate is provided, Enumerable#none? returns +true+ if and only if _none_ of the
+  # elements have a true value (i.e. not +nil+ or +false+).
+  #
+  # @author Botanicus
+  # @from Extensions
+  # @since 0.0.3
+  # @yield [block] Block which will be evaluated in Project.setttings object.
+  # @yieldparam [item] Each item of array-like collection
+  # @yieldparam [key, value] Each item of hash-like collection
+  # @option params [String, Array<String>] :exclude File or list of files or globs relative to base directory
+  # @raise [LoadError] If base directory doesn't exist
+  # @raise [ArgumentError] If first argument isn't a glob
+  # @return [Array<String>] List of successfully loaded files
+  # @example
+  #   [].none?                      # => true
+  #   [nil].none?                   # => true
+  #   [5,8,9].none?                 # => false
+  #   (1...10).none? { |n| n < 0 }  # => true
+  #   (1...10).none? { |n| n > 0 }  # => false
+  def none?(&block)
+    not self.any?(&block)
+  end
+end

data/lib/rubyexts/file.rb

@@ -0,0 +1,84 @@
+# encoding: utf-8
+
+class File
+  # Append given chunks to the existing file or create new one.
+  # It use <tt>IO#puts</tt> for write to given file.
+  #
+  # @author Botanicus
+  # @since 0.0.3
+  # @param [String] file Path to file. You can use <tt>~</tt>, <tt>~user</tt> or similar expressions.
+  # @param [String, Object] *chunks Chunks which will be written to the file
+  # @raise [Errno::ENOENT] If parent directory of given file doesn't exist
+  # @raise [Errno::EACCES] If you don't have permissions to write to given file
+  # @return [String] Expanded path to given file
+  # @example
+  #   File.append "~/.bashrc", source # => "/Users/botanicus/.bashrc"
+  def self.append(file, *chunks)
+    self.write(:puts, "a", file, *chunks)
+  end
+
+  # Append given chunks to the existing file or create new one.
+  # It use <tt>IO#print</tt> for write to given file.
+  #
+  # @author Botanicus
+  # @since 0.0.3
+  # @param [String] file Path to file. You can use <tt>~</tt>, <tt>~user</tt> or similar expressions.
+  # @param [String, Object] *chunks Chunks which will be written to the file
+  # @raise [Errno::ENOENT] If parent directory of given file doesn't exist
+  # @raise [Errno::EACCES] If you don't have permissions to write to given file
+  # @return [String] Expanded path to given file
+  # @example
+  #   File.append "~/.bashrc", source # => "/Users/botanicus/.bashrc"
+  def self.add(file, *chunks)
+    self.write(:print, "a", file, *chunks)
+  end
+
+  # Create new file and write there given chunks.
+  # It use <tt>IO#puts</tt> for write to given file.
+  #
+  # @author Botanicus
+  # @since 0.0.3
+  # @param [String] file Path to file. You can use <tt>~</tt>, <tt>~user</tt> or similar expressions.
+  # @param [String, Object] *chunks Chunks which will be written to the file
+  # @raise [Errno::ENOENT] If parent directory of given file doesn't exist
+  # @raise [Errno::EACCES] If you don't have permissions to write to given file
+  # @return [String] Expanded path to given file
+  # @example
+  #   File.puts "~/.bashrc", source # => "/Users/botanicus/.bashrc"
+  def self.puts(file, *chunks)
+    self.write(:puts, "w", file, *chunks)
+  end
+
+  # Create new file and write there given chunks.
+  # It use <tt>IO#print</tt> for write to given file.
+  #
+  # @author Botanicus
+  # @since 0.0.3
+  # @param [String] file Path to file. You can use <tt>~</tt>, <tt>~user</tt> or similar expressions.
+  # @param [String, Object] *chunks Chunks which will be written to the file
+  # @raise [Errno::ENOENT] If parent directory of given file doesn't exist
+  # @raise [Errno::EACCES] If you don't have permissions to write to given file
+  # @return [String] Expanded path to given file
+  # @example
+  #   File.print "~/.bashrc", source # => "/Users/botanicus/.bashrc"
+  def self.print(file, *chunks)
+    self.write(:print, "w", file, *chunks)
+  end
+
+  # Write data to file with given method.
+  #
+  # @author Botanicus
+  # @since 0.0.3
+  # @param [String] file Path to file. You can use <tt>~</tt>, <tt>~user</tt> or similar expressions.
+  # @param [String, Object] *chunks Chunks which will be written to the file
+  # @raise [Errno::ENOENT] If parent directory of given file doesn't exist
+  # @raise [Errno::EACCES] If you don't have permissions to write to given file
+  # @return [String] Expanded path to given file
+  # @example
+  #   File.write :printf, "w", "~/.bashrc", "%d %04x", 123, 123 # => "/Users/botanicus/.bashrc"
+  def self.write(method, mode, file, *args)
+    self.expand_path(file).tap do |path|
+      self.open(path, mode) { |file| file.send(method, *args) }
+    end
+  end
+end

data/lib/rubyexts/hash.rb

@@ -0,0 +1,180 @@
+# encoding: utf-8
+
+class Hash
+  # Return duplication of self with all keys non-recursively converted to symbols
+  #
+  # @author Botanicus
+  # @since 0.0.2
+  # @return [Hash] A hash with all keys transformed into symbols
+  def symbolize_keys
+    self.inject(Hash.new) do |result, array|
+      result[array.first.to_sym] = array.last
+      result
+    end
+  end
+
+  # Replace keys in self by coresponding symbols
+  #
+  # @author Botanicus
+  # @since 0.0.2
+  # @return [Hash] A hash with all keys transformed into symbols
+  def symbolize_keys!
+    self.replace(self.symbolize_keys)
+  end
+
+  # Return duplication of self with all keys recursively converted to symbols
+  #
+  # @author Botanicus
+  # @since 0.0.2
+  # @return [Hash] A hash with all keys transformed into symbols even in inner hashes
+  def deep_symbolize_keys
+    self.inject(Hash.new) do |result, array|
+      key, value = array.first, array.last
+      if value.respond_to?(:symbolize_keys)
+        result[key.to_sym] = value.symbolize_keys
+      else
+        result[key.to_sym] = value
+      end
+      result
+    end
+  end
+
+  # Recursively replace keys in self by coresponding symbols
+  #
+  # @author Botanicus
+  # @since 0.0.2
+  # @return [Hash] A hash with all keys transformed into symbols even in inner hashes
+  def deep_symbolize_keys!
+    self.replace(self.deep_symbolize_keys)
+  end
+
+  # Returns the value of self for each argument and deletes those entries.
+  #
+  # @author Botanicus
+  # @since 0.0.2
+  # @param [*args] the keys whose values should be extracted and deleted.
+  # @return [Array<Object>] The values of the provided arguments in corresponding order.
+  # @api public
+  # @example
+  #   hash = {one: 1, two: 2, three: 3}
+  #   hash.extract!(:one, :two) # => [1, 2]
+  #   hash                      # => {:three => 3}
+  def extract!(*args)
+    args.map do |arg|
+      self.delete(arg)
+    end
+  end
+
+  # @author Botanicus
+  # @since 0.0.2
+  # @return [String] A string formatted for HTML attributes
+  # @example
+  #   {class: "inner", id: "post-#{@post.id}"}.to_html_attrs # => "class='inner' id='post-1'"
+  def to_html_attrs
+    self.map { |key, value| "#{key}='#{value}'" }.join(" ")
+  end
+
+  # @author Botanicus
+  # @since 0.0.2
+  # @return [String] A string formatted for URL
+  # @example
+  #   {action: "rate", rating: 2}.to_url_attrs # => "action=rate&rating=2"
+  def to_url_attrs
+    self.map { |key, value| "#{key}=#{value}" }.join("&")
+  end
+
+  # @author Botanicus
+  # @since 0.0.2
+  # @return [String] Merge self into hash given as argument
+  def reverse_merge(another)
+    another.merge(self)
+  end
+
+  # @author Botanicus
+  # @since 0.0.2
+  # @return [String] Replace self by result of merge self into hash given as argument
+  def reverse_merge!(another)
+    self.replace(self.reverse_merge(another))
+  end
+
+  # @author Botanicus
+  # @since 0.0.2
+  # @deprecated
+  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
+
+  # Simplier syntax for code such as params[:post] && params[:post][:title]
+  #
+  # @author Jakub Stastny aka Botanicus
+  # @since 0.0.3
+  # @param [Object] First argument is the key of the hash, the second one the key of the inner hash selected by the first key etc.
+  # @return [Object, nil] The value of the most inner hash if found or nil.
+  # @raise [ArgumentError] If you don't specify keys.
+  # @raise [IndexError] If you work with final result as with hash, so basically you are trying to call fetch method on string or whatever.
+  #
+  # @example
+  #   {a: {b: 1}}.get(:a, :b)     # => 1
+  #   {a: {b: 1}}.get(:a, :b, :c) # => IndexError
+  #   {a: {b: 1}}.get(:a, :c)     # => nil
+  def get(*keys)
+    raise ArgumentError, "You must specify at least one key" if keys.empty?
+    keys.inject(self) do |object, key|
+      # Hash#fetch works similar as Hash#[], but [] method is
+      # defined for too many objects, also strings and even numbers
+      if object.respond_to?(:fetch)
+        begin
+          object.fetch(key)
+        # Hash#fetch raise IndexError if key doesn't exist
+        rescue IndexError
+          return nil
+        end
+      else
+        raise IndexError, "Object #{object.inspect} isn't hash-like collection"
+      end
+    end
+  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
+end

data/lib/rubyexts/kernel.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+module Kernel
+  # @since 0.0.2
+  def metaclass
+    class << self
+      self
+    end
+  end
+
+  # os.home
+  def os
+    @os ||= OS.parse
+  end
+
+  # @since 0.0.1
+  # @example
+  #   try_require_gem "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_gem(library, gemname = library, options = Hash.new)
+    gemname, options = library, gemname if gemname.is_a?(Hash) && options.empty?
+    try_require_gem!(library, gemname, options)
+  rescue LoadError
+    return false
+  end
+
+  # @since 0.0.3
+  def try_require_gem!(library, gemname = library, options = Hash.new)
+    gemname, options = library, gemname if gemname.is_a?(Hash) && options.empty?
+    require library
+  rescue LoadError => exception
+    message  = "Gem #{gemname} isn't installed. Run sudo gem install #{gemname}. (#{exception.inspect})"
+    logger   = Rango.logger.method(options[:level] || :error)
+    callable = defined?(Rango.logger) ? logger : method(:puts)
+    callable.call(message)
+    raise exception
+  end
+
+  # @since 0.0.3
+  def require_gem_or_exit(library, gemname = library, options = Hash.new)
+    gemname, options = library, gemname if gemname.is_a?(Hash) && options.empty?
+    try_require_gem!(library, gemname, options)
+  rescue LoadError
+    exit 1
+  end
+
+  # @since 0.0.3
+  def try_require(library)
+    require library
+  rescue LoadError
+    return false
+  end
+
+  def command(command)
+    puts command
+    puts %x[#{command}]
+  end
+  alias_method :sh,  :command
+  alias_method :run, :command
+
+  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
+
+  # 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