lolita 3.1.2 → 3.1.3

data/History.rdoc

@@ -1,3 +1,11 @@
+=== Version 3.1.3 /
+* Enhancements
+  * Lolita::Navigation::Tree and Lolita::Navigation::Branch added (Arturs Meisters)
+  * Main navigation tree generate from resources (Arturs Meisters)
+
+* Bug fixes
+  * Hooks #let_content fixed to change after first block. (Arturs Meisters)
+
 === Version 3.1.2 / 2011-04-14
 * Enhancements
   * Hooks for Lolita::RestController addeed (Arturs Meisters)

data/VERSION

@@ -1 +1 @@
-3.1.2
+3.1.3

data/app/controllers/lolita/rest_controller.rb

@@ -47,7 +47,7 @@ class Lolita::RestController < ApplicationController
       flash.now[:alert] = I18n.t "lolita.shared.destroy_alert"
     end
     self.run(:after_destroy)
-    redirect_to :action=>"index"
+    redirect_to lolita_resources_path
   end
 
   def index
@@ -95,7 +95,7 @@ class Lolita::RestController < ApplicationController
   end
 
   def respond_html_400
-    response.headers["Validation"] = 'true'
+    response.headers["Validation"] = 'false'
     flash.now[:alert] = I18n.t "lolita.shared.save_alert"
     show_form
   end

data/app/views/components/lolita/configuration/field/_label.html.erb

@@ -1 +1 @@
-<%= label resource_name,(field.title || field.name), :id=>"field_#{field.__id__}_label" %>
+<%= label resource_name, field.name, raw(field.title), :id=>"field_#{field.__id__}_label" %>

data/app/views/components/lolita/navigation/_display.html.erb

@@ -1,9 +1,3 @@
 <nav>
-  <ul>
-    <% Lolita.resources.each do |name,mapping| %>
-    <li <%=mapping.to==resource_class ? "class='active'" : ""%> >
-      <%= link_to mapping.name.to_s.humanize, lolita_resources_path(mapping) %>
-    </li>
-    <% end %>
-  </ul>
+  <%= render_component :"lolita/navigation",:tree, :tree=>tree %>
 </nav>

data/app/views/components/lolita/navigation/_tree.html.erb

@@ -0,0 +1,24 @@
+<ul>
+  <%tree.branches.each do |branch| 
+     if branch.object.is_a?(Lolita::Mapping) 
+       branch.options[:url]||=lolita_resources_path(branch.object) 
+       active=branch.object.to==resource_class
+     else   
+
+       branch.options[:url]=if branch.options[:url].respond_to?(:call) 
+         self.instance_eval(&(branch.options[:url])) 
+       else 
+         branch.options[:url] 
+       end 
+       active=branch.options[:url]==request.path
+     end 
+     
+    %>
+    <li <%=active ? "class='active'" : ""%>>
+      <%= link_to branch.title, branch.options[:url] %>
+      <% if branch.children.branches.any? %>
+        <%= render_component(:"lolita/navigation",:tree,:tree=>branch.children) %>
+      <% end %>
+    </li>
+  <% end %>
+</ul>

data/app/views/layouts/lolita/application.html.erb

@@ -29,7 +29,7 @@
     <div id="container">
       <%= render_component :"lolita/shared", :header %>
       <div id="main" role="main">
-        <%= render_component :"lolita/navigation",:display %>
+        <%= render_component :"lolita/navigation",:display,:tree=>Lolita::Navigation::Tree[:"left_side_navigation"] %>
         <div id="content" class="<%= content_classes %>">
           <%= yield %>
         </div>

data/lib/lolita/hooks.rb

@@ -126,6 +126,10 @@ module Lolita
         @callbacks={}
       end
 
+      def add_hooks *names
+        add_hook *names
+      end
+
       # This method is used to add hooks for class. It accept one or more hook names.
       # ====Example
       #     add_hook :before_save
@@ -154,17 +158,17 @@ module Lolita
       # ====Example
       #     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)
+      def run(hook_name,*args,&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],options[:run_scope]) do
-            callback=get_callback(hook_name)
-            result=run_callback(callback,&block)
-          end
+        options=args ? args.extract_options! : {}
+
+        raise Lolita::HookNotFound, "Hook #{hook_name} is not defined for #{self}." unless self.has_hook?(hook_name)
+        in_hooks_scope(options[:scope],options[:run_scope]) do
+          callback=get_callback(hook_name)
+          result=run_callback(callback,&block)
         end
+
         result
       end
 
@@ -188,8 +192,10 @@ module Lolita
       #        let_content # execute callback block(-s) in same scope as run is executed.
       #     end
       def let_content
