rad_core 0.0.13

data/lib/rad/support/callbacks.rb

@@ -0,0 +1,168 @@
+module Rad
+  module Callbacks
+    class AbstractCallback
+      attr_accessor :executor, :terminator
+      attr_reader :conditions
+      def conditions= conditions
+        @conditions = {}
+        conditions.each do |k, v|
+          @conditions[k.to_sym] = if v.is_a? Symbol
+            v.to_s
+          elsif v.is_a? Array
+            v.collect{|e| e.to_s}
+          else
+            v
+          end
+        end
+        @conditions
+      end
+    
+      def terminate? target, result
+        unless terminator.nil?
+          if terminator.is_a? Proc
+            terminator.call target, result
+          else
+            result == terminator
+          end
+        else
+          false
+        end
+      end
+    
+      def run? target, inf
+        if cond = conditions[:if]
+          evaluate_if(cond, target, inf)
+        elsif cond = conditions[:unless]
+          !evaluate_if(cond, target, inf)
+        elsif cond = conditions[:only]
+          evaluate_only(cond, inf)
+        elsif cond = conditions[:except]
+          !evaluate_only(cond, inf)
+        else
+          true
+        end
+      end
+    
+      def add_to_chain target, inf, &the_next
+        if run? target, inf
+          build_block target, &the_next
+        else
+          the_next
+        end         
+      end
+      
+      alias_method :deep_clone, :clone
+      
+      protected
+        def evaluate_if cond, target, inf
+          if cond.is_a? String
+            target.send cond
+          elsif cond.is_a? Proc
+            cond.call target, inf
+          else
+            must_be.never_called
+          end
+        end
+      
+        def evaluate_only cond, inf
+          method = inf[:method].to_s
+          if cond.is_a? String
+            cond == method
+          elsif cond.is_a? Array
+            cond.include? method
+          end
+        end
+    end
+  
+    class BeforeCallback < AbstractCallback    
+      def build_block target, &the_next
+        lambda do        
+          result = if executor.string_or_symbol?
+            target.send executor
+          elsif executor.is_a? Proc
+            executor.call target
+          else
+            must_be.never_called
+          end
+
+          the_next.call unless terminate? target, result
+        end
+      end
+    end
+  
+    class AroundCallback < AbstractCallback
+      def build_block target, &the_next
+        lambda do
+          if executor.string_or_symbol?
+            target.send executor, &the_next
+          elsif executor.is_a? Proc
+            executor.call target, the_next
+          else
+            must_be.never_called
+          end
+        end      
+      end
+    end
+  
+    class AfterCallback < AbstractCallback
+      def build_block target, &the_next
+        lambda do
+          result = if executor.string_or_symbol?
+            target.send executor
+          elsif executor.is_a? Proc
+            executor.call target
+          else
+            must_be.never_called
+          end
+        
+          the_next.call unless terminate? target, result
+        end      
+      end
+    end
+  
+    def run_callbacks callback_name, additional_information = {}, &block
+      callback_name = callback_name.to_s
+      block.must_be.defined
+    
+      callbacks = self.class.callbacks[callback_name]
+      chain_head = block
+      if callbacks and !callbacks.empty?
+        callbacks.reverse_each do |callback|
+          block = callback.add_to_chain self, additional_information, &chain_head
+          chain_head = block if block
+        end
+      end
+      chain_head.call
+    end
+  
+    module ClassMethods
+      inheritable_accessor :callbacks, {}
+    
+      def set_callback callback_name, type, *executor_or_options, &block   
+        # parsing arguments
+        type, callback_name = type.to_s, callback_name.to_s
+        opt = executor_or_options.extract_options!        
+        "You can't provide both method name and block for filter!" if block and !executor_or_options.empty?
+        executor = block || executor_or_options.first
+      
+        type.must_be.in %w{before around after}
+        executor.must_be.defined
+        
+        # creating callback
+        callback = case type
+        when 'before' then BeforeCallback.new
+        when 'around' then AroundCallback.new
+        when 'after' then AfterCallback.new
+        end            
+
+        callback.executor = executor
+        callback.terminator = opt.delete :terminator
+        callback.conditions = opt
+      
+        callbacks[callback_name] ||= []
+        callbacks[callback_name] << callback
+      end
+        
+    end
+  end
+end

