rad_core 0.0.13 → 0.0.14

data/lib/rad/template/_template.rb

@@ -0,0 +1,175 @@
+class Rad::Template
+  inject logger: :logger, environment: :environment
+
+  attr_accessor :relative_path_resolver, :prefixes
+  require_attr :prefixes
+  
+  def initialize
+    @relative_path_resolver = RelativePathResolver.new
+  end
+  
+  def render *args, &block
+    result, context = basic_render(parse_arguments(*args), &block)
+    result
+  end        
+  
+  def exist? tname, options = {}
+    !!find_template(tname, options)
+  end
+  
+  def read tname, options = {}
+    file = find_template(tname, options) || raise("no template '#{tname}'!")
+    File.read file
+  end
+  
+  def basic_render options, &block
+    with_context options do |context|
+      context.content_block ||= block
+
+      with_scope options, context do |scope|              
+        file = (
+          options[:file] || 
+          find_template(options[:template], options.merge(scope)) ||
+          (options[:if_not_exist] && find_template(options[:if_not_exist], options.merge(scope))) ||
+          raise("no template '#{options[:template]}'!")
+        )
+        
+        scope[:current_dir] = dirname(file)
+        
+        template = create_tilt_template file
+        
+        result = with_template context, template do
+          render_template template, context, options, &context.content_block
+        end
+        
+        return result, context
+      end            
+    end
+  end
+  
+  def parse_arguments *args
+    options = args.extract_options!
+    if args.size == 1
+      options[:template] = args.first
+    else 
+      raise "Invalid input" if args.size != 0
+    end     
+
+    options
+  end
+  
+  def find_file tname, prefixes, format, exact_format, directories
+    prefixes = prefixes || self.prefixes
+    prefixes.each do |prefix|
+      tname = template_name_with_prefix("#{directory_name}#{tname}", prefix)
+      file = 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
+      return file if file
+    end
+    return nil
+  end
+  
+  def directory_name; "" end
+  
+  def paths; @paths ||= [] end
+  
+  protected            
+    # 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 = rad.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 template_name_with_prefix tname, prefix      
+      index = tname.rindex('/')
+      index = index ? index + 1 : 0
+      tname = tname.clone
+      tname.insert index, prefix
+    end
+    
+    def with_context options, &block
+      context = Thread.current[:render_context] || options[:context] || Context.new(options[:instance_variables])
+      
+      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]),
+          relative_path_resolver: (options[:relative_path_resolver] || old[:relative_path_resolver])
+        }
+
+        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 dirname path; 
+      File.dirname path
+    end        
+    cache_method_with_params_in_production :dirname                    
+    
+    def find_template tname, options
+      tname.must_be.a String
+      # splitted into two to optimize cache
+      if tname =~ /^\//
+        find_absolute_template tname, options[:prefixes], options[:format], options[:exact_format]
+      else
+        resolver = options[:relative_path_resolver] || relative_path_resolver
+        resolver.find_relative_template tname, options[:prefixes], options[:format], options[:exact_format], options[:current_dir]
+      end
+    end
+            
+    def find_absolute_template tname, prefixes, format, exact_format                    
+      prefixes = prefixes || self.prefixes
+      find_file(tname, prefixes, format, exact_format, paths)
+    end
+    cache_method_with_params_in_production :find_absolute_template                
+    
+    def create_tilt_template path      
+      Tilt.new(path, nil, ugly: true, outvar: "@output"){|t| File.read(t.file)}
+    end
+    cache_method_with_params_in_production :create_tilt_template
+    
+    def render_template template, context, options, &block
+      locals = options[:locals] || {}
+      if object = options[:object]
+        locals[:object] = object
+      end
+
+      template.render context, locals, &block
+    end        
+end

data/lib/rad/template/template_context.rb

@@ -1,62 +1 @@
-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
+rad.template

data/lib/rad/template.rb

@@ -1,25 +1 @@
-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: ['', '_']
-)
+rad.template

data/lib/rad.rb

@@ -0,0 +1,8 @@
+module Rad
+  VERSION = '0.0.1'
+end
+
+require 'rad/_support/require'
+
+# Environment is the basic component of Rad 
+# it prepares and assembles your app ($LOAD_PATH, plugins and config files)

