rad_core 0.0.13 → 0.0.14

data/lib/rad/spec/view.rb

@@ -1,10 +0,0 @@
-raise 'not finished'
-
-# 
-# Routes
-# 
-rspec do
-  def default_path
-    rad.config.default_path!
-  end
-end

data/lib/rad/support/buffered_logger.rb

@@ -1,44 +0,0 @@
-# 
-# In development mode log also to STDOUT
-# 
-ActiveSupport::BufferedLogger.class_eval do
-  
-  def flush_with_stdout
-    STDOUT.write(buffer.join) unless buffer.empty?
-    flush_without_stdout
-  end
-  rad.after :config do
-    if rad.include?(:config) and (rad.config.development? or rad.config.stdout_logger(false))      
-      alias_method_chain :flush, :stdout
-    end
-  end
-  
-  
-  def info_with_format obj
-    info_without_format(obj_to_string(obj))
-  end
-  alias_method_chain :info, :format
-  
-  def warn_with_format obj
-    warn_without_format("WARN: " + obj_to_string(obj))
-  end
-  alias_method_chain :warn, :format
-  
-  def error_with_format obj
-    error_without_format("ERROR: " + obj_to_string(obj))
-  end
-  alias_method_chain :error, :format
-  
-  protected
-    def obj_to_string obj
-      if obj.is_a? Exception
-        backtrace = (obj.backtrace && obj.backtrace.sfilter(Exception.common_filters)) || []
-        %{\
-#{obj.message}
-  #{backtrace.join("\n  ")}
-} 
-      else
-        obj.to_s
-      end
-    end
-end

data/lib/rad/support/callbacks.rb

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

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

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

@@ -1,17 +0,0 @@
-# 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/micon.rb

@@ -1,13 +0,0 @@
-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.rb

@@ -1,63 +0,0 @@
-#
-# 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/template.rb

