media-path 0.1

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

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