rubyexts 0.0.1

data/CHANGELOG

@@ -0,0 +1,2 @@
+= Version 0.0.1
+  * Imported from Rango

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Jakub Šťastný aka Botanicus
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,79 @@
+#!/usr/bin/env rake1.9
+# encoding: utf-8
+
+# http://support.runcoderun.com/faqs/builds/how-do-i-run-rake-with-trace-enabled
+Rake.application.options.trace = true
+
+task :setup => ["submodules:init"]
+
+namespace :submodules do
+  desc "Init submodules"
+  task :init do
+    sh "git submodule init"
+  end
+
+  desc "Update submodules"
+  task :update do
+    Dir["vendor/*"].each do |path|
+      if File.directory?(path) && File.directory?(File.join(path, ".git"))
+        Dir.chdir(path) do
+          puts "=> #{path}"
+          puts %x[git reset --hard]
+          puts %x[git fetch]
+          puts %x[git reset origin/master --hard]
+          puts
+        end
+      end
+    end
+  end
+end
+
+task :gem do
+  sh "gem build rubyexts.gemspec"
+end
+
+namespace :gem do
+  task :prerelease do
+    require_relative "lib/rubyexts"
+    gemspec = Dir["*.gemspec"].first
+    content = File.read(gemspec)
+    prename = "#{gemspec.split(".").first}.pre.gemspec"
+    version = RubyExts::VERSION.sub(/^(\d+)\.(\d+)\.\d+$/) { "#$1.#{$1.to_i + 1}" }
+    File.open(prename, "w") do |file|
+      file.puts(content.gsub(/(\w+::VERSION)/, "'#{version}.pre'"))
+    end
+    sh "gem build #{prename}"
+    rm prename
+  end
+end
+
+desc "Release new version of rubyexts"
+task release: ["release:tag", "release:gemcutter"]
+
+namespace :release do
+  desc "Create Git tag"
+  task :tag do
+    require_relative "lib/rubyexts"
+    puts "Creating new git tag #{RubyExts::VERSION} and pushing it online ..."
+    sh "git tag -a -m 'Version #{RubyExts::VERSION}' #{RubyExts::VERSION}"
+    sh "git push --tags"
+    puts "Tag #{RubyExts::VERSION} was created and pushed to GitHub."
+  end
+
+  desc "Push gem to Gemcutter"
+  task :gemcutter do
+    puts "Pushing to Gemcutter ..."
+    sh "gem push #{Dir["*.gem"].last}"
+  end
+
+  desc "Create and push prerelease gem"
+  task :pre => ["gem:prerelease", :gemcutter]
+end
+
+desc "Run specs"
+task :default => :setup do
+  rubylib = (ENV["RUBYLIB"] || String.new).split(":")
+  libdirs = Dir["vendor/*/lib"]
+  ENV["RUBYLIB"] = (libdirs + rubylib).join(":")
+  exec "./script/spec --options spec/spec.opts spec"
+end

data/TODO.txt

@@ -0,0 +1,6 @@
+missing specs:
+	- attribute
+	- class (copy from extlib)
+
+rewrite/refactor:
+	- colored string

