rad_core 0.0.13

data/lib/rad/template/template.rb

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

data/lib/rad/template/template_context.rb

@@ -0,0 +1,62 @@
+module Rad
+  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: ::Rad::Template
+    delegate :url_for, to: :router        
+
+    
+    def j obj
+      obj.to_s.json_escape
+    end
+    
+    
+    # 
+    # Content Variables
+    # 
+    attr_accessor :content_block
+    def content_variables; @content_variables ||= {}.to_openobject 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/rad/template.rb

@@ -0,0 +1,25 @@
+gem "haml"
+
+require 'rad/environment'
+
+require 'erb'
+require 'haml'
+require 'tilt'
+require 'rad/template/support/tilt'
+require 'rad/template/support/tilt_fixes'
+
+[  
+  'template',
+  'template_context'
+].each{|f| require "rad/template/#{f}"}
+
+rad_core_dir = "#{__FILE__}/../../../..".dirname
+Rad::Template.paths << "#{rad_core_dir}/views"
+
+
+# 
+# Initialization
+# 
+Rad::Config::DEFAULTS.merge!(
+  default_template_prefixes: ['', '_']
+)

data/lib/rad_core/gems.rb

@@ -0,0 +1,31 @@
+# core gems dependencies
+gem 'i18n', '0.5.0'
+gem 'treetop', '1.4.9'
+gem 'polyglot', '0.3.1'
+gem 'mime-types', '1.16'
+
+# core gems
+gem 'activesupport', '3.0.3'
+gem 'builder', '2.1.2'
+
+gem 'haml', '3.0.25'
+gem 'tilt', '1.2.1'
+
+gem 'json', '1.4.6'
+gem 'addressable', '2.2.2'
+gem 'nokogiri', '1.4.4'
+gem 'rack', '1.2.1'
+
+gem 'dictionary', '1.0.0'  
+
+gem 'rack', '1.2.1'
+gem 'thin', '1.2.7'
+
+gem 'mail', '2.2.14'
+
+if respond_to? :fake_gem
+  fake_gem 'ruby_ext'
+  fake_gem 'vfs'
+  fake_gem 'micon'
+  fake_gem 'class_loader'
+end

data/readme.md

@@ -0,0 +1,33 @@
+# Rad - Ruby Web Framework inspired by Rails and Spring.
+
+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.
+
+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. 
+
+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.*
+
+## Why did I make another Rails?
+There are many things that I like in Rails:
+
+- high productivity
+- simplicity, agility and iterative development
+- excellent and very usefull ruby extensions
+- nice and very handy API and naming conventions
+- no config and fast start with leaning learning curve
+
+But, there are some problems
+
+- there's only one way - The Rails Way, it's all simple and cool when you are on this way. But if you wanna to step aside and do it in Your way - you'll get big problems, so big that they are almost completely eliminates all the goodness.
+- very hard to extend and customize
+- you forced to build monolithic applications, it's hard to build application as set of modules.
+- weak support of object oriented paradigm, there's really no true inheritance in Controller and Routing scheme.
+- hard to build distributed applications.
+
+With Rad I tried to save all the goodness and use API as closed to Rails as possible but also give the developer freedom to choose it's own way and also solve those important problems.
+
+## TODO
+- add link_to! and some_path! to preserve state

data/spec/controller/abstract_controller_spec/views/OperationsOrderSpec/action.erb

@@ -0,0 +1 @@
+<% OperationsOrderSpec.result << :template %>

data/spec/controller/abstract_controller_spec/views/ViewVariablesSpec/action.erb

@@ -0,0 +1,11 @@
+controller: <%= workspace.controller.class.name %>
+controller_name: <%= controller_name %>
+
+class: <%= workspace.class.name %>
+method_name: <%= workspace.method_name %>
+action: <%= action_name %>
+
+instance_variable: <%= @instance_variable %>
+
+params: <%= params.param %>
+format: <%= params.format %>

data/spec/controller/abstract_controller_spec.rb

