rubyexts 0.0.1 → 0.0.2

data/CHANGELOG

@@ -1,2 +1,4 @@
 = Version 0.0.1
   * Imported from Rango
+= Version 0.0.2
+  * Imported mixins from Rango

data/lib/rubyexts/attribute.rb

@@ -129,9 +129,11 @@ module AttributeMixin
   # Post.new.updated?
   # # => true
   # @since 0.0.2
-  def questionable(name, default_value)
+  # questionable(:testing) { }
+  def questionable(name, default_value = nil, &block)
     define_method("#{name}?") do
       unless self.instance_variables.include?(name.to_sym)
+        default_value = block_given? ? self.instance_eval(&block) : default_value
         self.instance_variable_set("@#{name}", default_value)
       end
       self.instance_variable_get("@#{name}")

data/lib/rubyexts/kernel.rb

@@ -32,9 +32,7 @@ module Kernel
     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)
+    puts message
     raise exception
   end
 

data/lib/rubyexts/logger.rb

@@ -0,0 +1,101 @@
+# encoding: utf-8
+
+# TODO: documentation
+# TODO: specs
+require "logger"
+require "rubyexts/string" # String#colorize
+
+module RubyExts
+  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/rubyexts/mixins/chainable.rb

@@ -0,0 +1,68 @@
+# encoding: utf-8
+
+# from merb-core
+module RubyExts
+  module Chainable
+    # Allows the definition of methods on a class that will be available via
+    # super.
+    #
+    # ==== Examples
+    #     class Foo
+    #       extend RubyExts::Chainable
+    #       chainable do
+    #         def hello
+    #           "hello"
+    #         end
+    #       end
+    #     end
+    #
+    #     class Foo
+    #       def hello
+    #         super + " Merb!"
+    #       end
+    #     end
+    #
+    # # Example with mixin:
+    # module TestMixin
+    #   extend RubyExts::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/rubyexts/mixins/hookable.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+
+# class Test
+#   extend Rango::Hookable
+#   install_hook do |instance|
+#     p instance
+#   end
+#
+#   def initialize
+#     p self
+#   end
+# end
+#
+# Test.new
+
+module RubyExts
+  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/rubyexts/mixins/import.rb

@@ -0,0 +1,89 @@
+# encoding: utf-8
+
+# boot: after rango.rb
+
+module RubyExts
+  # 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

data/lib/rubyexts/mixins/strategy.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+# Include this module to strategy superclass
+module RubyExts
+  module StrategyMixin
+    class << self
+      attribute :strategies, Array.new
+
+      def register
+        self.strategies.push(self)
+      end
+
+      def find(*args)
+        self.strategies.find { |strategy| strategy.match?(*args) }
+      end
+    end
+
+    def match?(*args)
+      raise "This method must be redefined in subclasses"
+    end
+
+    def run(*args)
+      raise "This method must be redefined in subclasses"
+    end
+
+    # define setup method if you need it
+  end
+end

data/lib/rubyexts/object.rb

@@ -1,26 +1,6 @@
 # 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

data/lib/rubyexts/try.rb

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

data/lib/rubyexts.rb

@@ -1,7 +1,7 @@
 # encoding: utf-8
 
 module RubyExts
-  VERSION ||= "0.0.1"
+  VERSION ||= "0.0.2"
 end
 
 module Kernel

data/script/spec

@@ -9,4 +9,6 @@ Dir[File.join(File.dirname(__FILE__), "..", "vendor", "*")].each do |path|
   end
 end
 
+ARGV.push("spec") if ARGV.empty?
+
 load File.expand_path(File.join(File.dirname(__FILE__), "..", "vendor", "rspec", "bin", "spec"))

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: rubyexts
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - "Jakub \xC5\xA0\xC5\xA5astn\xC3\xBD aka Botanicus"
 autorequire: 
 bindir: bin
 cert_chain: 
-date: 2009-11-23 00:00:00 +00:00
+date: 2009-12-03 00:00:00 +00:00
 default_executable: 
 dependencies: []
 
@@ -31,6 +31,11 @@ files:
 - lib/rubyexts/file.rb
 - lib/rubyexts/hash.rb
 - lib/rubyexts/kernel.rb
+- lib/rubyexts/logger.rb
+- lib/rubyexts/mixins/chainable.rb
+- lib/rubyexts/mixins/hookable.rb
+- lib/rubyexts/mixins/import.rb
+- lib/rubyexts/mixins/strategy.rb
 - lib/rubyexts/module.rb
 - lib/rubyexts/object.rb
 - lib/rubyexts/object_space.rb
@@ -40,6 +45,7 @@ files:
 - lib/rubyexts/string.rb
 - lib/rubyexts/time.rb
 - lib/rubyexts/time_dsl.rb
+- lib/rubyexts/try.rb
 - lib/rubyexts/try_dup.rb
 - lib/rubyexts/unique_array.rb
 - lib/rubyexts.rb