@@ -1,250 +0,0 @@
-module Rad
-  module Template
-    # DIRECTORY_NAME = "/views"
-    DIRECTORY_NAME = ""
-    
-    class << self
-      def paths; @paths ||= [] end
-      
-      inject(
-        logger: :logger,
-        config: :config,
-        environment: :environment
-      )
-      
-      def render *args, &block
-        result, context = basic_render(parse_arguments(*args), &block)
-        result
-      end        
-      
-      # def render_and_return_context *args, &block
-      #   basic_render(*parse_arguments(*args), &block)
-      # end
-      
-      def render_layout *args
-        options = parse_arguments(*args)        
-        options.must.include :content
-        options.must.include :context
-        
-        result, context = basic_render options do |*args|
-          if args.empty?
-            options.content
-          else
-            args.size.must_be == 1
-            variable_name = args.first.to_s
-            self.context.content_variables[variable_name]
-          end
-        end
-        
-        result
-      end      
-      
-      def exist? tname, options = {}
-        options = options.to_openobject
-        !!find_template(tname, calculate_prefixes(options), options.format, exact_format?(options), options.current_dir)
-      end
-      
-      def read tname, options = {}
-        options = options.to_openobject
-        file = find_template tname, calculate_prefixes(options), options.format, exact_format?(options), options.current_dir
-        raise "No template '#{tname}'!" unless file
-        File.read file
-      end
-      
-      def template_name_with_prefix tname, prefix      
-        index = tname.rindex('/')
-        index = index ? index + 1 : 0
-        tname = tname.clone
-        tname.insert index, prefix
-      end
-      
-      def parse_arguments *args
-        options = args.extract_options!.to_openobject
-        if args.size == 1
-          options.template = args.first
-        else 
-          raise "Invalid input" if args.size != 0
-        end     
-        
-        options
-      end
-      
-      def basic_render options, &block        
-        options = options.clone.to_openobject
-        
-        with_context options do |context|        
-          context.content_block ||= block            
-
-          with_scope options, context do |scope|              
-            unless file = options.file                               
-              file = find_template options.template!, calculate_prefixes(options), scope.format, exact_format?(options), scope.current_dir
-              raise "No template '#{options.template!}'!" unless file
-            end
-            
-            scope.current_dir = dirname(file)
-            
-            template = create_tilt_template file
-            
-            result = with_template context, template do
-              render_template template, options, &context.content_block
-            end
-            
-            return result, context
-          end            
-        end
-      end
-      
-      protected
-        def context          
-          Thread.current[:render_context]
-        end
-        
-        def calculate_prefixes options
-          options.action ? [''] : options.prefixes
-        end
-        
-        def exact_format? options
-          options.action? || options.exact_format?
-        end
-        
-        def with_context options, &block
-          context = Thread.current[:render_context] || options.context || create_context(options)
-          
-          old = Thread.current[:render_context]
-          begin            
-            Thread.current[:render_context] = context
-            block.call context
-          ensure
-            Thread.current[:render_context] = old
-          end
-        end
-        
-        def with_scope options, context, &block
-          initial = context.scope_variables
-
-          old = context.scope_variables || OpenObject.new
-          begin
-            context.scope_variables = {
-              current_dir: (options.current_dir || old.current_dir),
-              format: (options.format || old.format)
-              # prefixes: options.prefixes || old.prefixes
-            }.to_openobject
-
-            block.call context.scope_variables
-          ensure
-            context.scope_variables = old if initial
-          end
-        end
-        
-        def with_template context, template, &block
-          old = context._tilt_template
-          begin            
-            context._tilt_template = template
-            block.call context
-          ensure
-            context._tilt_template = old
-          end
-        end
-        
-        def create_context options
-          context_class = options.context_class || TemplateContext
-          raise "#{context_class} must inherit from TemplateContext!" unless context_class.is? TemplateContext
-          context = context_class.new
-          
-          context.options = options
-
-          if ivs = options.instance_variables
-            (ivs.is_a?(Array) ? ivs : [ivs]).each do |container|              
-              if container.is_a? Hash
-                container.each do |name, value|
-                  context.instance_variable_set("@#{name}", value)
-                end
-              else
-                container.instance_variables.each do |ivname|
-                  iv = container.instance_variable_get(ivname)
-                  context.instance_variable_set(ivname, iv)
-                end
-              end
-            end
-          end
-          
-          context
-        end
-        
-        def dirname path; 
-          File.dirname path
-        end        
-        cache_method_with_params_in_production :dirname                    
-        
-        def find_template tname, prefixes, format, exact_format, current_dir
-          tname.must_be.a String
-          # splitted into two to optimize cache
-          if tname =~ /^\//
-            find_absolute_template tname, prefixes, format, exact_format
-          else
-            find_relative_template tname, prefixes, format, exact_format, current_dir
-          end
-        end
-                
-        def find_absolute_template tname, prefixes, format, exact_format                    
-          prefixes = prefixes || config.default_template_prefixes!
-          prefixes.each do |prefix|
-            tname_with_prefix = template_name_with_prefix("#{DIRECTORY_NAME}#{tname}", prefix)
-            file = find_file(tname_with_prefix, format, exact_format, paths) #environment.directories)
-            return file if file
-          end
-          return nil
-        end
-        cache_method_with_params_in_production :find_absolute_template
-        
-        def find_relative_template tname, prefixes, format, exact_format, current_dir          
-          raise "You can't use relative template path '#{tname}' without :current_dir!" unless current_dir
-          prefixes = prefixes || config.default_template_prefixes!
-          prefixes.each do |prefix|
-            tname_with_prefix = template_name_with_prefix("/#{tname}", prefix)
-            file = find_file(tname_with_prefix, format, exact_format, [current_dir])
-            return file if file
-          end
-          return nil
-        end
-        cache_method_with_params_in_production :find_relative_template
-        
-        def find_file tname, format, exact_format, directories                    
-          if tname.include? '.'
-            _find_file(tname, directories) || _find_file("#{tname}.*", directories)
-          else            
-            if format
-              _find_file("#{tname}.#{format}.*", directories) or
-                _find_file("#{tname}.*", directories, exact_format)
-            else
-              _find_file("#{tname}.*", directories)
-            end
-          end                    
-        end
-        
-        # with_one_extension - 'tname.*' matches not only 'tname.erb' but also 'tname.html.erb', 
-        # with this option enabled it will not match 'tname.html.erb', only 'tname.erb'
-        def _find_file pattern, directories, with_one_extension = false
-          files = environment.find_files_by_pattern_without_cache pattern, directories
-          files = files.select{|f| f !~ /\.[^\.\/]+\.[^\.\/]+$/} if with_one_extension          
-          raise "multiple templates for '#{pattern}'!" if files.size > 1
-          files.first
-        end
-        
-        def create_tilt_template path
-          template_options = {
-            ugly: true,
-            outvar: "@output"
-          }
-          template = Tilt.new(path, nil, template_options){|t| File.read(t.file)}
-        end
-        
-        def render_template template, options, &block
-          locals = options.locals || {}
-          locals[:object] = options.object if options.object?
-
-          template.render context, locals, &block
-        end        
-    end
-  end
-end