crystal_ext 0.0.7 → 0.0.11

data/lib/crystal/template/template.rb

@@ -0,0 +1,244 @@
+module Crystal
+  module Template
+    DIRECTORY_NAME = "views"
+    
+    class << self
+      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 = options.stringify_keys!
+        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, options.current_dir)
+      end
+      
+      def read tname, options = {}
+        options = options.to_openobject
+        file = find_template tname, calculate_prefixes(options), options.format, 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, scope.current_dir
+              # p [tname, calculate_prefixes(options), scope.format, 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 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_without_cache path; 
+          File.dirname path
+        end        
+        cache_method_with_params_in_production :dirname                    
+        
+        def find_template tname, prefixes, format, current_dir
+          # splitted into two to optimize cache
+          if tname =~ /^\//
+            find_absolute_template tname, prefixes, format
+          else
+            find_relative_template tname, prefixes, format, current_dir
+          end
+        end
+                
+        def find_absolute_template_without_cache tname, prefixes, 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, environment.directories)
+            return file if file
+          end
+          return nil
+        end
+        cache_method_with_params_in_production :find_absolute_template
+        
+        def find_relative_template_without_cache tname, prefixes, 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, current_dir)
+            return file if file
+          end
+          return nil
+        end
+        cache_method_with_params_in_production :find_relative_template
+        
+        def find_file tname, 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, true)              
+            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
+          logger.warn "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)
+        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

data/lib/crystal/template/template_context.rb

@@ -0,0 +1,57 @@
+module Crystal
+  class TemplateContext
+    include Tilt::CompileSite, Tilt::ContextExt
+    
+    # 
+    # System
+    #
+    attr_accessor :options, :_tilt_template     
+       
+    # for saving :format, :current_dir and others
+    # def scope_variables; @scope_variables ||= OpenObject.new end
+    attr_accessor :scope_variables
+    
+    
+    # 
+    # Helpers
+    # 
+    inject(
+      :workspace => :workspace,
+      :router => :router,
+      :config => :config
+    )
+    
+    delegate :render, :to => ::Crystal::Template
+    delegate :url_for, :to => :router        
+    
+    
+    # 
+    # Content Variables
+    # 
+    attr_accessor :content_block
+    def content_variables; @content_variables ||= {} end    
+    def content_for name, content = nil, &block
+      content ||= capture(&block)
+      (content_variables[name.to_s] ||= "") << content
+      nil
+    end        
+    def prepend_to name, content = nil, &block
+      content ||= capture(&block)
+      (content_variables[name.to_s] ||= "").insert 0, content
+      nil
+    end
+    def wrap_content_for name, &block
+      block.must_be.defined
+      content = capture((content_variables[name.to_s] || ""), &block)
+      content_variables[name.to_s] ||= content
+      nil
+    end
+    def has_content_for? name
+      content_variables.include? name.to_s
+    end    
+        
+    def params
+      workspace.params
+    end        
+  end
+end

data/lib/views/crystal_default_templates/development/error.html.erb

@@ -0,0 +1,11 @@
+<html>
+<body>
+	<p>
+		<b><font color='red'>ERROR:</font></b>
+		<%= error.message.html_escape %>
+	</p>
+	<pre>
+  <%= error.backtrace && error.backtrace.sfilter(Exception.common_filters).join("\n  ").html_escape %>
+	</pre>
+</body>
+</html>

data/lib/views/crystal_default_templates/development/error.js.erb

@@ -0,0 +1 @@
+console.log("<%= error.message.js_escape %>");

data/readme.md

@@ -1,14 +1,11 @@
-# Extensions for the Crystal framework.
+# Crystal - Ruby Web Framework inspired by Rails and Spring.
 
-- abstract_interface - tools for rapid interface creation.
-- common_interface - concrete interface built with abstract_interface tools.
-- asset_packager - packages CSS and JS asset for your application.
-- crystal_ext - additions and extensions of the Crystal.
-- crystal_jquery - jQuery plugin for the Crystal.
-- mongo_mapper_ext - additions and extensions of the MongoMapper.
-- rad - Rapid Application Development tool built upon of the Crystal.
+It kinda does the same thing as Rails but in different way. The idea is to provide you with an application framework as opened and extensible as the Ruby itself.
 
-Please go to specs for docs.
+It's the constructor, built from set of low coupled components. You can start quickly using one of predefined 'opinionated' profiles, or tune and extend it as you wish. 
+The same apply for the architecture of your application - instead of to be a monolith it consists of cooperating plugins/gems. 
 
