rango 0.1.0 → 0.1.1

data/lib/rango/helpers/merb-helpers/form_helpers.rb

@@ -1,21 +0,0 @@
-# encoding: utf-8
-
-require_relative "form/helpers"
-require_relative "form/builder"
-
-module Rango
-  module Helpers
-    include Rango::Helpers::Form
-  end
-end
-
-class Rango::Controller
-  class_inheritable_accessor :_default_builder
-end
-
-# Rango::BootLoader.after_app_loads do
-#   module Rango::Controller
-#     self._default_builder =
-#       Object.full_const_get(Rango::Plugins.config[:helpers][:default_builder]) rescue Rango::Helpers::Form::Builder::ResourcefulFormWithErrors
-#   end
-# end

data/lib/rango/helpers/merb-helpers/tag_helpers.rb

@@ -1,63 +0,0 @@
-# encoding: utf-8
-
-module Rango
-  module Helpers
-    module Tag
-      # Creates a generic HTML tag. You can invoke it a variety of ways.
-      #
-      #   tag :div
-      #   # <div></div>
-      #
-      #   tag :div, 'content'
-      #   # <div>content</div>
-      #
-      #   tag :div, :class => 'class'
-      #   # <div class="class"></div>
-      #
-      #   tag :div, 'content', :class => 'class'
-      #   # <div class="class">content</div>
-      #
-      #   tag :div do
-      #     'content'
-      #   end
-      #   # <div>content</div>
-      #
-      #   tag :div, :class => 'class' do
-      #     'content'
-      #   end
-      #   # <div class="class">content</div>
-      #
-      def tag(name, contents = nil, attrs = {}, &block)
-        attrs, contents = contents, nil if contents.is_a?(Hash)
-        contents = capture(&block) if block_given?
-        open_tag(name, attrs) + contents.to_s + close_tag(name)
-      end
-
-      # Creates the opening tag with attributes for the provided +name+
-      # attrs is a hash where all members will be mapped to key="value"
-      #
-      # Note: This tag will need to be closed
-      def open_tag(name, attrs = nil)
-        "<#{name}#{' ' + attrs.to_html_attributes unless attrs.blank?}>"
-      end
-
-      # Creates a closing tag
-      def close_tag(name)
-        "</#{name}>"
-      end
-
-      # Creates a self closing tag.  Like <br/> or <img src="..."/>
-      #
-      # +name+ : the name of the tag to create
-      # +attrs+ : a hash where all members will be mapped to key="value"
-      def self_closing_tag(name, attrs = nil)
-        "<#{name}#{' ' + attrs.to_html_attributes if attrs && !attrs.empty?}/>"
-      end
-
-    end
-  end
-end
-
-module Rango::Helpers
-  include Rango::Helpers::Tag
-end

data/lib/rango/helpers/merb-helpers/text_helpers.rb

@@ -1,73 +0,0 @@
-# encoding: utf-8
-
-module Rango
-  module Helpers
-    module Text
-      # from merb-core / Kernel
-      def extract_options_from_args!(args)
-        args.pop if (args.last.instance_of?(Hash) || args.last.instance_of?(Mash))
-      end
-
-
-      # Allows you to cycle through elements in an array
-      #
-      # ==== Parameters
-      # values<Array>:: Array of objects to cycle through
-      # values<Hash>:: Last element of array can be a hash with the key of
-      #                :name to specify the name of the cycle
-      #
-      # ==== Returns
-      # String
-      #
-      # ==== Notes
-      # * Default name is :default
-      #
-      # ==== Example
-      # <%= 5.times { cycle("odd! ","even! "} %>
-      #
-      # Generates:
-      #
-      # odd! even! odd! even! odd!
-      def cycle(*values)
-        options = extract_options_from_args!(values) || {}
-        key = (options[:name] || :default).to_sym
-        (@cycle_positions ||= {})[key] ||= {:position => -1, :values => values}
-        unless values == @cycle_positions[key][:values]
-          @cycle_positions[key] = {:position => -1, :values => values}
-        end
-        current = @cycle_positions[key][:position]
-        @cycle_positions[key][:position] = current + 1
-        values.at( (current + 1) % values.length).to_s
-      end
-
-      # Allows you to reset a cycle
-      #
-      # ==== Parameters
-      # name<Symbol|String>:: Name of the cycle
-      #
-      # ==== Returns
-      # True if successful, otherwise nil
-      #
-      # ==== Notes
-      # * Default name is :default
-      #
-      # ==== Example
-      # <%= cycle("odd! ","even! ","what comes after even?") %>
-      # <%= cycle("odd! ","even! ","what comes after even?") %>
-      # <% reset_cycle %>
-      # <%= cycle("odd! ","even! ","what comes after even?") %>
-      #
-      # Generates:
-      #
-      # odd! even! odd!
-      def reset_cycle(name = :default)
-        (@cycle_positions[name.to_sym] = nil) &&
-          true if @cycle_positions && @cycle_positions[name.to_sym]
-      end
-    end
-  end
-end
-
-module Rango::Helpers
-  include Rango::Helpers::Text
-end

