lolita-menu 0.3.6 → 0.4.0

data/lib/lolita-menu/nested_tree/branch_builder.rb

@@ -1,70 +1,70 @@
 module Lolita
-	module Menu
-		module NestedTree
-			class BranchBuilder
+  module Menu
+    module NestedTree
+      class BranchBuilder
 
-				ROOT = "root"
-				NONE = "none"
+        ROOT = "root"
+        NONE = "none"
 
-				def initialize(root, attributes)
-					@root = root
-					@attributes = {}
-					(attributes || {}).each do |key,value|
-						@attributes[key.to_sym] = value
-					end
-				end
+        def initialize(root, attributes)
+          @root = root
+          @attributes = {}
+          (attributes || {}).each do |key,value|
+            @attributes[key.to_sym] = value
+          end
+        end
 
-				def root?
-					@attributes[:item_id] == "root"
-				end
+        def root?
+          @attributes[:item_id] == "root"
+        end
 
-				def value_for(attribute)
-					convert(@attributes[attribute.to_sym])
-				end
+        def value_for(attribute)
+          convert(@attributes[attribute.to_sym])
+        end
 
-				def attribute_value_pairs
-					@attributes.map do |attr, value|
-						[mapping[attr], convert(value)]
-					end
-				end
+        def attribute_value_pairs
+          @attributes.map do |attr, value|
+            [mapping[attr], convert(value)]
+          end
+        end
 
-				def attribute_value_pairs_hash
-					hash = {}
-					attribute_value_pairs.each do |pair|
-						next if pair[0] == :item_id
-						hash[pair[0]] = pair[1]
-					end
-					hash
-				end
+        def attribute_value_pairs_hash
+          hash = {}
+          attribute_value_pairs.each do |pair|
+            next if pair[0] == :item_id
+            hash[pair[0]] = pair[1]
+          end
+          hash
+        end
 
-				private
+        private
 
-				def mapping
-					unless @mapping
-						@mapping = {
-							:left => :lft,
-							:right => :rgt
-						}
-						class << @mapping
-							def [](key)
-								self.keys.include?(key) ? self.fetch(key) : key
-							end
-						end
-					end
-					@mapping
-				end
+        def mapping
+          unless @mapping
+            @mapping = {
+              :left => :lft,
+              :right => :rgt
+            }
+            class << @mapping
+              def [](key)
+                self.keys.include?(key) ? self.fetch(key) : key
+              end
+            end
+          end
+          @mapping
+        end
 
-				def convert(value)
-					if value == ROOT
-						@root.id
-					elsif value == NONE || !value 
-						nil
-					else 
-						value.to_i
-					end
-				end
+        def convert(value)
+          if value == ROOT
+            @root.id
+          elsif value == NONE || !value 
+            nil
+          else 
+            value.to_i
+          end
+        end
 
-			end
-		end
-	end
+      end
+    end
+  end
 end

data/lib/lolita-menu/nested_tree/configuration.rb

@@ -1,87 +1,87 @@
 module Lolita
-	module Menu
-		module NestedTree
-			module ClassMethods
-				# Allows to use tree structure relationship between model records
-				#
-				# ===
-				#
-				# Usage:
-				#
-				# lolita_nested_tree :scope => "User"
-				#
-				# ===
-				#
-				# Configuration options:
-				# * <tt>:scope</tt> - model name (as String)
-				#
-				def lolita_nested_tree(options = {})
-					@lolita_nested_tree ||= Lolita::Menu::NestedTree::Configuration.new(self, options)
-				end
-			end
+  module Menu
+    module NestedTree
+      module ClassMethods
+        # Allows to use tree structure relationship between model records
+        #
+        # ===
+        #
+        # Usage:
+        #
+        # lolita_nested_tree :scope => "User"
+        #
+        # ===
+        #
+        # Configuration options:
+        # * <tt>:scope</tt> - model name (as String)
+        #
+        def lolita_nested_tree(options = {})
+          @lolita_nested_tree ||= Lolita::Menu::NestedTree::Configuration.new(self, options)
+        end
+      end
 