data/lib/rad/support/exception.rb

@@ -0,0 +1,31 @@
+class Exception
+  class << self
+    attr_accessor :common_filters
+  end
+end
+Exception.common_filters = [
+  "/gems/haml",
+  "/gems/tilt",
+  "/gems/facets",
+  "/gems/rack",
+  "/gems/mongrel",
+  "/gems/rspec",
+  "/timeout.rb",
+  "/bin/spec",
+  
+  "/rad/support/callbacks",
+  "/rad/template/template",
+  "/rad/template/support/tilt",
+  
+  "/abstract_inteface/lib/abstract_interface/view_builder",
+  "/common_interface/lib/common_interface/view_helper",    
+  
+  # "/rad/template",
+  # "/rad/support",
+  
+  "/monitor",
+  "/synchronize",
+  "/class_loader",
+  "/micon"
+]
+# Exception.common_filters = []

data/lib/rad/support/filters.rb

@@ -0,0 +1,34 @@
+module Rad
+  module Filters
+    inherit Callbacks    
+          
+    module ClassMethods
+      def before *args, &block
+        opt = args.extract_options!
+        if block       
+          set_callback :action, :before, opt, &block
+        else 
+          args.each{|executor| set_callback :action, :before, executor, opt}        
+        end
+      end
+      
+      def around *args, &block
+        opt = args.extract_options!
+        if block       
+          set_callback :action, :around, opt, &block
+        else 
+          args.each{|executor| set_callback :action, :around, executor, opt}        
+        end
+      end
+      
+      def after *args, &block
+        opt = args.extract_options!
+        if block       
+          set_callback :action, :after, opt, &block
+        else 
+          args.each{|executor| set_callback :action, :after, executor, opt}        
+        end
+      end
+    end
+  end
+end

data/lib/rad/support/format.rb

@@ -0,0 +1,17 @@
+# module Rad
+#   class Format < String
+#     def == other
+#       self.to_sym == other
+#     end
+#     
+#     def method_missing m
+#       m = m.to_s
+#       super unless m[-1..-1] == '?'
+#       self == m[0..-2].to_sym
+#     end
+#     
+#     def inspect
+#       self.to_sym.inspect
+#     end
+#   end
+# end

data/lib/rad/support/hacks_and_fixes.rb

@@ -0,0 +1,23 @@
+# 
+# Problem: the Hash::slice method in ActiveSupport works a little differently than in Facets. 
+# And because Facets is overrides ActiveSupport version this causes problems (for example in to_json method)
+# In ActiveSupport it returns :nil if there's no key in Facets it raises error.
+# 
+# Use Case:
+# hash = {:items=>[], "slug"=>"item-z8w", "name"=>"Item", "created_at"=>"2011-01-10T07:04:01Z", "dependent"=>"false", "viewers"=>["manager", "user:user1"], "updated_at"=>"2011-01-10T07:04:01Z", :icon_url=>"null", "text"=>"null", "tags"=>[], "owner_name"=>"user1", "_type"=>"Selector"}
+# args = ["id", "_type", "slug", "name", "text", "tags", "dependent", "owner_name", "viewers", "created_at", "updated_at"]
+# hash.slice *args
+#
+# Solution:
+# Redefining :slice the same way as in ActiveSupport.
+# 
+class Hash
+  def slice(*keep_keys)
+    hash = {}
+    keep_keys.each do |key|      
+      # hash[key] = fetch(key)
+      hash[key] = self[key]
+    end
+    hash
+  end
+end

data/lib/rad/support/micon.rb

