lolita 3.1.1 → 3.1.2

data/Gemfile

@@ -7,9 +7,9 @@ gem "abstract"
 gem "builder", "~> 2.1.2" #cucumber asks for builder 3 but rails supports 2.1
 
 group :mongoid do
-	gem "mongo"
-	gem "mongoid", "~> 2.0.0.rc.7"
-	gem "bson_ext"
+	gem "mongo", "~> 1.3.0"
+	gem "mongoid", "~> 2.0.0"
+	gem "bson_ext", "~> 1.3.0"
 end
 
 #gem 'cover_me', '>= 1.0.0.rc6', :group => :test

data/History.rdoc

@@ -1,3 +1,21 @@
+=== Version 3.1.2 / 2011-04-14
+* Enhancements
+  * Hooks for Lolita::RestController addeed (Arturs Meisters)
+  * Form save response splited in different methods for easy way to override (Arturs Meisters)
+  * Hooks for #render_components (Arturs Meisters)
+  * Hook #run return results from methods and blocks as one big string (Arturs Meisters)
+  * Hooks :run_scope inventend (Arturs Meisters)
+  
+* Bug fixes
+  * Migration detection fixed (Arturs Meisters)
+  * Hooks named fire methods fixed (Arturs Meisters)
+  * Bug fixes in hooks (Arturs Meisters)
+  * Builder bug fix, in production (Arturs Meisters)
+
+=== Version 3.1.1 / 2011-04-13
+* Enhancements
+  * Filters for list added (Gatis Tomsons)
+
 === Version 3.1.0 / 2011-04-12
 * Enhancements
   * Hooks added (Arturs Meisters)
@@ -66,5 +84,5 @@
   * New look (Rolands Bondars)
 
 === Versions before 3.0.3
-Lolita 3.0 is completely different from previous versions and don't have any compability or architecture same as
+Lolita 3 is completely different from previous versions and don't have any compability or architecture same as
 old versions. 

data/README.rdoc

@@ -48,7 +48,49 @@ to all controllers.
 If you decide to use some newer version, you most likely should copy new assets to your project. 
 This can be done with
   rails g lolita:assets
+===Using hooks
 
