lolita-menu 0.0.6

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,15 @@
+source "http://rubygems.org"
+
+gem 'lolita','~>3.1.6'
+gem 'haml', :require=>true
+
+group :development, :test do
+  gem 'rspec', '~>2.6.0'
+  gem "sqlite3"
+  gem 'rspec-rails', '~>2.6.0'
+  gem 'haml-rails'
+  gem "shoulda", ">= 0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/History.rdoc

@@ -0,0 +1,24 @@
+=== Version 0.0.6 / 2011-05-19
+* Bug fixes
+  * Can't recognize HAML files in projects without haml.
+  
+=== Version 0.0.5 / 2011-05-19
+* Bug fixes
+  * HAML dependencies not supported
+  
+=== Version 0.0.4 / 2011-05-19
+* Bug fixes
+  * Wrong table names for models
+
+=== Version 0.0.3 /  2011-05-19
+* Enhancements
+  * README updated
+
+=== Version 0.0.2 / 2011-05-19
+* Bug fixes
+  * migrations have one timestamp 
+  * migration names does not match class names
+
+=== Version 0.0.1 / 2011-05-19
+  * Basic models, controllers, views
+  * JavaScripts, Style, Migrations

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 ITHouse, Arturs Meisters
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,17 @@
+= Lolita Menu
+Create, sort and publish menus with Lolita.
+
+==Instalation
+In your project Gemfile put
+  gem 'lolita-menu'
+And run
+  bundle install
+Like with other Lolita gems call
+  rails g lolita_menu:install
+Since this gem comes with migrations
+  rake db:migrate
+
+Enjoy!
+    
+==Copyright
+Copyright © 2011 ITHouse and Arturs Meisters. See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "lolita-menu"
+  gem.homepage = "http://github.com/ithouse/lolita-menu"
+  gem.license = "MIT"
+  gem.summary = %Q{Menu managing plugin for Lolita.}
+  gem.description = %Q{Manage public menus for each project inside Lolita.}
+  gem.email = "support@ithouse.lv"
+  gem.authors = ["ITHouse","Arturs Meisters"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "lolita-menu #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.6

data/app/controllers/menu_items_controller.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+class MenuItemsController < ActionController::Base
+  include Lolita::Controllers::UserHelpers
+
+  before_filter :authenticate_lolita_user!
+
+  def create
+    menu=Menu.find_by_id(params[:menu_id])
+    item=MenuItem.create!(:name=>"new item",:url=>"/",:menu_id=>params[:menu_id])
+    menu.append(item)
+    render :partial=>"row", :locals=>{:item=>item}
+  end
+
+  def update
+    if item=MenuItem.find_by_id(params[:id])
+      item.send(:"#{params[:attribute]}=",params[:value])
+      item.save
+      render :json=>{:status=>item.errors.any? ? "error" : "saved"}
+    else
+      render :json=>{:status=>"error"}
+    end
+  end
+
+  def update_tree
+    menu=Menu.find_by_id(params[:menu_id])
+
+    if menu && menu.update_whole_tree(params[:items])
+      response.headers["Lolita-Notice"] = I18n.t("lolita.menu.notice")
+    else
+      response.headers["Lolita-Error"] = I18n.t("lolita.menu.error")
+    end
+
+    render :nothing=>true
+  end
+
+  def destroy
+    item=MenuItem.find_by_id(params[:id])
+    item.destroy
+    render :json=>{:id=>item.id}
+  end
+end

data/app/models/menu.rb

@@ -0,0 +1,139 @@
+class Menu < ActiveRecord::Base
+  set_table_name "lolita_menus"
+  
+  has_many :items, :class_name => "MenuItem", :dependent => :destroy
+
+  validates :name, :presence => true
+
+  after_create :create_root, :unless=>:have_root?
+
+  include Lolita::Configuration
+
+  lolita do
+    list do
+      column :name
+      builder :name=>"lolita/menu",:state=>"list"
+    end
+    tab(:content) do
+      field :name
+    end
+  end
+
+  POSITION_ATTRIBUTES = {:left => :lft,:right => :rgt,:depth => :depth,:parent_id => :parent_id}
+  ROOT = "root"
+  NONE = "none"
+
+  def position_attributes
+    POSITION_ATTRIBUTES
+  end
+
+  def root
+    if item=self.items.first
+      item.root
+    end
+  end
+
+  def children
+    self.root.children
+  end
+
+  def append(item)
+    unless item.menu_id == self.id
+      item.menu_id = self.id
+      item.save!
+    end
+    self.root.append(item)
+    item.reload
+  end
+
+  def have_root?
+    !!self.root
+  end
+
+  def update_whole_tree(items)
+    begin
+      self.class.transaction do
+        update_all_items(items)
+        true
+      end
+    end
+  end
+
+  protected
+
+
+  def update_all_items(items)
+    items_ids=items_with_acumulated_ids(items) do |item|
+      update_item(item)
+    end
+    remove_deleted_items(items_ids)
+  end
+
+  def items_with_acumulated_ids(items)
+    item_ids=[]
+    items.each do |key,item|
+      item_ids << item[:item_id]
+      yield item
+    end
+    return item_ids
+  end
+
+  def update_item(item)
+    if is_root?(item)
+      update_root(item)
+    else
+      update_branch(item)
+    end
+  end
+
+  def is_root?(item)
+    item[:item_id]==ROOT
+  end
+
+  def update_root(item)
+    MenuItem.update_all(update_values_for(item),"id=#{root.id}")
+  end
+
+  def update_branch(item)
+    MenuItem.update_all(update_values_for(item),"id=#{item[:item_id].to_i}")
+  end
+
+  def update_values_for(item)
+    values=[]
+    position_attributes.each do |attr_name,field|
+      value = value_for_attribute(attr_name,item)
+      values<<"#{field}=#{value}"
+    end
+    values.join(", ")
+  end
+
+  def value_for_attribute(attr_name,item)
+    if item[attr_name]==NONE || !item[attr_name]
+      "NULL"
+    elsif item[attr_name]==ROOT
+      root.id
+    else
+      item[attr_name].to_i
+    end
+  end
+
+  def remove_deleted_items(ids)
+    deleted_ids=deleted_items_ids(ids)
+    if deleted_ids.any?
+      MenuItem.delete_all("id IN (#{deleted_ids.join(",")})")
+    end
+  end
+
+  def deleted_items_ids(ids)
+    ids = ids.map{|id| id=="root" ? root.id : id.to_i}
+    all_ids = MenuItem.where(:menu_id=>self.id).map{|item| item.id}
+    all_ids - ids
+  end
+
+  private
+
+  def create_root
+    MenuItem.create_root!(self)
+  end
+
+end

data/app/models/menu_item.rb

@@ -0,0 +1,130 @@
+class MenuItem < ActiveRecord::Base
+  set_table_name "lolita_menu_items"
+  
+  attr_accessor :place
+  
+  belongs_to :menu, :class_name => "Menu"
+
+  validates :name,:presence => true
+  validates :url, :format => {:with => /^\/.*/}, :unless=>:root?
+
+  before_create :set_default_positions
+  after_create :put_in_place
+  before_validation :set_default_values, :if=>:new_record?
+
+  class << self
+    def create_root!(menu)
+      new_item = self.create!({:menu_id => menu.id}.merge(default_root_position))
+      menu.items << new_item
+    end
+
+    def default_root_position
+      {
+        :lft=>1,
+        :rgt=>2,
+        :depth=>0,
+        :parent_id=>nil
+      }
+    end
+  end
+  # instance methods
+
+  def visible?
+    self.is_visible
+  end
+
+  def root?
+    self.parent_id.nil?
+  end
+
+  def parent
+    @parent||=self.class.find_by_id(self.parent_id)
+    @parent
+  end
+
+  def parent=(parent_item)
+    @parent=parent_item
+  end
+
+  def children
+    @children||=self.class.where("lft>:left AND rgt<:right AND depth=:depth AND menu_id=:menu",{
+      :left => self.lft,:right => self.rgt,:depth => self.depth+1, :menu=>self.menu_id 
+    }).order("lft asc")
+    @children
+  end
+
+  def root
+    if self.parent_id.nil?
+      self
+    else
+      self.class.where(:menu_id=>self.menu_id,:parent_id=>nil).first
+    end
+  end
+
+  def append(item)
+    append_item(item)
+    recalculate_positions_after(:append)
+  end
+
+  private
+
+  def append_item(item)
+    position=position_for_append
+    self.class.update_all(positions_to_update_string(position),"id=#{item.id}")
+  end
+
+  def recalculate_positions_after(action)
+    if action==:append
+      self.class.update_all("rgt=#{self.rgt+2}","id=#{self.id}")
+    end
+  end
+
+  def positions_to_update_string(positions)
+    result=[]
+    positions.each do |field,value|
+      result<<"#{field}=#{value}"
+    end
+    result.join(", ")
+  end
+
+  def position_for_append
+    {
+      :lft => self.rgt,
+      :rgt => self.rgt+1,
+      :depth => self.depth+1,
+      :parent_id => self.id
+    }
+  end
+
+  def set_default_positions
+    if am_i_new_root? || !menu_id
+      set_root_position
+    else
+      self.place=:append
+    end
+  end
+
+  def am_i_new_root?
+    self.menu_id && Menu.exists?(menu_id) && !MenuItem.where(:menu_id=>menu_id).first
+  end
+
+  def set_root_position
+    self.class.default_root_position.each do |method,value|
+      unless self.send(method)
+        self.send(:"#{method}=",value)
+      end
+    end
+  end
+
+  def put_in_place
+    if place==:append
+      self.menu.root.append(self)
+    end
+  end
+
+  def set_default_values
+    self.name||="root"
+    self.url||="/"
+  end
+
+end