-P.S.
-All these components will be in standalone gems, but right now it's simpler for me to hold all of them in one place.
+Web tier looks almost like Rails and overall architecture is slightly borrowed from Java Spring framework.
+Yes, I know that IoC aren't much popular in Ruby community, but it's not quite ordinary IoC, and it's really handy.
+
+*It's under heavy development, and not ready to use.*

data/spec/_mailer/basic_spec.rb

@@ -0,0 +1,110 @@
+# require "#{File.expand_path(File.dirname(__FILE__))}/helper"
+# 
+# describe "Render" do
+#   inject :conveyors => :conveyors
+#   
+#   before :all do
+#     class ::AnItem
+#       inherit Crystal::Render
+#       
+#       def show
+#         {'result' => 'value'}
+#       end
+#       
+#       def partial
+#       end
+#       
+#       def format; end
+#     end
+#     
+#     class ::ALayout
+#       inherit Crystal::Render
+#       layout '/ALayout/layout'
+#       
+#       def show
+#       end
+#     end
+#     
+#     @dir = "#{File.expand_path(File.dirname(__FILE__))}/integration_spec"
+#     
+#     $LOAD_PATH << @dir
+#     
+#     Crystal.run nil, {:before => :environment}, :render_spec do
+#       crystal.config.environment = :test
+#       crystal.config.test_error_template = crystal.config.development_error_template
+#     end
+#     
+#     crystal[:config].environment = :test
+#     crystal[:environment] = Crystal::Environment.new
+#     crystal[:environment].load :render_spec
+#     
+#     conveyors.web << Crystal::Processors::RenderObject.new(:remote_object, :method_name, :remote_result)
+#   end
+#   
+#   after :all do
+#     $LOAD_PATH.delete @dir    
+#     crystal.clear    
+#     [:AnItem, :ALayout].each{|c| Object.send :remove_const, c if Object.const_defined? c}    
+#   end
+#   
+#   
+#   it "should correctly display error messages (with correct format)" do
+#     error = StandardError.new('some error')
+#     
+#     workspace = wcall :error => error, :params => {:format => :html}
+#     workspace.response.body.should =~ /html.+some error/m
+#     workspace.response.content_type.should == Mime.html
+#     
+#     workspace = wcall :error => error, :params => {:format => :js}
+#     workspace.response.body.should =~ /some error/
+#     workspace.response.content_type.should == Mime.js
+#     
+#     workspace = wcall :error => error, :params => {:format => :non_existing_mime}
+#     workspace.response.body.should =~ /some error/
+#     workspace.response.content_type.should == Mime.text
+#   end
+#   
+#   it "layout" do
+#     workspace = wcall :remote_object => ALayout.new, :method_name => :show, :params => {:format => :html}
+#     workspace.response.body.should == "Layout html, content"
+#     workspace.response.content_type.should == Mime.html
+# 
+#     workspace = wcall :remote_object => ALayout.new, :method_name => :show, :params => {:format => :js}
+#     workspace.response.body.should == "Layout js, content"
+#     workspace.response.content_type.should == Mime.js
+#   end
+#   
+#   it "context, controller_name, method_name, object" do
+#     controller = AnItem.new
+#     workspace = wcall(
+#       :remote_object => controller, 
+#       :method_name => :show, 
+#       :remote_result => controller.show, 
+#       :params => {:class_name => 'AnItem', :method_name => 'show'}
+#     )
+#     
+#     workspace.response.body.should == %{\
+# Controller: AnItem
+# Class Name: AnItem
+# Mehtod Name: show
+# Result object: value}
+#     workspace.response.content_type.should == Mime.html
+#   end
+#   
+#   it "format" do
+#     workspace = wcall :remote_object => AnItem.new, :method_name => :format, :params => {:format => :html}
+#     workspace.response.body.should == "html format"
+#     workspace.response.content_type.should == Mime.html
+#     
+#     workspace = wcall :remote_object => AnItem.new, :method_name => :format, :params => {:format => :js}
+#     workspace.response.body.should == "js format"
+#     workspace.response.content_type.should == Mime.js
+#   end
+#   
+#   it "should not allow to render partials as actions" do
+#     workspace = wcall :remote_object => AnItem.new, :method_name => :partial
+#     workspace.error.message.should =~ /No template/
+#   end
+#   
+#   it "should be able override layout inside of template"
+# end