media-path 0.1

data/vendor/rubyexts/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/vendor/rubyexts/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/vendor/rubyexts/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/vendor/rubyexts/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

data/vendor/rubyexts/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