@@ -0,0 +1,132 @@
+require "controller/spec_helper"
+
+describe "AbstractController" do  
+  with_environment
+  with_abstract_controller_spec
+  with_view_path "#{spec_dir}/views"
+  
+  before :all do
+    AbstractController = Rad::AbstractController
+  end
+  
+  after :all do
+    remove_constants %w(
+      WorkspaceVariablesSpec
+      SpecialResultSpec
+      RespondToSpec
+      ViewVariablesSpec
+      OperationsOrderSpec
+      NoTemplateSpec
+      AbstractController
+    )
+  end
+  
+  it "should set workspace variables" do
+    class ::WorkspaceVariablesSpec
+      inherit AbstractController
+  
+      def action; end    
+    end
+  
+    ccall WorkspaceVariablesSpec, :action    
+
+    workspace.controller.should be_a(WorkspaceVariablesSpec)
+    workspace.response.should respond_to("body=")
+
+    expected_result = {      
+      params: {},
+  
+      class: WorkspaceVariablesSpec,   
+      method_name: :action, 
+      action: :action
+    }
+    workspace.to_h(true).subset(expected_result.keys).should == expected_result
+  end
+    
+  it "should be able to throw :halt_render in controller or view and that result must be assigned as result" do
+      class ::SpecialResultSpec
+        inherit AbstractController    
+        def action
+          throw :halt_render, 'some content'
+        end      
+      end
+      
+      ccall(SpecialResultSpec, :action).should == "some content"
+    end
+      
+    it "respond_to" do
+      class ::RespondToSpec
+        inherit AbstractController
+        
+        def action
+          respond_to do |format|
+            format.html{render inline: 'html'}
+            format.json{render json: {a: 'b'}}
+          end
+        end
+      end
+      
+      ccall(RespondToSpec, :action, format: 'html').should == 'html'
+      ccall(RespondToSpec, :action, format: 'json').should == %({"a":"b"})
+      lambda{ccall(RespondToSpec, :action, format: 'js')}.should raise_error(/can't respond to 'js' format/)
+    end
+    
+    it "controller's instance variables must be available in view, and also other variables" do
+      class ::ViewVariablesSpec
+        inherit AbstractController
+        
+        def action
+          @instance_variable = "iv value"
+        end
+      end
+      
+      ccall(ViewVariablesSpec, :action, param: 'param value', format: 'html').should == %(\
+controller: ViewVariablesSpec
+controller_name: ViewVariablesSpec
+
+class: ViewVariablesSpec
+method_name: action
+action: action
+
+instance_variable: iv value
+
+params: param value
+format: html)
+    end
+    
+    it "operations order" do
+      class ::OperationsOrderSpec
+        inherit AbstractController
+        
+        def self.result
+          @result ||= []
+        end
+        
+        around do |controller, block|
+          begin
+            OperationsOrderSpec.result << :before
+            block.call
+          ensure
+            OperationsOrderSpec.result << :after
+          end
+        end
+        
+        def action
+          OperationsOrderSpec.result << :action
+        end
+      end
+      
+      ccall(OperationsOrderSpec, :action)
+      OperationsOrderSpec.result.should == [:before, :action, :template, :after]    
+    end
+    
+    it "should write empty response if no template for action" do
+      class NoTemplateSpec
+        inherit AbstractController
+        
+        def action; end
+      end
+      
+      ccall(NoTemplateSpec, :action).should == ""
+    end
+end

data/spec/controller/controller_context_spec/views/ItemSpec/actions.erb

@@ -0,0 +1,4 @@
+<% case value %>
+<% when :increase %>
+<% when :decrease %>
+<% end %>

data/spec/controller/controller_context_spec/views/PageSpec/actions.erb

@@ -0,0 +1,3 @@
+<% case value %>
+<% when :decrease %>
+<% end %>

data/spec/controller/controller_context_spec.rb

@@ -0,0 +1,123 @@
+require "controller/spec_helper"
+
+describe "ControllerContext" do
+  with_environment environment: :development
+  with_view_path "#{spec_dir}/views"
+  
+  before :all do
+    AbstractController = Rad::AbstractController
+    
+    class ItemSpec
+      inherit AbstractController
+      
+      def show; end      
+      def update; end
+      def delete; end
+      def increase; end
+      def decrease; end      
+    end
+    
+    class PageSpec < ItemSpec
+      def show; end
+      def increase; end
+    end    
+    
+    module NamespaceSpec
+      class ClassSpec
+        inherit AbstractController
+        
+        def show; end
+        def update; end
+      end
+    end
+  end
+  
+  after :all do
+    remove_constants %w(
+      ItemSpec
+      PageSpec
+      NamespaceSpec      
+      ItemSpecHelper
+      PageSpecHelper
+      AbstractController
+    )    
+  end
+  
+  describe "basic" do
+    it "should provide template name for non-existing template" do
+      ItemSpec.template_name_for(:delete).should == "/ItemSpec/delete"
+      PageSpec.template_name_for(:delete).should == "/ItemSpec/delete"
+    end
+  
+    it "should provide template name for existing template" do
+      ItemSpec.template_name_for(:update).should == "/ItemSpec/update"
+    end
+  
+    it "should inherit template name for template existing in parent" do
+      PageSpec.template_name_for(:update).should == "/ItemSpec/update"
+    end
+  
+    it "should override template name for template existing in both self and parent" do
+      ItemSpec.template_name_for(:show).should == "/ItemSpec/show"
+      PageSpec.template_name_for(:show).should == "/PageSpec/show"
+    end
+  
+    it "should transfer namespaces into folders" do
+      NamespaceSpec::ClassSpec.template_name_for(:show).should == "/NamespaceSpec/ClassSpec/show"
+    end
+  end
+  
+  describe "actions" do
+    it "should be able to check for action inside of actions.xxx files" do
+      ItemSpec.template_name_for(:increase).should == "/ItemSpec/actions"
+    end
+  
+    it "should be able to check for action inside of actions.xxx files" do
+      ItemSpec.template_name_for(:increase).should == "/ItemSpec/actions"
+      ItemSpec.template_name_for(:decrease).should == "/ItemSpec/actions"
+      ItemSpec.template_name_for(:action_not_defined_inside_of_actions_file).should == "/ItemSpec/action_not_defined_inside_of_actions_file"
+    end
+  
+    it "should inherit actions.xxx" do
+      PageSpec.template_name_for(:increase).should == "/ItemSpec/actions"
+      PageSpec.template_name_for(:decrease).should == "/PageSpec/actions"
+    end
+  end
+  
+  describe "controller_context_class, helper" do
+    before :each do 
+      ItemSpec.instance_variable_set "@controller_context_class", nil
+      ItemSpec.instance_variable_set "@controller_context_class", nil
+    end
+    
+    it "controller_context_class" do
+      ItemSpec.controller_context_class.should == ItemSpec::ItemSpecControllerContext
+      PageSpec.controller_context_class.should == PageSpec::PageSpecControllerContext
+      PageSpec::PageSpecControllerContext.is?(PageSpec::ItemSpecControllerContext).should be_true
+    end
+    
+    it "helper" do
+      module ::ItemSpecHelper
+        def controller_item; end
+      end
+      
+      module ::PageSpecHelper
+        def controller_page; end
+      end
+      
+      ItemSpec.helper ItemSpecHelper
+      PageSpec.helper PageSpecHelper
+      
+      ItemSpec::ItemSpecControllerContext.instance_methods.should include(:controller_item)
+      
+      PageSpec::PageSpecControllerContext.instance_methods.should include(:controller_item)
+      PageSpec::PageSpecControllerContext.instance_methods.should include(:controller_page)
+    end
+  end
+  
+  describe "other" do
+    it "should understand underscored paths" do
+      NamespaceSpec::ClassSpec.template_name_for(:update).should == "/namespace_spec/class_spec/update"
+    end
+  end
+end