simple-templater 0.0.1

data/vendor/rubyexts/lib/rubyexts/hash.rb

@@ -0,0 +1,147 @@
+# 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
+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

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

data/vendor/rubyexts/lib/rubyexts/unique_array.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+# Get is using it
+# co treba udelat to pres observery?
+module RubyExts
+  class UniqueArray < Array
+    def push(*args)
+      args.each do |arg|
+        unless self.include?(arg)
+          super(arg)
+        end
+      end
+    end
+    alias_method :<<, :push
+  end
+end