data/readme.md

@@ -1,14 +1,26 @@
-# Rad - Ruby Web Framework inspired by Rails and Spring.
+# Rad - Ruby Web Framework
 
-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.
+Goals: **give You tools to fight complexity** and freedom to do it in a way You like.
 
-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. 
+You can start quickly using one of predefined *opinionated* profiles, or take a total control over all aspects of environment and completelly modify it according to Your goals. 
 
-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.
+If You whould like **to see it working, please go to http://ruby-lang.info** - that site powered by Rad.
 
-*It's under heavy development, and not ready to use.*
+It's designed to:
+
+- Divide and rule (build app as a set of cooperated components)
+- True support for OOP (models, routes, controllers/resources + views)
+- Simple things should be simple (simple API, instant start with minimal config)
+- Complete control if You need it, it's designed to be open and customizable
+- Agile/Extreme development should be easy (specs, iterative development, fast prototyping)
+
+## Some thecnical thoughts and ideas
+
+- I tried to keep codebase as small and simple as possible and delegate job do another libraries, so actually it's an integration layer on top of other libraries that focuses on providing nice and consistent interface.
+- It uses "conveyors" for assembling all kind of responces, and it's very easy to set custom assembly chain or modify existing one. This way You have a strong controll over wide aspects of framework.
+- So, it looks like **lots of config**? - **No** - there are predefined profiles and if You don't need special environment - just use one and start instantly. But if You ever would need a complete control - it is there.
+- I also tried to comply to KISS principle - always fighting complex stuff, seeking for not needed API or code that can be eliminated or delegated to external library.
+- I tried to reuse existing good stuff as much as possible, for example - web tier looks kinda like Rails (so, You don't have to learn much of new stuff and API) but the behaviour of it is slightly (or sometimes significally) different.
 
 ## Why did I make another Rails?
 There are many things that I like in Rails:
@@ -19,15 +31,31 @@ There are many things that I like in Rails:
 - nice and very handy API and naming conventions
 - no config and fast start with leaning learning curve
 
-But, there are some problems
+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.
+- 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.
+- You forced to build monolithic applications, it's hard to build application as set of modules (partially fixed in Rails 3).
 - 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
+## Finished functional
+
+- Controllers (80% of Rails + new stuff)
+- Views (80% of Rails + new stuff)
+- Router (Polymorphic, Restful, Simple)
+- Migrations (MongoDB, multiple databases, versions, up/down)
+- Deployment automation (90% of capistrano + new stuff)
+- Mailers (80% of Rails)
+- Code reloading in :development
+- Asset packaging
+- MooTools support
+- Specs support (Controllers, Models + new stuff)
+- Console (nothing special, just like rails console)
+- and more ...
+
+## License
+
+Copyright (c) Alexey Petrushin http://4ire.net, released under the **MIT** license.

data/spec/controller/abstract_spec.rb

@@ -0,0 +1,126 @@
+require "spec_helper"
+
+describe "Abstract" do
+  with_view_path "#{spec_dir}/views"
+  with_abstract_controller
+  
+  after :all do
+    remove_constants %w(
+      WorkspaceVariablesSpec
+      SpecialResultSpec
+      RespondToSpec
+      ViewVariablesSpec
+      OperationsOrderSpec
+      NoTemplateSpec      
+    )
+  end
+  
+  it "should set workspace variables" do
+    class ::WorkspaceVariablesSpec
+      inherit Rad::Controller::Abstract
+  
+      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 in controller or view and that result must be assigned as result" do
+    class ::SpecialResultSpec
+      inherit Rad::Controller::Abstract    
+      def action
+        throw :halt, 'some content'
+      end      
+    end
+    
+    ccall(SpecialResultSpec, :action).should == "some content"
+  end
+    
+  it "respond_to" do
+    class ::RespondToSpec
+      inherit Rad::Controller::Abstract
+      
+      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 Rad::Controller::Abstract
+      
+      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 Rad::Controller::Abstract
+      
+      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 render :nothing" do
+    class NoTemplateSpec
+      inherit Rad::Controller::Abstract
+      
+      def action; end
+    end
+    
+    ccall(NoTemplateSpec, :action).should == ""
+  end
+end

data/spec/controller/context_spec.rb

@@ -0,0 +1,123 @@
+require "spec_helper"
+
+describe "Controller Context" do
+  with_view_path "#{spec_dir}/views"
+  
+  before :all do
+    class ItemSpec
+      inherit Rad::Controller::Abstract
+      
+      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 Rad::Controller::Abstract
+        
+        def show; end
+        def update; end
+      end
+    end
+  end
+  
+  after :all do
+    remove_constants %w(
+      ItemSpec
+      PageSpec
+      NamespaceSpec      
+      ItemSpecHelper
+      PageSpecHelper      
+    )    
+  end
+  
+  describe "basic" do    
+    before{@args = [[''], nil, nil, nil]}
+    
+    it "should return nil for non-existing template" do
+      ItemSpec.find_relative_template(:delete, *@args).should be_nil
+      PageSpec.find_relative_template(:delete, *@args).should be_nil
+    end
+  
+    it "should provide template name for existing template" do
+      ItemSpec.find_relative_template(:update, *@args).should == "#{spec_dir}/views/item_spec/update.erb"
+    end
+  
+    it "should inherit template name for template existing in parent" do
+      PageSpec.find_relative_template(:update, *@args).should == "#{spec_dir}/views/item_spec/update.erb"
+    end
+  
+    it "should override template name for template existing in both self and parent" do
+      ItemSpec.find_relative_template(:show, *@args).should == "#{spec_dir}/views/item_spec/show.erb"
+      PageSpec.find_relative_template(:show, *@args).should == "#{spec_dir}/views/page_spec/show.erb"
+    end
+  
+    it "should transfer namespaces into folders" do
+      NamespaceSpec::ClassSpec.find_relative_template(:show, *@args).should == "#{spec_dir}/views/NamespaceSpec/ClassSpec/show.erb"
+    end
+  end
+  
+  describe "actions" do
+    before{@args = [[''], nil, nil, nil]}
+    
+    it "should be able to check for action inside of actions.xxx files" do
+      ItemSpec.find_relative_template(:increase, *@args).should == "#{spec_dir}/views/item_spec/actions.erb"
+    end
+  
+    it "should be able to check for action inside of actions.xxx files" do
+      ItemSpec.find_relative_template(:increase, *@args).should == "#{spec_dir}/views/item_spec/actions.erb"
+      ItemSpec.find_relative_template(:decrease, *@args).should == "#{spec_dir}/views/item_spec/actions.erb"
+      ItemSpec.find_relative_template(:action_not_defined_inside_of_actions_file, *@args).should == nil
+    end
+  
+    it "should inherit actions.xxx" do
+      PageSpec.find_relative_template(:increase, *@args).should == "#{spec_dir}/views/item_spec/actions.erb"
+      PageSpec.find_relative_template(:decrease, *@args).should == "#{spec_dir}/views/page_spec/actions.erb"
+    end
+  end
+  
+  describe "context_class, helper" do
+    before do 
+      ItemSpec.instance_variable_set "@context_class", nil
+      ItemSpec.instance_variable_set "@context_class", nil
+    end
+    
+    it "context_class" do
+      ItemSpec.context_class.should == ItemSpec::ItemSpecContext
+      PageSpec.context_class.should == PageSpec::PageSpecContext
+      PageSpec::PageSpecContext.is?(PageSpec::ItemSpecContext).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::ItemSpecContext.instance_methods.should include(:controller_item)
+      
+      PageSpec::PageSpecContext.instance_methods.should include(:controller_item)
+      PageSpec::PageSpecContext.instance_methods.should include(:controller_page)
+    end
+  end
+  
+  describe "other" do
+    it "should understand underscored paths" do
+      NamespaceSpec::ClassSpec.find_relative_template(:update, [''], nil, nil, nil).should == "#{spec_dir}/views/namespace_spec/class_spec/update.erb"
+    end
+  end
+end