rango 0.0.3

data/lib/rango/ext/object_space.rb

@@ -0,0 +1,11 @@
+# coding: utf-8
+
+module ObjectSpace
+  def self.classes
+    classes = Array.new
+    ObjectSpace.each_object(Class) do |klass|
+      classes << klass
+    end
+    return classes
+  end
+end

data/lib/rango/ext/path.rb

@@ -0,0 +1,222 @@
+# coding: utf-8
+
+# TODO: documentation
+# TODO: copy it's spec file
+class Path
+  # @since 0.0.1
+  attr_reader :absolute
+
+  # Path.new("public/uploads")
+  # Path.new("#{Rango::.root}/public/uploads")
+  # @since 0.0.1
+  def initialize(path)
+    path = path.absolute if path.is_a?(Path) # TODO: spec it
+    raise ArgumentError unless path.is_a?(String) # TODO: spec it
+    # no trailing /
+    path.sub!(%r{/$}, "")
+    if path.match(%r{^/})
+      @absolute = File.expand_path(path)
+    else
+      @absolute = File.expand_path(File.join(Dir.pwd, path))
+    end
+    unless File.exist?(@absolute)
+      raise "NotExists: #{@absolute}"
+    end
+  end
+
+  # @since 0.0.1
+  def relative
+    path = @absolute.dup
+    path[Dir.pwd + "/"] = String.new
+    return path
+  end
+
+  # @since 0.0.1
+  def url
+    path = @absolute.dup
+    path[Project.root] = String.new
+    path
+  end
+
+  # @since 0.0.1
+  def ==(another)
+    raise TypeError unless another.is_a?(self.class)
+    @absolute == another.absolute
+  end
+  alias_method :eql?, :==
+
+  # @since 0.0.1
+  def join(*segments)
+    raise ArgumentError if segments.any? { |segment| not segment.is_a?(String) }
+    raise ArgumentError if segments.any? { |segment| segment.match(%r{^/}) }
+    Path.new(File.join(@absolute, *segments))
+  end
+
+  # @since 0.0.1
+  def +(segment)
+    raise ArgumentError unless segment.is_a?(String)
+    raise ArgumentError if segment.match(%r{^/})
+    Path.new("#@absolute/#{segment}")
+  end
+
+  # Dir["#{path}/*"]
+  alias_method :to_s, :absolute
+
+  # @since 0.0.1
+  def entries
+    Dir["#@absolute/*"].map do |path|
+      self.class.new(path)
+    end
+  end
+
+  # @since 0.0.1
+  def inspect
+    %{"file://#@absolute"}
+  end
+
+  # @since 0.0.1
+  def basename
+    File.basename(@absolute)
+  end
+
+  # # Use instead of File.open("foo", "w")
+  # def self.write(file, &block)
+  #   self.open(file, "w", &block)
+  # end
+  #
+  # # Use instead of File.open("foo", "r")
+  # def self.read(file, &block)
+  #   self.open(file, "r", &block)
+  # end
+  #
+  # # Use instead of File.open("foo", "a")
+  # def self.append(file, &block)
+  #   self.open(file, "a", &block)
+  # end
+  #
+  # # Use instead of File.open("foo", "w+")
+  # def self.rewrite(file, &block)
+  #   self.open(file, "w+", &block)
+  # end
+  #
+  # @since 0.0.1
+  def write(&block)
+    File.open(file, "w", &block)
+  end
+
+  # @since 0.0.1
+  def read(&block)
+    if block_given?
+      File.open(@absolute, "r", &block)
+    else
+      File.read(@absolute)
+    end
+  end
+
+  # @since 0.0.1
+  def append(&block)
+    File.open(file, "a", &block)
+  end
+
+  # @since 0.0.1
+  def rewrite(&block)
+    File.open(file, "w+", &block)
+  end
+
+  # Pathname("x.html.erb").extname
+  # => ".erb"
+  # @since 0.0.1
+  def extension(file)
+    self.to_s[/\.\w+?$/] # html.erb.
+    # return @path.last.sub(/\.(\w+)$/, '\1') # dalsi moznost
+  end
+
+  # @since 0.0.1
+  def extension=(extension)
+    if @path.last.match(/\./)
+      return Path[self[0..-1] + @path.last.sub(/\.\w+$/, ".#{extension}")]
+    else
+      return @path[-1] = "#{@path.last}.#{extension}"
+    end
+  end
+
+  # @since 0.0.1
+  def to_a
+    return self.to_s.split("/")
+  end
+
+  # @since 0.0.1
+  def without_extension
+    return self.to_s.sub(/#{extension}$/, '')
+  end
+
+  # @since 0.0.1
+  def without_extension!
+    return self.to_s.sub!(/#{extension}$/, '')
+  end
+
+  # alias_method :childrens, :children
+  # @since 0.0.1
+  def make_executable
+    File.chmod(0755, @filename)
+  end
+
+  # @since 0.0.1
+  def make_unexecutable
+    File.chmod(0644, @filename)
+  end
+
+  # @since 0.0.1
+  def run(command)
+    Dir.chdir(self) do
+      return %x(#{command})
+    end
+  end
+
+  # @since 0.0.1
+  def exist?
+    File.exist?(@absolute)
+  end
+
+  # @since 0.0.1
+  def load
+    Kernel.load(@absolute)
+  end
+
+  # @since 0.0.1
+  def hidden?
+    self.basename.to_s.match(/^\./).to_bool
+  end
+
+  # dir/foo/../ => dir/
+  # @since 0.0.1
+  def normalize
+    @filename.gsub!(/[^\/]+\/\.{2}/, "")
+  end
+
+  # @since 0.0.1
+  def empty?
+    (self.directory? and self.children.empty?) || File.zero?()
+  end
+
+  # @since 0.0.1
+  def md5(file)
+    require 'digest/md5'
+    Digest::MD5.hexdigest(File.read(file))
+  end
+
+  # @since 0.0.1
+  def self.without_extension(file)
+    return file.sub(/\.\w+$/, '')
+  end
+
+  # @since 0.0.1
+  def self.basename_without_extension(file)
+    return File.basename(file.sub(/\.\w+$/, ''))
+  end
+
+  # @since 0.0.1
+  def self.change_extension(file, extension)
+    return file.sub(/\.\w+$/, ".#{extension}")
+  end
+end

data/lib/rango/ext/random.rb

@@ -0,0 +1,22 @@
+# coding: utf-8
+
+class Array
+  def rand
+    self[Kernel.rand(length)]
+  end
+  alias_method :random, :rand
+end
+
+class Range
+  def rand
+    self.min + Kernel.rand(self.max)
+  end
+  alias_method :random, :rand
+end
+
+class Hash
+  def rand
+    self[self.keys.random]
+  end
+  alias_method :random, :rand
+end

data/lib/rango/ext/string.rb

@@ -0,0 +1,16 @@
+# coding: utf-8
+
+class String
+  # @since 0.0.1
+  # @example
+  #   "message".colorize.red.bold
+  # @param [type] name explanation
+  # @return [String] Return duplication of self. In it's metaclass is included +Term::ANSIColor+.
+  def colorize
+    ColoredString.new(self)
+  end
+
+  # rack
+  # @since 0.0.2
+  alias_method :each, :each_line
+end

data/lib/rango/ext/thor.rb

@@ -0,0 +1,32 @@
+# coding: utf-8
+
+require "thor"
+
+# Hooks
+# Rango::Tasks.hook do
+#   Dir["models/*.rb"].each(&method(:require))
+# end
+class Rango
+  class Tasks < Thor
+    class << self
+      attr_accessor :hooks
+      def hook(&block)
+        @hooks ||= Array.new
+        @hooks.push(block)
+      end
+
+      def inherited(subclass)
+        subclass.hooks = self.hooks
+      end
+    end
+
+    def boot(*args)
+      require "rango"
+      Rango.boot(*args)
+      p self.class.hooks
+      self.class.hooks.each(&:call)
+    rescue Exception => exception
+      Rango.logger.exception(exception)
+    end
+  end
+end

data/lib/rango/ext/time_dsl.rb

@@ -0,0 +1,63 @@
+# coding: utf-8
+
+# stolen from merb-helpers
+
+# Provides a a simple way of calling time units and to see the elapsed time between 2 moments
+# ==== Examples
+#   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/lib/rango/ext/try.rb

@@ -0,0 +1,30 @@
+# coding: utf-8
+
+# stolen from rails (but our definition isn't compatible)
+# rails defines try as __send__ for each objects exclude nil - nil#try returns nil
+# our try returns nil if the method doesn't exist
+
+class Object
+  # 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.
+  #
+  # *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.
+  #
+  # ==== Examples
+  #
+  # Without try
+  #   @person && @person.name
+  # or
+  #   @person ? @person.name : nil
+  #
+  # With try
+  #   @person.try(:name)
+  #
+  # +try+ also accepts arguments and/or a block, for the method it is trying
+  #   Person.try(:find, 1)
+  #   @people.try(:collect) {|p| p.name}
+  def try(method, *args, &block)
+    self.send(method, *args, &block) if self.respond_to?(method)
+  end
+end

data/lib/rango/forms/form.rb

@@ -0,0 +1,29 @@
+# coding: utf-8
+
+# class ContactForm < Rango::Form
+#   property :subject, String
+#   property :message, Text
+#   property :cc_self, Boolean
+# end
+
+# @future 0.0.3 It's just a prototype now
+class Rango
+  class Form
+    attribute :media
+
+    def valid?
+    end
+
+    def to_html
+      output = Array.new
+      output << %{<form action="#{@action}" method="post">}
+      output << *@fields.map { |field| field.to_html }
+      output << %{</form>}
+      return output.join("\n")
+    end
+  end
+
+  class ModelForm
+
+  end
+end

data/lib/rango/generic_views/static.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+
+class Rango::GenericViews < Rango::Controller
+  def static(template)
+    render(template)
+  end
+end

data/lib/rango/helpers.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+class Rango
+  module Helpers
+    # tag :a, href: "/contact" { anchor }
+    # tag :a, "contact", href: "/contact"
+    # @since 0.0.2
+    def tag(tag, content, attrs = Hash.new, &block)
+      attrs, content = content, String.new if attrs.empty? && content.is_a?(Hash)
+      block.call if block
+      %[<#{tag} #{attrs.to_html_attrs}>#{content}</#{tag}>]
+    end
+
+    # @since 0.0.2
+    def single_tag(tag, attrs = Hash.new)
+      %[<#{tag} #{attrs.to_html_attrs} />]
+    end
+  end
+end
+
+Rango.import("helpers/assets")
+Rango.import("helpers/syntax")
+Rango.import("helpers/general")
+Rango.import("helpers/merb-helpers")