+Lolita define hooks for RestController and for components.
+====RestController hooks
+
+There are two kind of hooks for all actions - <em>before_[action name]</em> and <em>after_[action name]</em>.
+Define callbacks for those hooks outside of controller. This will call User#log_action each time when #destroy 
+action is requested.
+   Lolita::RestController.before_destroy do
+      User.log_action("Going to delete #{params[:id]}") 
+   end
+Also you can define callbacks in your controllers that extend Lolita::RestController. This will call #set_default_params
+each time #new action is requested.
+   class PostController < Lolita::RestController
+      before_new :set_default_params
+
+      private
+
+      def set_default_params
+        params[:post][:title]="-Your title goes here-"
+      end
+  end
+====Component hooks
+
+Components have three hooks - <em>before</em>, <em>after</em> and <em>around</em>.
+Component hooks are different from controller hooks with names. Each component has it's own name, that is used to
+call component, like
+  render_component :"lolita/configuration/list/display"
+  #same as
+  render_component :"lolita/configuration/list", :display
+and this name is used to add callback for component. As components is not related to specific class, then there
+are only one way to define callback for them.
+  Lolita::Hooks.component(:"lolita/configuration/list/display").before do
+    "<div>My Custom text</div>"
+  end
+That what are inside of blocks depends on place where you define callback if it is in <i>.rb</i> file, than you
+should put HTML in quotes, if in <i>.erb</i> and similar files then there is no need for that. Also blocks with 
+Ruby code only return last line, so you should probably define HTML as shown in previous example.
+For <b>around</b> callback if you pass block, then original content will be replaced with that, but if you want
+to let original content inside of your block content than it is done like this with #let_content method.
+  Lolita::Hooks.component(:"lolita/configuration/list/display").around do
+    "<div style='color:red'>#{let_content}</div>"
+  end
 ==License
 
 Lolita is under MIT license. See LICENSE.txt[https://github.com/ithouse/lolita/blob/master/LICENSE.txt]

data/VERSION

@@ -1 +1 @@
-3.1.1
+3.1.2

data/app/controllers/lolita/rest_controller.rb

@@ -1,44 +1,57 @@
 class Lolita::RestController < ApplicationController
   include Lolita::Controllers::UserHelpers
   include Lolita::Controllers::InternalHelpers
+
+  include Lolita::Hooks
+  add_hook :before_new, :after_new, :before_create,:after_create,:before_edit,:after_edit
+  add_hook :before_update,:after_update,:before_destroy,:after_destroy,:before_index,:after_index
+  add_hook :before_build_resource, :after_build_resource
   
   before_filter :authenticate_lolita_user!
   layout "lolita/application"
   
   def new
+    self.run(:before_new)
     build_resource
     show_form
   end
 
   def create
+    self.run(:before_create)
     build_resource
     save_and_redirect
   end
 
   def edit
+    self.run(:before_edit)
     get_resource
     show_form
   end
   
   def update
+    self.run(:before_update)
     get_resource
     if self.resource
       self.resource=resource_with_attributes(self.resource,resource_attributes)
       save_and_redirect
+
     end
   end
 
   def destroy
+    self.run(:before_destroy)
     get_resource
     if self.resource && self.resource.destroy
       flash.now[:notice] = I18n.t "lolita.shared.destroy_notice"
     else
       flash.now[:alert] = I18n.t "lolita.shared.destroy_alert"
     end
+    self.run(:after_destroy)
     redirect_to :action=>"index"
   end
 
   def index
+    self.run(:before_index)
     respond_to do |format|
       format.html do
         build_response_for(:list,:page=>page)
@@ -47,40 +60,59 @@ class Lolita::RestController < ApplicationController
         render :json=>page
       end
     end
+    self.run(:after_index)
   end
 
   private
 
   def show_form
-    #TODO Valdis: ja es extendoju rest_controller un gribu pārdefinēt edit actionu, man vajag lai
-    #  varu norādīt citu šablonu, piemēram, manā gadījumā ir services_controller un jamais meklē
-    #  "services/form", bet es gribu izmantot to pašu "lolita/rest/form"
-    #  tagad man viss šitais jāpārkopē uz projektu
-
     build_response_for(:tabs)
+    self.run(:"after_#{params[:action]}")
     if request.xhr?
-      render :form, :layout => false
+      render "/lolita/rest/form", :layout => false
     else
-      render :form
+      render "/lolita/rest/form"
     end
   end
   
   def save_and_redirect
-      respond_to do |format|
-        format.html do
-          if self.resource.save
-            flash.now[:notice] = I18n.t "lolita.shared.save_notice"
-          else
-            flash.now[:alert] = I18n.t "lolita.shared.save_alert"
-          end
-          show_form
-        end
-        format.json do
-          render :status => self.resource.save ? 200 : 400, :json => self.resource
-        end
+    respond_to do |format|
+      if self.resource.save
+        self.resource.reload
+        format.html{ respond_html_200}
+        format.json{ respond_json_200}
+      else
+        format.html{ respond_html_400 }
+        format.json{ respond_json_400 }
       end
+    end
   end
   
+  def respond_html_200
+    response.headers["Validation"] = 'true'
+    flash.now[:notice] = I18n.t "lolita.shared.save_notice"
+    show_form
+  end
+
+  def respond_html_400
+    response.headers["Validation"] = 'true'
+    flash.now[:alert] = I18n.t "lolita.shared.save_alert"
+    show_form
+  end
+
+  def respond_json_200
+    respond_json(200)
+  end
+
+  def respond_json_400
+    respond_json(400)
+  end
+
+  def respond_json(status)
+    self.run(:"after_#{params[:action]}")
+    render :status=>status, :json=>self.resource
+  end
+
   def to_list
     builder=build_response_for(:list,:page=>page)
     render :index

data/lib/lolita.rb

@@ -4,16 +4,16 @@ LOLITA_VERSION=File.read(File.expand_path("../../VERSION",__FILE__)).gsub(/[^.\w
 puts "=> Lolita #{LOLITA_VERSION} starting#{defined?(Rails) ? " with Rails" : ""}"
 
 # TODO should allow run lolita seperated
-unless (["-d","--debug"] & ARGV).empty?
-  require "ruby-debug"
-  Debugger.settings[:autoeval]=true
-else
-  unless self.respond_to?(:debugger)
-    def debugger
-      warn "Debugger called at #{caller.first} was ignored, run lolita with -d to attatch debugger."
-    end
-  end
-end
+# unless (["-d","--debug"] & ARGV).empty?
+#   require "ruby-debug"
+#   Debugger.settings[:autoeval]=true
+# else
+#   unless self.respond_to?(:debugger)
+#     def debugger
+#       warn "Debugger called at #{caller.first} was ignored, run lolita with -d to attatch debugger."
+#     end
+#   end
+# end
 
 require 'abstract'
 require 'active_support/core_ext/numeric/time'

data/lib/lolita/builder.rb

@@ -34,14 +34,15 @@ module Lolita
     # default state is <code>:display</code>
     def get_builder(*value)
       if value && !value.empty?
-        set_builder(value)
+        builder_values_from(value)
       elsif @builder
-        set_builder(@builder)
+        builder_values_from(@builder)
       else
         unless @builder
-          @builder=default_builder
+          default_builder
+        else
+          @builder
         end
-        @builder
       end
     end
 
@@ -52,13 +53,13 @@ module Lolita
     
     private
 
-    def set_builder value
+    def builder_values_from value
       if value.is_a?(Hash)
-        @builder=value
+        value
       elsif value.is_a?(Array)
-        @builder={:name=>fix_name(value[0]),:state=>value[1] || default_build_state}
+        {:name=>fix_name(value[0]),:state=>value[1] || default_build_state}
       else
-        @builder={:name=>fix_name(value),:state=>default_build_state}
+        {:name=>fix_name(value),:state=>default_build_state}
       end
     end
     

data/lib/lolita/controllers/component_helpers.rb

@@ -26,23 +26,41 @@ module Lolita
       #      render_component "lolita/list", :display
       #      render_component "lolita/list/display"
       def render_component *args
-        
         @opts=args.extract_options!
         name=args[0]
         state=args[1]
         format=@opts.delete(:format)
+    
         raise "Can't render component without name!" unless name
         will_use_component name 
-        partial_name=File.join("/components",name.to_s,state ? state.to_s : nil)
-        if format
-          with_format(format) do
-            render(:partial=>partial_name,:locals=>@opts)
+        component_name=File.join(name.to_s,state ? state.to_s : nil)
+        partial_name=File.join("/components",component_name)
+        output=output_component(partial_name,component_name,:format=>format,:locals=>@opts)
+        self.respond_to?(:raw) ? raw(output) : output
+      end
+      
+      def output_component(partial_name,name,options={})
+        output=""
+        if options[:format]
+          with_format(options[:format]) do
+            output << output_with_callbacks(partial_name,name,options[:locals])
           end
         else
-          render(:partial=>partial_name,:locals=>@opts)
+          output << output_with_callbacks(partial_name,name,options[:locals])
         end
+        output
       end
-      
+
+      def output_with_callbacks(partial_name,name,locals)
+        output= Lolita::Hooks.component(name).run(:before,:run_scope=>self).to_s
+        block_output=Lolita::Hooks.component(name).run(:around, :run_scope=>self) do
+          render(:partial=>partial_name,:locals=>locals)
+        end
+        output << block_output.to_s
+        output << Lolita::Hooks.component(name).run(:after,:run_scope=>self).to_s
+        output
+      end
+
       def with_format(format, &block)
         old_formats = formats
         self.formats = [format]

data/lib/lolita/controllers/internal_helpers.rb

@@ -60,8 +60,10 @@ module Lolita
       end
 
       def build_resource(attributes=nil)
+        self.run(:before_build_resource)
         attributes||=resource_attributes
         self.resource=resource_with_attributes(resource_class.new,attributes)
+        self.run(:after_build_resource)
       end
 
       def build_response_for(conf_part,options={})

data/lib/lolita/hooks.rb

@@ -92,6 +92,7 @@ module Lolita
     end
 
     module ClassMethods
+      attr_accessor :hooks_run_scope
 
       # Setter for #hook_scope.
       def hooks_scope=(object)
@@ -154,14 +155,17 @@ module Lolita
       #     MyClass.run(:before_save,:after_save,:scope=>MyClass.new)
       #     # this will call callbacks in MyClass instance scope, that means that self will be MyClass instance.
       def run(*hook_names,&block)
+
+        result=nil
         options=hook_names.extract_options!
         (hook_names || []).each do |hook_name|
           raise Lolita::HookNotFound, "Hook #{hook_name} is not defined for #{self}." unless self.has_hook?(hook_name)
-          in_hooks_scope(options[:scope]) do
+          in_hooks_scope(options[:scope],options[:run_scope]) do
             callback=get_callback(hook_name)
-            run_callback(callback,&block)
+            result=run_callback(callback,&block)
           end
         end
+        result
       end
 
       # Is hook with <em>name</em> is defined for class.
@@ -192,7 +196,7 @@ module Lolita
       # Set #method_missing
       def recognize_hook_methods method_name, *args, &block
         if method_name.to_s.match(/^run_(\w+)/)
-          self.run($1,&block)
+          self.run($1,*args,&block)
           true
         end
       end
@@ -201,46 +205,61 @@ module Lolita
 
       # Switch between self and given <em>scope</em>. Block will be executed with <em>scope</em>.
       # And after that it will switch back to self.
-      def in_hooks_scope(scope)
+      def in_hooks_scope(scope,run_scope=nil)
         begin
           self.hooks_scope=scope||self
+          if run_scope
+            run_scope.define_singleton_method(:let_content) do
+              scope.let_content
+            end
+          end
+          self.hooks_run_scope=run_scope || self.hooks_scope
           yield
         ensure
           self.hooks_scope=self
+          self.hooks_run_scope=self.hooks_scope
         end
       end
 
       # Run callback. Each callback is Hash with <i>:methods</i> Array and </i>:blocks</i> Array
       def run_callback(callback,&block)
-        run_methods(callback[:methods],&block)
-        run_blocks(callback[:blocks],&block)
+        method_results=run_methods(callback[:methods],&block)
+        block_results=run_blocks(callback[:blocks],&block)
+        method_results+block_results
       end
 
       # Run methods from <em>methods</em> Array
       def run_methods methods, &block
+        result=""
         (methods||[]).each do |method_name|
-          hooks_scope.__send__(method_name,&block)
+          result << (hooks_run_scope.__send__(method_name,&block)).to_s
         end
+        result
       end
 
       # Run blocks from <em>blocks</em> Array. Also it set #given_callback_content if block is given, this
       # will allow to call #let_content. Each block is runned with #run_block.
       def run_blocks blocks,&given_block
+        result=""
         (blocks||[]).each do |block|
           begin
             if block_given?
               self.given_callback_content=given_block
             end
-            run_block(block,&given_block)
+            result << (run_block(block,&given_block)).to_s
           ensure
             self.given_callback_content=nil
           end
         end
+        if block_given? && (!blocks || (blocks && blocks.empty?))
+          result << run_block(given_block).to_s
+        end
+        result
       end
 
       # Run block in scope. 
       def run_block block, &given_block
-        hooks_scope.instance_eval(&block)
+        hooks_run_scope.instance_eval(&block)
       end
 
       # Return all callbacks
@@ -277,8 +296,10 @@ module Lolita
     module InstanceMethods
 
       # See Lolita::Hooks::ClassMethods#run
-      def run(*hook_names)
-        self.class.run(*hook_names,:scope=>self)
+      def run(*hook_names,&block)
+        options=hook_names ? hook_names.extract_options! : {}
+        options[:scope]=self
+        self.class.run(*hook_names,options,&block)
       end
 
       # See Lolita::Hooks::ClassMethods#let_content
@@ -288,7 +309,7 @@ module Lolita
 
       # See Lolita::Hooks::ClassMethods#method_missing
       def method_missing(*args,&block)
-        unless self.class.recognize_hook_methods(*args,&block)
+        unless self.class.recognize_hook_methods(*args,:scope=>self,&block)
           super
         end
       end

data/lib/lolita/rails/all.rb

@@ -1,3 +1,8 @@
 require 'lolita/mapping'
 require 'lolita/rails'
-require 'lolita/modules'
+require 'lolita/modules'
+
+Lolita::Hooks::NamedHook.add(:components)
+Lolita::Hooks.components.class_eval{
+  add_hook :before,:after,:around
+}

data/lib/lolita/rails/routes.rb

@@ -110,7 +110,7 @@ class RouteSet
     private
 
     def migrating?
-      File.basename($0)=="rake" && $ARGV.include?("db:migrate")
+      File.basename($0)=="rake" && (ARGV.include?("db:migrate"))
     end
   end
 end

data/lolita.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{lolita}
-  s.version = "3.1.1"
+  s.version = "3.1.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["ITHouse (Latvia) and Arturs Meisters"]
-  s.date = %q{2011-04-13}
+  s.date = %q{2011-04-14}
   s.description = %q{Great Rails CMS, that turns your business logic into good-looking, fully functional workspace. }
   s.email = %q{support@ithouse.lv}
   s.extra_rdoc_files = [
@@ -212,11 +212,13 @@ Gem::Specification.new do |s|
     "spec/configuration/tab_spec.rb",
     "spec/configuration/tabs_spec.rb",
     "spec/controllers/internal_helpers_spec.rb",
+    "spec/controllers/lolita_rest_nested_resources_spec.rb",
     "spec/controllers/lolita_rest_spec.rb",
     "spec/dbi/base_spec.rb",
     "spec/hooks_spec.rb",
     "spec/lolita_spec.rb",
     "spec/mapping_spec.rb",
+    "spec/navigation/branch_spec.rb",
     "spec/navigation/tree_spec.rb",
     "spec/orm/mongoid.rb",
     "spec/rails_app/app/controllers/application_controller.rb",
@@ -326,11 +328,13 @@ Gem::Specification.new do |s|
     "spec/configuration/tab_spec.rb",
     "spec/configuration/tabs_spec.rb",
     "spec/controllers/internal_helpers_spec.rb",
+    "spec/controllers/lolita_rest_nested_resources_spec.rb",
     "spec/controllers/lolita_rest_spec.rb",
     "spec/dbi/base_spec.rb",
     "spec/hooks_spec.rb",
     "spec/lolita_spec.rb",
     "spec/mapping_spec.rb",
+    "spec/navigation/branch_spec.rb",
     "spec/navigation/tree_spec.rb",
     "spec/orm/mongoid.rb",
     "spec/rails_app/app/controllers/application_controller.rb",

data/spec/controllers/internal_helpers_spec.rb

@@ -5,6 +5,21 @@ require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
 
 class MyController < ApplicationController
   include Lolita::Controllers::InternalHelpers
+  include Lolita::Hooks
+  add_hook :before_build_resource,:after_build_resource
+  add_hook :before_index
+  before_index :modify
+
+  def index
+    @@temp=1
+    self.run_before_index
+  end
+
+  private
+
+  def modify
+    @@temp=3
+  end
 end
 
 describe MyController do
@@ -12,6 +27,11 @@ describe MyController do
      @controller.request.env["lolita.mapping"]=Lolita.mappings[:post]
   end
 
+  it "should call hook in #index" do
+    @controller.index
+    @controller.class.class_variable_get(:"@@temp").should == 3
+  end
+
   it "should get resource name" do
     @controller.resource_name.should == :post
   end

data/spec/controllers/lolita_rest_nested_resources_spec.rb

@@ -0,0 +1,33 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Lolita::RestController do
+  render_views
+
+  before(:each) do
+    @controller.request.env["lolita.mapping"]=Lolita.mappings[:post]
+  end
+
+  it "should create new nested resources together with base resource"
+#  do
+#    p = {:title=>"Post 1"}
+#    p[:comments_attributes] = [{:body=>"Comment 1"}, {:body=>"Comment 2"}]
+#    post :create, :post=>p
+#    Post.last.title.should == "Post 1"
+#    puts Comment.all.to_a.inspect
+#    Post.first.comments.length.should == 2
+#    Post.first.comments.last.body.should == "Comment 2"
+#  end
+
+  it "should create new nested resources for existing base resource"
+
+  it "should add new nested resources for existing base resource with existing nested resourcer"
+
+  it "should remove nested resources from base resource"
+
+  it "should modify nested resources for given base resource"
+
+
+end
+
+
+

data/spec/controllers/lolita_rest_spec.rb

@@ -7,6 +7,17 @@ describe Lolita::RestController do
     @controller.request.env["lolita.mapping"]=Lolita.mappings[:post]
   end
 
+  describe "hooks" do
+    it "should call hooks on #index action" do
+      @controller.class.class_variable_set(:"@@temp",1)
+      @controller.before_index do
+        @@temp=2
+      end
+      get :index
+      @controller.class.class_variable_get(:"@@temp").should == 2
+    end
+  end
+
   it "should render list component for index action" do
     get :index
     response.should render_template("index")

data/spec/hooks_spec.rb

@@ -26,6 +26,7 @@ class Counter
     @value
   end
 end
+
 describe Lolita::Hooks do
   after(:each) do
     MyClass.clear_hooks if MyClass.respond_to?(:clear_hooks)
@@ -116,20 +117,75 @@ describe Lolita::Hooks do
     end
 
 
+    describe "block content" do
+      it "should return block content" do
+        MyClass.after_load do
+          "My name"+
+          let_content.to_s
+        end
+
+        output=MyClass.run(:after_load) do
+          " is Earl"
+        end
+
+        output.should == "My name is Earl"
+      end
+    end
+
     context "wrap around" do
 
       it "should allow to wrap around when #run receive block" do
         MyClass.after_load do 
           value("first")
           let_content()
-          value("second")
         end
 
         MyClass.run(:after_load) do
-          value().should=="first"
+          value("second")
         end
         MyClass.value.should == "second"
       end
+
+      it "should call default block when no block passed as callback" do
+        MyClass.run(:after_load) do
+          value("inblock")
+        end
+
+        MyClass.value.should=="inblock"
+      end
+    end
+
+    context "methods as callbacks" do
+      class MethodTestClass 
+        include Lolita::Hooks
+        add_hook :before_save
+        before_save :set_name
+
+        def save
+          self.run_before_save
+        end
+
+        private
+
+        def self.set_name
+          @name="Class name"
+        end
+
+        def set_name
+          @name="Name"
+        end
+      end
+
+      it "should call callback for method on class" do
+        MethodTestClass.run_before_save
+        MethodTestClass.instance_variable_get(:"@name").should == "Class name"
+      end
+
+      it "should run callbac on instance" do
+        object=MethodTestClass.new
+        object.save
+        object.instance_variable_get(:"@name").should == "Name"
+      end
     end
   end
 
@@ -174,6 +230,15 @@ describe Lolita::Hooks do
       Counter.get.should == 2
     end
 
+    it "should execute run block when no callback block given" do
+      Lolita::Hooks.components.add_hook(:around)
+      Counter.set(0)
+      Lolita::Hooks.components.run(:around) do
+        Counter.set(1)
+      end
+      Counter.get.should==1
+    end
+
     it "should run all named hook callbacks when runned on named collection" do
       pending "Need to update functionality to work."
       Lolita::Hooks.components.add_hook(:after)

data/spec/navigation/branch_spec.rb

@@ -0,0 +1,80 @@
+require File.expand_path(File.dirname(__FILE__) + '/../simple_spec_helper')
+
+describe Lolita::Navigation::Branch do
+  let(:tree){Lolita::Navigation::Tree.new("test tree")}
+
+  describe "attributes" do
+    let(:branch){Lolita::Navigation::Branch.new}
+
+    it "should have title" do
+      branch.title="Pages"
+      branch.title.should == "Pages"
+    end
+
+    it "should have default name" do
+      branch.name.should match(/branch/)
+    end
+
+    it "should not have level when branch is not in tree" do
+      branch.level.should be_nil
+    end
+
+    it "should have options, that may containe any values needed" do
+      branch.options[:url]="/"
+      branch.options[:url].should == "/"
+    end
+
+    it "should belongs to tree" do
+      branch.tree.should be_nil
+      lambda{
+        branch.tree=Object.new
+      }.should raise_error(ArgumentError)
+    end
+
+    context "relationships" do
+
+      it "should have parent" do
+        branch=tree.add(Object)
+        branch.parent.should == tree.root
+      end
+
+      it "should have childern" do
+        branch.append(Lolita::Navigation::Branch.new)
+        branch.children.class.should == Lolita::Navigation::Tree
+        branch.children.should have(1).item
+      end
+
+      it "should have siblings" do
+        tree.add(Object)
+        branch=tree.add(String)
+        branch.siblings[:before].should_not be_nil
+        branch.siblings[:after].should be_nil
+      end
+    end
+  end
+
+  describe "adding" do
+    let(:new_branch){Lolita::Navigation::Branch.new}
+
+    it "should append to existing branch" do
+      new_branch.append(Lolita::Navigation::Branch.new)
+      new_branch.append(Object)
+      new_branch.append("Pages")
+      new_branch.children.should have(3).items
+    end
+
+    it "should prepend to exsiting branch" do
+      new_branch.append(Object)
+      new_branch.prepend(String)
+      new_branch.children.first.object.should == String
+    end
+
+    it "should add before and after branch" do
+      branch=tree.add(Object)
+      branch.before(Lolita::Navigation::Branch.new)
+      branch.after(Object)
+      branch.siblings.values.compact.should have(2).items
+    end
+  end
+
+end

data/spec/navigation/tree_spec.rb

@@ -27,7 +27,7 @@ describe Lolita::Navigation::Tree do
 
   context "#add" do
     it "should accept object, position and options" do
-      tree.add(Object,:append,:url=>"/mypath")
+      tree.add(Object.new,:append,:url=>"/mypath")
       tree.should have(1).branch
     end
   end
@@ -38,7 +38,7 @@ describe Lolita::Navigation::Tree do
 
     it "should iterate through all branches" do
       0.upto(3){|i|
-        tree.add(Object,:append,:url=>"/#{i}",:name=>"branch#{i}")
+        tree.add(Object.new,:append,:url=>"/#{i}",:name=>"branch#{i}")
       }
       tree.each_with_index do |branch,index|
         branch.name.should == "branch#{index}"

data/spec/rails_app/app/mongoid/post.rb

@@ -12,5 +12,8 @@ class Post
   has_many :comments
   belongs_to :profile
   validates_presence_of :title
+
+  accepts_nested_attributes_for :comments, :reject_if => :all_blank
+
   lolita
 end

metadata

@@ -2,7 +2,7 @@
 name: lolita
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 3.1.1
+  version: 3.1.2
 platform: ruby
 authors: 
 - ITHouse (Latvia) and Arturs Meisters
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-13 00:00:00 +03:00
+date: 2011-04-14 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -372,11 +372,13 @@ files:
 - spec/configuration/tab_spec.rb
 - spec/configuration/tabs_spec.rb
 - spec/controllers/internal_helpers_spec.rb
+- spec/controllers/lolita_rest_nested_resources_spec.rb
 - spec/controllers/lolita_rest_spec.rb
 - spec/dbi/base_spec.rb
 - spec/hooks_spec.rb
 - spec/lolita_spec.rb
 - spec/mapping_spec.rb
+- spec/navigation/branch_spec.rb
 - spec/navigation/tree_spec.rb
 - spec/orm/mongoid.rb
 - spec/rails_app/app/controllers/application_controller.rb
@@ -480,7 +482,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -453610993
+      hash: 43629427
       segments: 
       - 0
       version: "0"
@@ -511,11 +513,13 @@ test_files:
 - spec/configuration/tab_spec.rb
 - spec/configuration/tabs_spec.rb
 - spec/controllers/internal_helpers_spec.rb
+- spec/controllers/lolita_rest_nested_resources_spec.rb
 - spec/controllers/lolita_rest_spec.rb
 - spec/dbi/base_spec.rb
 - spec/hooks_spec.rb
 - spec/lolita_spec.rb
 - spec/mapping_spec.rb
+- spec/navigation/branch_spec.rb
 - spec/navigation/tree_spec.rb
 - spec/orm/mongoid.rb
 - spec/rails_app/app/controllers/application_controller.rb