data/lib/rango/loggers/logger.rb

@@ -1,100 +0,0 @@
-# encoding: utf-8
-
-# TODO: documentation
-# TODO: specs
-require "logger"
-
-module Rango
-  class Logger < ::Logger
-    # @since 0.0.1
-    def initialize(output = STDERR)
-      super(output)
-      self.setup
-    end
-
-    # @since 0.0.1
-    def setup
-      self.level = ::Logger::DEBUG
-      self.datetime_format = "%H:%M:%S"
-      self.setup_format
-    end
-
-    # @since 0.0.1
-    def exception(exception)
-      self.error("#{exception.message} (#{exception.class})")
-      exception.backtrace.each do |line|
-        unless line.match(/thin|eventmachine/)
-          STDERR.puts("- #{line.colorize.cyan}")
-        end
-      end
-    end
-
-    # Logger methods can takes more arguments and they returns array with arguments
-    # NOTE: why we dup args each time? Because we colorize messages, but if logger method
-    # is used for handling requests, we just need to send noncolored messages as response.
-    # @since 0.0.1
-    def debug(*args)
-      original = args.dup
-      args.map { |arg| super(arg) }
-      return original
-    end
-
-    # @since 0.0.1
-    def info(*args)
-      original = args.dup
-      args.map { |arg| super(arg) }
-      return original
-    end
-
-    # @since 0.0.1
-    def warn(*args)
-      original = args.dup
-      args.map { |arg| super(arg) }
-      return original
-    end
-
-    # @since 0.0.1
-    def error(*args)
-      original = args.dup
-      args.map { |arg| super(arg) }
-      return original
-    end
-
-    # @since 0.0.1
-    def fatal(*args)
-      original = args.dup
-      args.map { |arg| super(arg) }
-      return original
-    end
-
-    # Project.logger.inspect(@posts, item)
-    # Project.logger.inspect("@post" => @post)
-    # @since 0.0.1
-    def inspect(*args)
-      if args.first.is_a?(Hash) && args.length.eql?(1)
-        args.first.each do |name, value|
-          self.debug("#{name}: #{value.inspect}")
-        end
-      else
-        args = args.map { |arg| arg.inspect }
-        self.debug(*args)
-      end
-    end
-
-    # @since 0.0.1
-    def setup_format
-      self.formatter = lambda do |severity, datetime, progname, msg|
-        # logger.debug(object_to_inspect)
-        msg = msg.inspect unless msg.is_a?(String)
-        datetime = datetime.strftime("[%H:%M:%S]")
-        case severity
-        when "DEBUG" then "#{datetime} #{msg.colorize.yellow}\n"
-        when "INFO"  then "#{datetime} #{msg.colorize.green}\n"
-        when "WARN"  then "#{datetime} #{msg.colorize.yellow}\n"
-        when "ERROR" then "#{datetime} #{msg.colorize.red}\n"
-        when "FATAL" then "#{datetime} #{msg.colorize.red.bold}\n"
-        end
-      end
-    end
-  end
-end

data/lib/rango/mixins/chainable.rb