-        if content=self.given_callback_content
+        if self.given_callback_content.respond_to?(:call)
           run_block(self.given_callback_content)
+        elsif self.given_callback_content
+          self.given_callback_content
         end
       end
 
@@ -239,19 +245,20 @@ module Lolita
 
       # 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.
+      # After first run result of first block become #given_callback_content, and when next block
+      # call #let_content, this string will be returned for that block
       def run_blocks blocks,&given_block
         result=""
-        (blocks||[]).each do |block|
-          begin
-            if block_given?
-              self.given_callback_content=given_block
-            end
+
+        self.given_callback_content=block_given? ? given_block : nil
+
+        if blocks && !blocks.empty?
+          blocks.each do |block|
             result << (run_block(block,&given_block)).to_s
-          ensure
-            self.given_callback_content=nil
+            self.given_callback_content=result
           end
-        end
-        if block_given? && (!blocks || (blocks && blocks.empty?))
+        elsif block_given?
+          self.given_callback_content=nil
           result << run_block(given_block).to_s
         end
         result

data/lib/lolita/navigation/branch.rb

@@ -2,6 +2,117 @@ module Lolita
   module Navigation
     class Branch
 
+      attr_accessor :title,:name,:object
+      attr_reader :level,:options,:tree,:parent
+
+      def initialize(*args)
+        
+        @options=args ? args.extract_options! : {}
+        set_object(args||[])
+        set_default_values
+        assign_attributes_from_options
+      end
+
+      def tree=(new_tree)
+        raise ArgumentError, "Tree already assigned" if self.tree || !new_tree.is_a?(Lolita::Navigation::Tree)
+        @tree=new_tree
+      end
+
+      def children
+        @children||=Lolita::Navigation::Tree.new("#{name}_children_tree")
+        @children
+      end
+
+      def index
+        self.tree.get_branch_index(self)
+      end
+
+      def siblings
+        index=self.index
+        {
+          :before=>self.tree.branches[index-1],
+          :after=>self.tree.branches[index+1]
+        }
+      end
+
+      def append(*args)
+        move_to(:append,*args)
+      end
+
+      def after(*args)
+        move_to(:after,*args)
+      end
+
+      def before(*args)
+        move_to(:before,*args)
+      end
+
+      def prepend(*args)
+        move_to(:prepend,*args)
+      end
+
+      def self.get_or_create(*args)
+        options=args ? args.extract_options! : {}
+        args||=[]
+        possible_object=args[0]
+
+        if possible_object.is_a?(String)
+          self.new(possible_object,options.merge(:title=>possible_object))
+        elsif possible_object.is_a?(self)
+          possible_object
+        else
+          self.new(possible_object,options)
+        end
+      end
+
+      def get_or_create(*args)
+        self.class.get_or_create(*args)
+      end
+
+      private
+
+      def move_to(position,*args)
+        branch=get_or_create(*args)
+        raise ArgumentError("Can't #{position} without branch.") unless branch
+        if [:before,:after].include?(position) && !branch.tree
+          raise ArgumentError, "Can't move in not-existing tree!"
+        end
+        new_branch=case position
+        when :append
+          self.children.append(branch)
+        when :prepend
+          self.children.prepend(branch)
+        when :after
+          branch.tree.before(branch,self)
+        when :before
+          branch.tree.after(branch,self)
+        end
+        new_branch.instance_variable_set(:"@level",new_branch.level+([:append,:prepend].include?(position) ? 1 : 0))
+        new_branch
+      end
+
+
+      def set_object(args)
+        @object=if args[0].is_a?(Lolita::Navigation::Tree)
+          @level=0
+          args[0]
+        else
+          args[0]
+        end
+      end
+
+      def set_default_values
+        @name||="branch_#{self.__id__}"
+        @level||=0
+      end
+
+      def assign_attributes_from_options
+        @options.each{|key,value|
+          if self.respond_to?(:"#{key}=")
+            self.send(:"#{key}=",@options.delete(key))
+          end
+        }
+      end
     end
   end
 end

data/lib/lolita/navigation/tree.rb

@@ -1,6 +1,108 @@
 module Lolita
   module Navigation
     class Tree