-			class Configuration
+      class Configuration
 
-				attr_reader :klass, :options, :scope, :build_method
+        attr_reader :klass, :options, :scope, :build_method
 
-				def initialize(base_class, options = {})
-					@klass = base_class					
-					@options = options || {}
-					initialize_options
-					normalize_attributes
-					validate
-					extend_scope_classes
-				end
+        def initialize(base_class, options = {})
+          @klass = base_class         
+          @options = options || {}
+          initialize_options
+          normalize_attributes
+          validate
+          extend_scope_classes
+        end
 
-				def scope_keys
-					@scope.map do |scope|
-						@klass.reflect_on_association(scope.to_sym).foreign_key.to_sym
-					end
-				end
+        def scope_keys
+          @scope.map do |scope|
+            @klass.reflect_on_association(scope.to_sym).foreign_key.to_sym
+          end
+        end
 
-				def scope_key_for(klass)
-					scope_reflections.detect do |reflection|
-						reflection.klass == klass
-					end.foreign_key.to_sym
-				end
+        def scope_key_for(klass)
+          scope_reflections.detect do |reflection|
+            reflection.klass == klass
+          end.foreign_key.to_sym
+        end
 
-				def scope_classes
-					@scope.map do |scope|
-						@klass.reflect_on_association(scope.to_sym).klass
-					end
-				end
+        def scope_classes
+          @scope.map do |scope|
+            @klass.reflect_on_association(scope.to_sym).klass
+          end
+        end
 
-				def scope_reflections
-					@scope.map do |scope|
-						@klass.reflect_on_association(scope.to_sym)
-					end
-				end
+        def scope_reflections
+          @scope.map do |scope|
+            @klass.reflect_on_association(scope.to_sym)
+          end
+        end
 
-				private
+        private
 
-				def initialize_options
-					@options.each do |attr, value|
-						self.respond_to?(attr.to_sym) && instance_variable_set(:"@#{attr}", value)
-					end
-				end
+        def initialize_options
+          @options.each do |attr, value|
+            self.respond_to?(attr.to_sym) && instance_variable_set(:"@#{attr}", value)
+          end
+        end
 
-				def normalize_attributes
-					@scope = (@scope.is_a?(Array) && @scope || [@scope]).compact
-				end
+        def normalize_attributes
+          @scope = (@scope.is_a?(Array) && @scope || [@scope]).compact
+        end
 
-				def validate
-					@scope.each do |scope|
-						raise ArgumentError, "#{@klass} should reflect on association #{scope}" unless @klass.reflect_on_association(scope.to_sym)
-					end
-				end
+        def validate
+          @scope.each do |scope|
+            raise ArgumentError, "#{@klass} should reflect on association #{scope}" unless @klass.reflect_on_association(scope.to_sym)
+          end
+        end
 
-				def extend_scope_classes
-					scope_classes.each do |klass|
-						klass.send(:include, Lolita::Menu::NestedTree::Scope)
-					end
-				end
+        def extend_scope_classes
+          scope_classes.each do |klass|
+            klass.send(:include, Lolita::Menu::NestedTree::Scope)
+          end
+        end
 
-			end
-		end
-	end
+      end
+    end
+  end
 end

data/lib/lolita-menu/nested_tree/scope.rb

@@ -1,54 +1,54 @@
 module Lolita