@@ -1,68 +0,0 @@
-# encoding: utf-8
-
-# from merb-core
-module Rango
-  module Chainable
-    # Allows the definition of methods on a class that will be available via
-    # super.
-    #
-    # ==== Examples
-    #     class Foo
-    #       extend Rango::Chainable
-    #       chainable do
-    #         def hello
-    #           "hello"
-    #         end
-    #       end
-    #     end
-    #
-    #     class Foo
-    #       def hello
-    #         super + " Merb!"
-    #       end
-    #     end
-    #
-    # # Example with mixin:
-    # module TestMixin
-    #   extend Rango::Chainable
-    #   chainable do
-    #     def test
-    #       "from mixin!"
-    #     end
-    #   end
-    # end
-    #
-    # class Test
-    #   include TestMixin
-    #   def test
-    #     "hello " + super
-    #   end
-    # end
-    #
-    # puts Test.new.test
-    #
-    #
-    # Foo.new.hello #=> "hello Merb!"
-    #
-    # ==== Parameters
-    # &block::
-    #   a block containing method definitions that should be
-    #   marked as chainable
-    #
-    # ==== Returns
-    # Module:: The anonymous module that was created
-    def chainable(method = nil, &block)
-      if method.nil? && block_given?
-        mixin = Module.new(&block)
-        include mixin
-        return mixin
-      elsif method && ! block_given?
-        # TODO
-        # def test
-        #   # ...
-        # end
-        # chainable :test
-      end
-    end
-  end
-end

data/lib/rango/mixins/hookable.rb

@@ -1,32 +0,0 @@
-# encoding: utf-8
-
-# class Test
-#   extend Rango::Hookable
-#   install_hook do |instance|
-#     p instance
-#   end
-#
-#   def initialize
-#     p self
-#   end
-# end
-#
-# Test.new
-
-module Rango
-  module Hookable
-    def new(*args)
-      instance = super(*args)
-      self.hooks.each { |hook| hook.call(instance) }
-      return instance
-    end
-
-    def hooks
-      @hooks ||= Array.new
-    end
-
-    def install_hook(&block)
-      self.hooks.push(block)
-    end
-  end
-end

data/lib/rango/mixins/import.rb

@@ -1,89 +0,0 @@
-# encoding: utf-8
-
-# boot: after rango.rb
-
-module Rango
-  # This mixin will be included also to project or your custom app main namespace
-  module ImportMixin
-    # class Project
-    #   extend Rango::ImportMixin
-    # end
-    def self.extended(base)
-      unless base.respond_to?(:root)
-        class << base
-          def root
-            File.dirname(caller[1].split(":").first)
-          end
-        end
-      end
-    end
-
-    # class Project
-    #   class << self
-    #     extend Rango::ImportMixin
-    #   end
-    # end
-    def self.included(base)
-      unless base.respond_to?(:root)
-        base.class_eval do
-          def root
-            File.dirname(caller.last.split(":").first)
-          end
-        end
-      end
-    end
-
-    # @since 0.0.1
-    # @example
-    #   Project.import("blog/views")
-    #   Project.import("blog/views", soft: true)
-    # @param [String] path Path to file which will be loaded using +Kernel#load+ if +Project.settings.debug+ is true or +Kernel#require+ if not.
-    # @param [Hash[soft: Boolean(default true)], @optional] options
-    # @raise [LoadError] Unless <tt>soft: true</tt> option is used, it will raise +LoadError+ if the file wasn't found.
-    # @return [Boolean] If loading suceed.
-    def import(path, options = Hash.new)
-      # it is better than rescue LoadError, because
-      # LoadError can be raise inside the required file
-      fullpath = self.find_absolute(path)
-      if fullpath.nil? && options[:soft]   # any file found and soft importing enabled
-        # do nothing
-      elsif fullpath.nil? && !options[:soft]            # any file found and soft importing disabled
-        raise LoadError, "File #{path.inspect} (treated as #{fullpath.inspect}) doesn't exist"
-      elsif !fullpath.nil?                     # the file was found
-        Kernel.load(fullpath)
-      elsif !fullpath.nil?                    # the file was found
-        Kernel.require(fullpath)
-      end
-    end
-
-    # @since 0.0.2
-    def import_first(paths, options = Hash.new)
-      paths.each do |path|
-        fullpath = self.find_absolute(path)
-        next if fullpath.nil?
-        return self.import(fullpath, options)
-      end
-      raise LoadError unless options[:soft]
-    end
-
-    # @since 0.0.1
-    # @param [String] path Path to loaded file.
-    # @return [Boolean] If the loading was successful.
-    def import!(path)
-      path = File.join(self.root, path)
-      file = self.find_absolute(path)
-      Kernel.load(file)
-    end
-
-    def find(file)
-      ["#{file}.rb", file].find do |file|
-        File.exist?(file)
-      end
-    end
-
-    def find_absolute(file)
-      file = File.join(self.root, file) unless file.match(%r[^/])
-      self.find(file)
-    end
-  end
-end