+      include Enumerable
+      include Lolita::Hooks
+
+      class<<self
+        def remember(tree)
+          @@trees||={}
+          @@trees[tree.name.to_sym]=tree
+        end
+
+        def [](name)
+          @@trees||={}
+          @@trees[name]
+        end
+      end
+
+      add_hooks :before_branch_added, :after_branch_added
+
+      attr_reader :name,:root,:default_position,:branches
+
+      def initialize(name)
+        @name=name
+        @default_possition=:append
+        @branches=[]
+      end
+
+      def each 
+        @branches.each do |branch|
+          yield branch
+          if branch.children.any?
+            branch.children.each do |child|
+              yield child
+            end
+          end
+        end
+      end
+
+      def method_missing method_name, *args
+        @branches.send(method_name.to_sym,*args)
+      end
+
+
+      def append(*branch)
+        adding_branch(*branch) do |fixed_branch|
+          @branches<<fixed_branch
+        end
+      end
+
+      def prepend(*branch)
+        adding_branch(*branch) do |fixed_branch|
+          @branches.unshift(fixed_branch)
+        end
+      end
+
+      def after(given_branch,*other_branch) 
+        index=get_branch_index(given_branch)
+
+        adding_branch(*other_branch) do |fixed_branch|
+          put_in_branches(fixed_branch,index)
+        end
+      end
+
+      def before(given_branch,*other_branch)
+        index=get_branch_index(given_branch)
+
+        adding_branch(*other_branch) do |fixed_branch|
+          put_in_branches(fixed_branch,index-1)
+        end
+      end
+
+      def get_branch_index(given_branch)
+        @branches.each_with_index{|branch,index|
+          return index if given_branch==branch
+        }
+        raise ArgumentError, "Branch #{given_branch.inspect} not exists in #{self.inspect}"
+      end
+
+      private
+
+      def adding_branch *branch
+        self.run(:before_branch_added,*branch)
+        fixed_branch=fix_branch(*branch)
+        yield fixed_branch
+        @last_branch=fixed_branch
+        self.run(:after_branch_added,fixed_branch)
+        fixed_branch
+      end
+
+      def fix_branch(*branch)
+        unless branch[0].is_a?(Lolita::Navigation::Branch)
+          options=branch.extract_options!
+          Lolita::Navigation::Branch.get_or_create(*branch,options.merge(:tree=>self))
+        else
+          branch[0].tree=self
+          branch[0]
+        end
+      end
+
+      def put_in_branches branch,index
+        before_part=@branches.slice(0,index+1) || []
+        after_part=@branches.slice(index+1,@branches.size-index) || []
+        @branches=before_part+[branch]+after_part
+      end
 
     end
   end

data/lib/lolita/rails/routes.rb

@@ -1,13 +1,18 @@
 module ActionDispatch::Routing
   
-class RouteSet
-    # alias_method_chain :draw, :lolita
+  class RouteSet
 
-    # def draw_with_lolita
-    #   Lolita::Hooks.run("")
-    #   draw_without_lolita
-    # end
+    def draw_with_lolita  *args,&block
+      unless Lolita::Navigation::Tree[:"left_side_navigation"]
+        tree=Lolita::Navigation::Tree.new(:"left_side_navigation")
+        Lolita::Navigation::Tree.remember(tree)
+      end
+      draw_without_lolita *args,&block
+    end
+
+    alias_method_chain :draw, :lolita
   end
+
   class Mapper
 
     # Every module, that is used with lolita and has routes, need to have
@@ -51,6 +56,7 @@ class RouteSet
         mapping=Lolita.add_mapping(resource,options)
         Lolita.resources[mapping.name]=mapping
         target_class=mapping.to
+        Lolita::Navigation::Tree[:"left_side_navigation"].append(mapping,:title=>mapping.name.to_s.humanize)
         all_resource_classes<<target_class
 
         lolita_scope mapping.name do

data/lolita.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{lolita}
-  s.version = "3.1.2"
+  s.version = "3.1.3"
 
   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-14}