-	module Menu
-		module NestedTree
-			module Scope
-	
-				def self.included(base_class)
-					base_class.extend(ClassMethods)
-					base_class.send(:include, InstanceMethods)
-				end
-
-				module ClassMethods
-					def sees?(tree_class)
-						tree_class.lolita_nested_tree.scope_classes.include?(self)
-					end
-				end
-
-				module InstanceMethods
-					def sees?(tree_class)
-						self.class.sees?(tree_class)
-					end
-
-					def root(tree_class, scope_attributes = {})
-						tree_class.find_or_create_root(merge_scope_with_self(tree_class, scope_attributes))
-					end
-
-					def children(*args)
-						self.root(*args).children
-					end
-
-					def append(item, scope_attributes = {})
-						scope_attributes = merge_scope_with_self(item.class, scope_attributes)
-						scope_root = self.root(item.class, scope_attributes)
-						item.class.with_tree_scope(scope_attributes) do
-							scope_root.append(item)
-							item.reload
-						end
-						item
-					end
-
-					private
-
-					def merge_scope_with_self(tree_class, scope_attributes)
-						scope_attributes.merge(tree_key(tree_class) => self.id)
-					end
-
-					def tree_key(klass)
-						klass.lolita_nested_tree.scope_key_for(self.class)
-					end
-
-				end
-			end
-		end
-	end
+  module Menu
+    module NestedTree
+      module Scope
+  
+        def self.included(base_class)
+          base_class.extend(ClassMethods)
+          base_class.send(:include, InstanceMethods)
+        end
+
+        module ClassMethods
+          def sees?(tree_class)
+            tree_class.lolita_nested_tree.scope_classes.include?(self)
+          end
+        end
+
+        module InstanceMethods
+          def sees?(tree_class)
+            self.class.sees?(tree_class)
+          end
+
+          def root(tree_class, scope_attributes = {})
+            tree_class.find_or_create_root(merge_scope_with_self(tree_class, scope_attributes))
+          end
+
+          def children(*args)
+            self.root(*args).children
+          end
+
+          def append(item, scope_attributes = {})
+            scope_attributes = merge_scope_with_self(item.class, scope_attributes)
+            scope_root = self.root(item.class, scope_attributes)
+            item.class.with_tree_scope(scope_attributes) do
+              scope_root.append(item)
+              item.reload
+            end
+            item
+          end
+
+          private
+
+          def merge_scope_with_self(tree_class, scope_attributes)
+            scope_attributes.merge(tree_key(tree_class) => self.id)
+          end
+
+          def tree_key(klass)
+            klass.lolita_nested_tree.scope_key_for(self.class)
+          end
+
+        end
+      end
+    end
+  end
 end

data/lib/lolita-menu/nested_tree/tree_builder.rb

@@ -1,38 +1,38 @@
 module Lolita
-	module Menu
-		module NestedTree
-			class TreeBuilder
+  module Menu
+    module NestedTree
+      class TreeBuilder
 
-				attr_reader :items, :root
+        attr_reader :items, :root
 
-				def initialize(klass, items, scope_attributes = {})
-					@klass  = klass
-					@scope_attributes = scope_attributes
-					@root = @klass.find_or_create_root(@scope_attributes)
-					@items = items.is_a?(Hash) ? items.values : items
-					@items.map! do |item| 
-						Lolita::Menu::NestedTree::BranchBuilder.new(@root, item)
-					end
-				end
+        def initialize(klass, items, scope_attributes = {})
+          @klass  = klass
+          @scope_attributes = scope_attributes
+          @root = @klass.find_or_create_root(@scope_attributes)
+          @items = items.is_a?(Hash) ? items.values : items
+          @items.map! do |item| 
+            Lolita::Menu::NestedTree::BranchBuilder.new(@root, item)
+          end
+        end
 
-				def item_ids
-					@items.map { |item| item.value_for(:item_id) }
-				end
+        def item_ids
+          @items.map { |item| item.value_for(:item_id) }
+        end
 
-				def update_items
-					@items.each do |item|
-						@klass.update_item(item)
-					end
-					@klass.remove_items(deleted_items)
-				end
+        def update_items
+          @items.each do |item|
+            @klass.update_item(item)
+          end
+          @klass.remove_items(deleted_items)
+        end
 
-				private
+        private
 
-				def deleted_items
-					@klass.with_tree_scope(@scope_attributes).all_tree_item_ids - item_ids
-				end
+        def deleted_items
+          @klass.with_tree_scope(@scope_attributes).all_tree_item_ids - item_ids
+        end
 
-			end
-		end
-	end
+      end
+    end
+  end
 end