@@ -0,0 +1,13 @@
+module Rad
+  class << self
+    delegate :register, :[], :[]=, :before, :after, :before_scope, :after_scope, :activate, :include?, :clear, :delete, to: Micon
+  end
+end
+
+def rad &block
+  if block
+    Rad.class_eval &block
+  else
+    Rad
+  end
+end

data/lib/rad/support/mime.rb

@@ -0,0 +1,13 @@
+module Mime
+  class << self
+    def method_missing m, *args
+      raise "invalid usage of Mime!" unless args.empty?
+      self[m]
+    end
+  
+    def [] type
+      type = ".#{type}" unless type =~ /^\./
+      Rack::Mime.mime_type(type) || raise("Unknown MIME type: #{type}")
+    end
+  end
+end

data/lib/rad/support/module.rb

@@ -0,0 +1,48 @@
+class Module
+  
+  # 
+  # Dynamically enables cache in :production and disables in another environments.
+  # If no environment given uses non-cached version.
+  # 
+  def cache_method_with_params_in_production method        
+    method_with_cache, method_without_cache = "#{method}_with_cache", "#{method}_without_cache"
+    iv = "@#{method}_cache"
+    
+    # raise "Method '#{method}' already defined!" if instance_methods.include?(method)
+    if instance_methods.include?(method_with_cache) or instance_methods.include?(method_without_cache)
+      warn "can't cache the :#{method} twice!" 
+    else
+      alias_method method_without_cache, method      
+
+      # create cached method
+      define_method method_with_cache do |*args| 
+        unless results = instance_variable_get(iv)
+          results = Hash.new(NotDefined)
+          instance_variable_set iv, results
+        end
+
+        result = results[args]
+
+        if result.equal? NotDefined 
+          result = send method_without_cache, *args
+          results[args] = result
+        end
+
+        result
+      end
+
+      # listen to environment events
+      rad.after :config do |config|
+        if config.production?
+          alias_method method, method_with_cache
+        else
+          alias_method method, method_without_cache
+        end
+      end
+
+      # by default uses non-cached version
+      # alias_method method, method_without_cache
+    end        
+  end
+  
+end

data/lib/rad/support/rson.rb

@@ -0,0 +1,53 @@
+class Object
+  def rson?
+    false
+  end
+end
+
+[
+  FalseClass,
+  TrueClass,
+  Numeric,
+  String,
+  Symbol,
+  NilClass,
+].each do |klass|
+  klass.class_eval do
+    def to_rson options = {}
+      self
+    end
+    
+    def rson?
+      true
+    end
+  end
+end
+
+Array.class_eval do
+  def to_rson options = {}
+    collect{|v| v.to_rson(options)}
+  end
+  
+  def rson?
+    all?{|v| v.rson?}
+  end
+end
+  
+[Hash, OpenObject].each do |klass|
+  klass.class_eval do
+    def to_rson options = {}
+      r = self.class.new
+      each do |k, v|
+        r[k.to_rson(options)] = v.to_rson(options)
+      end
+      r
+    end
+  
+    def rson?
+      each do |k, v|
+        return false unless k.rson? and v.rson?
+      end
+      true
+    end
+  end
+end

data/lib/rad/support/ruby_ext_with_active_support.rb

@@ -0,0 +1,4 @@
+OpenObject.class_eval do
+  # support :extract_options for OpenObject
+  def extractable_options?; true end
+end

data/lib/rad/support/string.rb