+  s.date = %q{2011-04-15}
   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 = [
@@ -72,6 +72,7 @@ Gem::Specification.new do |s|
     "app/views/components/lolita/configuration/tab/default/_display.html.erb",
     "app/views/components/lolita/configuration/tabs/_display.html.erb",
     "app/views/components/lolita/navigation/_display.html.erb",
+    "app/views/components/lolita/navigation/_tree.html.erb",
     "app/views/components/lolita/shared/_flash.html.erb",
     "app/views/components/lolita/shared/_header.html.erb",
     "app/views/components/lolita/shared/_right_sidebar.html.erb",

data/spec/navigation/branch_spec.rb

@@ -15,8 +15,8 @@ describe Lolita::Navigation::Branch do
       branch.name.should match(/branch/)
     end
 
-    it "should not have level when branch is not in tree" do
-      branch.level.should be_nil
+    it "should have level 0 when branch is not in tree" do
+      branch.level.should == 0
     end
 
     it "should have options, that may containe any values needed" do
@@ -30,27 +30,6 @@ describe Lolita::Navigation::Branch do
         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
@@ -60,7 +39,7 @@ describe Lolita::Navigation::Branch do
       new_branch.append(Lolita::Navigation::Branch.new)
       new_branch.append(Object)
       new_branch.append("Pages")
-      new_branch.children.should have(3).items
+      new_branch.children.branches.should have(3).items
     end
 
     it "should prepend to exsiting branch" do
@@ -70,11 +49,35 @@ describe Lolita::Navigation::Branch do
     end
 
     it "should add before and after branch" do
-      branch=tree.add(Object)
-      branch.before(Lolita::Navigation::Branch.new)
-      branch.after(Object)
+      branch=tree.append(Object)
+      first_branch=Lolita::Navigation::Branch.new
+      debugger
+      first_branch.before(branch)
+      last_branch=Lolita::Navigation::Branch.new
+      last_branch.after(branch)
       branch.siblings.values.compact.should have(2).items
     end
   end
 
+  describe "relationships" do
+    let(:branch){Lolita::Navigation::Branch.new}
+
+      it "should have parent" do
+        branch=tree.append(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.branches.should have(1).item
+      end
+
+      it "should have siblings" do
+        tree.append(Object)
+        branch=tree.append(String)
+        branch.siblings[:before].should_not be_nil
+        branch.siblings[:after].should be_nil
+      end
+    end
 end

data/spec/navigation/tree_spec.rb

@@ -18,16 +18,13 @@ describe Lolita::Navigation::Tree do
 
   end
 
-  describe "work with nodes" do
-    it "should have root branch with level 0" do
-      tree.root.should_not be_nil
-      tree.root.level.should == 0
+  describe "adding" do
+    it "should append" do
+      tree.append(Lolita::Navigation::Branch.new)
     end
-  end
 
-  context "#add" do
     it "should accept object, position and options" do
-      tree.add(Object.new,:append,:url=>"/mypath")
+      tree.append(Object.new,:url=>"/mypath")
       tree.should have(1).branch
     end
   end
@@ -38,7 +35,7 @@ describe Lolita::Navigation::Tree do
 
     it "should iterate through all branches" do
       0.upto(3){|i|
-        tree.add(Object.new,:append,:url=>"/#{i}",:name=>"branch#{i}")
+        tree.append(Object.new,:url=>"/#{i}",:name=>"branch#{i}")
       }
       tree.each_with_index do |branch,index|
         branch.name.should == "branch#{index}"
@@ -46,37 +43,32 @@ describe Lolita::Navigation::Tree do
     end
 
     it "should itereate in each level" do
-      parent_branch=tree.root
       branch=empty_branch
       0.upto(5){|i|
-        parent_branch.append(branch)
+        tree.append(branch)
         parent_branch=branch
         branch=Lolita::Navigation::Branch.new(Object,:url=>"/")
       }
-      level_counter=1
-      tree.each_level do |branches,level|
-        branches.should have(1).item
-        level.should == level_counter
-        level_counter+=1
+      level_counter=0
+      tree.each do |branch|
+        branch.level.should == level_counter
       end
     end
   end
 
   it "should have callbacks" do
     Lolita::Navigation::Tree.should respond_to(:hooks)
-    hook_names=[:before_load,:after_load,:before_branch_added,:after_branch_added]
+    hook_names=[:before_branch_added,:after_branch_added]
     (Lolita::Navigation::Tree.hooks - hook_names).should be_empty
   end
 
   it "should have way to add branches based on earlier added branches" do
     tree.after_branch_added do
-      self.each do |branch|
-        if branch.resources.is_a?(Object)
-          branch.append(Object,:url=>"/")
-        end
+      unless self.detect{|branch| branch.options[:url]=="/"}
+        self.append(Object,:url=>"/")
       end
     end
-    tree.add(Object,:append,:url=>"/mypath")
+    tree.append(Object,:url=>"/mypath")
     tree.should have(2).branches
   end
 end

metadata

@@ -2,7 +2,7 @@
 name: lolita
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 3.1.2
+  version: 3.1.3
 platform: ruby
 authors: 
 - ITHouse (Latvia) and Arturs Meisters
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-04-14 00:00:00 +03:00
+date: 2011-04-15 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -232,6 +232,7 @@ files:
 - app/views/components/lolita/configuration/tab/default/_display.html.erb
 - app/views/components/lolita/configuration/tabs/_display.html.erb
 - app/views/components/lolita/navigation/_display.html.erb
+- app/views/components/lolita/navigation/_tree.html.erb
 - app/views/components/lolita/shared/_flash.html.erb
 - app/views/components/lolita/shared/_header.html.erb
 - app/views/components/lolita/shared/_right_sidebar.html.erb
@@ -482,7 +483,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 43629427
+      hash: 1019725473
       segments: 
       - 0
       version: "0"