data/lib/rubyexts.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+
+module RubyExts
+  VERSION ||= "0.0.1"
+end
+
+module Kernel
+  # Require all files matching given glob relative to $:
+  #
+  # @author Botanicus
+  # @since 0.0.3
+  # @param [String] library Glob of files to require
+  # @param [Hash] params Optional parameters.
+  # @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
+  #   acquire "lib/*"
+  #   acquire "lib/**/*", exclude: "**/*_spec.rb"
+  #   acquire "lib/**/*", exclude: ["**/*_spec.rb", "lib/init.rb"]
+  def acquire(glob, params = Hash.new)
+    base, glob = get_base_and_glob(glob)
+    $:.compact.find do |path|
+      fullpath = File.expand_path(File.join(path, base))
+      if File.directory?(fullpath)
+        return __acquire__(fullpath, glob, params.merge(soft: true))
+      end
+    end
+    raise LoadError, "Directory #{base} doesn't exist in $:"
+  end
+
+  def acquire!(glob, params = Hash.new)
+    self.acquire(glob, params.merge(soft: false))
+  end
+
+  # Require all files matching given glob relative to current file
+  #
+  # @author Botanicus
+  # @since 0.0.3
+  # @param [String] library Glob of files to require
+  # @param [Hash] params Optional parameters.
+  # @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
+  #   acquire "lib/*"
+  #   acquire "lib/**/*", exclude: "**/*_spec.rb"
+  #   acquire "lib/**/*", exclude: ["**/*_spec.rb", "lib/init.rb"]
+  def acquire_relative(glob, params = Hash.new)
+    base, glob = get_base_and_glob(glob)
+    path = File.dirname(caller[0].split(":").first)
+    full = File.expand_path(File.join(path, base))
+    raise LoadError, "Directory #{base} doesn't exist in #{path}" unless File.directory?(full)
+    return __acquire__(full, glob, params.merge(soft: true))
+  end
+
+  def acquire_relative!(glob, params = Hash.new)
+    self.acquire_relative(glob, params.merge(soft: false))
+  end
+
+  def load_relative(file)
+    path = File.dirname(caller[0].split(":").first)
+    load File.expand_path(File.join(path, file))
+  end
+
+  private
+  def __acquire__(path, glob, params)
+    glob.replace("#{glob}.rb") if glob.eql?("*") || glob.end_with?("/*")
+    files = Dir[File.join(path, glob)]
+    excludes = [params[:exclude]].flatten.compact
+    excludes.map! do |glob|
+      fullpath = File.join(path, glob)
+      File.file?(fullpath) ? fullpath : Dir[fullpath]
+    end
+    excludes = excludes.flatten.compact
+    files.select do |path|
+      if File.file?(path) && !excludes.include?(path)
+        soft_not_loaded = params[:soft] && ! $LOADED_FEATURES.include?(path)
+        load(path) if soft_not_loaded || ! params[:soft]
+        $LOADED_FEATURES.push(path) if soft_not_loaded
+      end
+    end
+  end
+
+  def get_base_and_glob(glob)
+    base, glob = glob.match(/^([^*]+)(.*)$/)[1..2]
+    raise ArgumentError, "You have to provide glob" if glob.empty?
+    return [base, glob]
+  end
+end
+
+acquire_relative "rubyexts/*"
+
+# run console if executed directly
+if $0 == __FILE__
+  require "irb"
+  require "irb/completion"
+  include RubyExts
+  IRB.start(__FILE__)
+end

data/lib/rubyexts/array.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+
+class Array
+  # Returns the _only_ element in the array or raise
+  # +IndexError+ if array hasn't exactly one element.
+  #
+  # @author Botanicus
+  # @from Extensions
+  # @since 0.0.3
+  # @raise [IndexError] If array hasn't exactly one element
+  # @return [Object] First (and only) item of the array
+  # @example
+  #   [5].only        # => 5
+  #   [1, 2, 3].only  # => IndexError
+  #   [].only         # => IndexError
+  def only
+    raise IndexError, "Array#only called on non-single-element array" unless self.size == 1
+    self.first
+  end
+end

data/lib/rubyexts/attribute.rb

@@ -0,0 +1,151 @@
+# encoding: 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 "rubyexts/try_dup"
+
+# default value for attr
+module AttributeMixin
+  # class Array
+  #   private_alias :join
+  #   def join(char)
+  #     puts "New join!"
+  #     __join__(char)
+  #   end
+  # end
+  def private_alias(method)
+    alias_method "__#{method}__", method
+    private "__#{method}__"
+  end
+
+  # @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/rubyexts/capture_io.rb

@@ -0,0 +1,32 @@
+require "stringio"
+
+def STDOUT.capture(&block)
+  before = self
+  $stdout = StringIO.new
+  block.call
+  $stdout.rewind
+  output = $stdout.read
+  $stdout = before
+  output
+end
+
+# @example STDOUT.capture { puts "hi" }
+# # => "hi"
+def STDERR.capture(&block)
+  before = self
+  $stderr = StringIO.new
+  block.call
+  $stderr.rewind
+  output = $stderr.read
+  $stderr = before
+  output
+end
+
+# @example STDIN.capture("yes") { ask("Do you hear me?") }
+# # => "yes"
+def STDIN.capture(default, &block)
+  STDIN.reopen "/dev/null" # so we don't get the fucking prompt
+  STDIN.ungetbyte(default) # so the default value can be get by STDIN.getc & similar methods
+  block.call
+  # TODO: how I can get back the original STDIN?
+end

data/lib/rubyexts/class.rb