@@ -0,0 +1,26 @@
+class String
+  def json_escape
+    ERB::Util.json_escape self
+  end
+  
+  def html_escape
+    # ERB::Util.html_escape self
+    Rack::Utils.escape_html self
+  end
+  
+  JS_ESCAPE_MAP = {
+    '\\'    => '\\\\',
+    '</'    => '<\/',
+    "\r\n"  => '\n',
+    "\n"    => '\n',
+    "\r"    => '\n',
+    '"'     => '\\"',
+    "'"     => "\\'" 
+  }  
+  def js_escape
+    gsub(/(\\|<\/|\r\n|[\n\r"'])/){JS_ESCAPE_MAP[$1]}
+  end
+  
+  # String marks, like :format, :safe 
+  def marks; @marks ||= OpenObject.new end
+end

data/lib/rad/support.rb

@@ -0,0 +1,63 @@
+#
+# ruby
+#
+raise 'ruby 1.9.2 or higher required!' unless RUBY_VERSION >= '1.9.2'
+
+Encoding.default_external = Encoding::UTF_8
+Encoding.default_internal = Encoding::UTF_8
+warn "  default source encoding is not UTF-8, something wroing is going on!" if __ENCODING__ != Encoding::UTF_8
+
+# def ensure_utf8! string
+#   raise "invalid encoding (#{string})!" unless string.encoding == Encoding::UTF_8
+# end
+
+
+#
+# gems
+#
+require 'rad_core/gems'
+
+require 'rad/support/active_support'
+
+require 'ruby_ext'
+
+require 'vfs'
+
+require 'ruby_ext/more/open_constructor'
+require 'rad/support/ruby_ext_with_active_support'
+
+require 'class_loader'
+
+require 'micon'
+require 'rad/support/micon'
+
+require 'dictionary'
+
+require 'thread'
+require 'time'
+require 'uri'
+require 'json'
+
+
+require 'addressable/uri'
+require 'rad/support/addressable'
+::Uri = Addressable::URI
+
+#
+# support
+#
+require 'rad/support/hacks_and_fixes'
+
+
+autoload :Nokogiri, 'nokogiri'
+
+[  
+  'module',
+  'buffered_logger',
+  'callbacks',
+  'filters',
+  'mime',  
+  'string',
+  'rson',
+  'exception',
+].each{|f| require "rad/support/#{f}"}

data/lib/rad/template/support/tilt.rb

@@ -0,0 +1,68 @@
+module Tilt
+  # 
+  # Include it into your template context class for :output, :capture and :concat support
+  # 
+  module ContextExt
+    def output
+      _tilt_template.class.output(self)
+    end
+  
+    def capture *args, &block
+      _tilt_template.class.capture self, &block      
+    end
+  
+    def concat value
+      _tilt_template.class.concat self, value
+    end
+  end  
+  
+  class Template
+    def self.get_output context
+      raise "Output variable for #{self.class} not defined!"
+    end
+    
+    def self.capture context, &block
+      raise "capture not implemented for #{self.class}!"
+    end
+    
+    def self.concat context, value
+      raise "concat not implemented for #{self.class}!"
+    end
+  end
+  
+  class ERBTemplate
+    def self.get_output context
+      context.instance_variable_get "@output"
+    end
+    
+    def self.capture context, &block
+      begin
+        old_output = context.instance_variable_get "@output"
+        old_output.must_be.defined
+        context.instance_variable_set "@output", ""
+        block.call
+        context.instance_variable_get "@output"
+      ensure
+        context.instance_variable_set "@output", old_output
+      end      
+    end
+    
+    def self.concat context, value
+      get_output(context) << value
+    end    
+  end
+  
+  class HamlTemplate
+    def self.get_output context
+      context.haml_buffer.buffer
+    end
+    
+    def self.capture context, &block
+      context.capture_haml &block
+    end
+    
+    def self.concat context, value
+      context.haml_concat value
+    end
+  end
+end

data/lib/rad/template/support/tilt_fixes.rb

@@ -0,0 +1,17 @@
+# 
+# Tilt::HamlTemplate.inspect causes error, fixin it.
+# 
+class Tilt::HamlTemplate
+  def inspect
+    "#<Tilt::HamlTemplate:#{object_id} ...>"
+  end
+end
+
+# 
+# Tilt::HamlTemplate.inspect causes error, fixin it.
+#
+class Haml::Buffer
+  def inspect
+    "#<Tilt::Buffer:#{object_id} ...>"
+  end
+end