@@ -0,0 +1,177 @@
+# Copyright (c) 2004-2008 David Heinemeier Hansson
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+# Allows attributes to be shared within an inheritance hierarchy, but where
+# each descendant gets a copy of their parents' attributes, instead of just a
+# pointer to the same. This means that the child can add elements to, for
+# example, an array without those additions being shared with either their
+# parent, siblings, or children, which is unlike the regular class-level
+# attributes that are shared across the entire hierarchy.
+class Class
+  # Defines class-level and instance-level attribute reader.
+  #
+  # @param *syms<Array> Array of attributes to define reader for.
+  # @return <Array[#to_s]> List of attributes that were made into cattr_readers
+  #
+  # @api public
+  #
+  # @todo Is this inconsistent in that it does not allow you to prevent
+  #   an instance_reader via :instance_reader => false
+  def cattr_reader(*syms)
+    syms.flatten.each do |sym|
+      next if sym.is_a?(Hash)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}
+          @@#{sym}
+        end
+
+        def #{sym}
+          @@#{sym}
+        end
+      RUBY
+    end
+  end
+
+  # Defines class-level (and optionally instance-level) attribute writer.
+  #
+  # @param <Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
+  # @return <Array[#to_s]> List of attributes that were made into cattr_writers
+  #
+  # @api public
+  def cattr_writer(*syms)
+    options = syms.last.is_a?(Hash) ? syms.pop : {}
+    syms.flatten.each do |sym|
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+        unless defined? @@#{sym}
+          @@#{sym} = nil
+        end
+
+        def self.#{sym}=(obj)
+          @@#{sym} = obj
+        end
+      RUBY
+
+      unless options[:instance_writer] == false
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          def #{sym}=(obj)
+            @@#{sym} = obj
+          end
+        RUBY
+      end
+    end
+  end
+
+  # Defines class-level (and optionally instance-level) attribute accessor.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to define accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level attribute writer is defined.
+  # @return <Array[#to_s]> List of attributes that were made into accessors
+  #
+  # @api public
+  def cattr_accessor(*syms)
+    cattr_reader(*syms)
+    cattr_writer(*syms)
+  end
+
+  # Defines class-level inheritable attribute reader. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[#to_s]> Array of attributes to define inheritable reader for.
+  # @return <Array[#to_s]> Array of attributes converted into inheritable_readers.
+  #
+  # @api public
+  #
+  # @todo Do we want to block instance_reader via :instance_reader => false
+  # @todo It would be preferable that we do something with a Hash passed in
+  #   (error out or do the same as other methods above) instead of silently
+  #   moving on). In particular, this makes the return value of this function
+  #   less useful.
+  def class_inheritable_reader(*ivars)
+    instance_reader = ivars.pop[:reader] if ivars.last.is_a?(Hash)
+
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}
+          return @#{ivar} if defined?(@#{ivar})
+          return nil      if self.object_id == #{self.object_id}
+          ivar = superclass.#{ivar}
+          return nil if ivar.nil?
+          @#{ivar} = ivar.try_dup
+        end
+      RUBY
+
+      unless instance_reader == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}
+            self.class.#{ivar}
+          end
+        RUBY
+      end
+    end
+  end
+
+  # Defines class-level inheritable attribute writer. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable writer for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of the attributes that were made into inheritable writers.
+  #
+  # @api public
+  #
+  # @todo We need a style for class_eval <<-HEREDOC. I'd like to make it
+  #   class_eval(<<-RUBY, __FILE__, __LINE__), but we should codify it somewhere.
+  def class_inheritable_writer(*ivars)
+    instance_writer = ivars.pop[:instance_writer] if ivars.last.is_a?(Hash)
+    ivars.each do |ivar|
+      self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+        def self.#{ivar}=(obj)
+          @#{ivar} = obj
+        end
+      RUBY
+      unless instance_writer == false
+        self.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          def #{ivar}=(obj) self.class.#{ivar} = obj end
+        RUBY
+      end
+    end
+  end
+
+  # Defines class-level inheritable attribute accessor. Attributes are available to subclasses,
+  # each subclass has a copy of parent's attribute.
+  #
+  # @param *syms<Array[*#to_s, Hash{:instance_writer => Boolean}]> Array of attributes to
+  #   define inheritable accessor for.
+  # @option syms :instance_writer<Boolean> if true, instance-level inheritable attribute writer is defined.
+  # @return <Array[#to_s]> An Array of attributes turned into inheritable accessors.
+  #
+  # @api public
+  def class_inheritable_accessor(*syms)
+    class_inheritable_reader(*syms)
+    class_inheritable_writer(*syms)
+  end
+end