lolita 3.1.9 → 3.1.10

data/lib/lolita/base_configuration.rb

@@ -1,166 +1,166 @@
-module Lolita
-  # Base::Configuration methods are accessable through Lolita module.
-  # Like Lolita.modules and Lolita.routes and so on.
-  class BaseConfiguration
-  
-    attr_reader :scope, :modules, :routes, :controllers,:resources
-    attr_accessor :mappings,:default_route,:user_classes,:authentication
-    attr_writer :default_locale
-
-    def initialize(scope)
-      @scope=scope
-      @mappings={}
-      @resources={}
-      @default_module=nil
-      @user_classes=[]
-      @modules=[]
-      @routes={}
-      @controllers={}
-    end
-
-    def navigation
-      @navigation||=Lolita::Navigation::Base.new()
-      @navigation
-    end
-
-    def locales=(value)
-      unless value.is_a?(Array)
-        @locales=[value]
-      else
-        @locales=value
-      end
-    end
-
-    def locales
-      @locales || []
-    end
-
-    def locale()
-      @locale || default_locale
-    end
-
-    def locale=given_locale
-      @locale=if locales.include?(given_locale.to_s.to_sym)
-        given_locale.to_s.to_sym
-      else
-        Lolita.default_locale
-      end
-    end
-    # Return default locale. First looks for defined default locale for Lolita, when not found than
-    # take first of defined #locales for Lolita, if there no defined locales for Lolita, than
-    # look for I18n and take default locale from there or if there is no I18n than take :en
-    def default_locale
-      @default_locale || self.locales.first || (defined?(::I18n) ? ::I18n.default_locale : :en)
-    end
-    # Call (with #call) to route klass
-    # And return all names of routes that are needed for resource.
-    # When with #add_module routes are defined like 
-    #     Lolita.add_module MyModule, :route=>:my_module
-    # then this will be passed to the method that creates routes, but 
-    # when Proc is passed to <i>:route</i> then this Proc should return
-    # name of route or nil.
-    # These names then are used for methods like <em>lolita_[route_name]_route</em>
-    # that should be required somewhere in you module.
-    def conditional_routes(klass=nil)
-      @routes.map{|name,route|
-        if route.first
-          if route.last.respond_to?(:call)
-            route.last.call(klass)
-          else
-            route.last
-          end
-        end
-      }.compact
-    end
-
-    # Find all routes that is needed for defined classes
-    # And return only one for each different route.
-    def common_routes(klasses)
-      @routes.map{|name,route|
-        unless route.first
-          klasses.map{|klass| route.last.respond_to?(:call) ? route.last.call(klass) : route.last}
-        end
-      }.flatten.compact.uniq
-    end
-      
-    # Include module in Lolita, don't know why i need this
-    def use(module_name)
-      Lolita.send(:include,module_name)
-    end
-
-    def add_mapping(resource,options={})
-      mapping = Lolita::Mapping.new(resource, options)
-      self.mappings[mapping.name] = mapping
-      mapping
-    end
-
-    # Add new module to Lolita
-    # Accpted options
-    # * <tt>controller</tt> - not in use
-    # * <tt>nested</tt> - is route stands itsefl or is used in combination with resource
-    # * <tt>route</tt> - Symbol of route name or lambad, that return route name based on resource.
-    # Route name is used to call method lolita_[route_name] in Mapper class, and that should draw route.
-    # * <tt>:name</tt> - name of module, underscored symbol. Used to draw default route, by default always
-    # lolita_rest is called, but if route with resource name is found, than by default this route will be drawn.
-    # Like lolita_for :posts, can go to different controller than rest and do other things.
-    # * <tt>:path</tt> - some file that will be included. Deprecated will be removed
-    # ====Example
-    #     Lolita.add_module Lolita::Posts, :route=>:post, :name=>:post
-    #     lolita_for :posts #=> create url whatever is defined in lolita_post method, and goes to :controller=>"lolita/posts"
-    #     Lolita.add_module Lolita::FileUpload, :route=>lambda{|resource| resource.lolita.tabs.by_type(:file) ? :file_upload : nil}
-    #     lolita_for :users #=> creat default rest urls and also call method lolita_file_upload if user lolita define :file tab.
-    # To add route for public interface that goes to added module, than use 
-    #    Lolita.add_module Post, :name=>:posts
-    # And then when in routes.rb will be defined lolita_for(:posts) it will call method <i>lolita_posts_route</i>
-    # and that method should define resource. 
-    # ====Example
-    #     # require this in your gem or lib
-    #     module ActionDispatch::Routing
-    #        class Mapper
-    #          protected
-    #          def lolita_posts_route mapping, controllers
-    #            resources mapping.plural,:only=>[:index,:new,:create],
-    #              :controller=>controllers[:posts],:module=>mapping.module
-    #          end
-    #        end
-    #      end
-    # You open Mapper class and add your method that call #resources or #match or other method that define route
-    # For common route for all lolita resources your method should look like this
-    # ====Example
-    #     def lolita_files_route 
-    #        mapping=Lolita.add_mapping(:files,:class_name=>"Lolita::Multimedia::File",:module=>"file_upload")
-    #        scope :module=>mapping.module do
-    #            resources mapping.name
-    #        end
-    #     end
-    def add_module module_container, options={}
-      raise ArgumentError, "Can't add module without module container!" unless module_container
-      options.assert_valid_keys(:controller,:route,:model,:path,:name,:nested)
-      name=options[:name]||module_container.to_s.to_sym
-      self.modules<<module_container
-
-      if options.has_key?(:route)
-        self.routes[name]=[options.has_key?(:nested) ? options[:nested] : true,options[:route]]
-      end
-      self.controllers[name]=options[:controller] if options.has_key?(:controller)
-
-      if options[:path]
-        require File.join(options[:path],name.to_s)
-      end
-  
-    end
-
-    # Lolita.extend_route_for(:any,:posts,:file_upload) do |resource|
-    #   if resource.tabs.by_type(:metadata)
-    #     with do
-    #       resources :metadata
-    #     end 
-    #   end
-    #end
-    # :any for any
-    # lolita/posts/metadata
-    # lolita/posts/files/metadata
-    def lolita_extend_route_for()
-    end
-  end
+module Lolita
+  # Base::Configuration methods are accessable through Lolita module.
+  # Like Lolita.modules and Lolita.routes and so on.
+  class BaseConfiguration
+  
+    attr_reader :scope, :modules, :routes, :controllers,:resources
+    attr_accessor :mappings,:default_route,:user_classes,:authentication
+    attr_writer :default_locale
+
+    def initialize(scope)
+      @scope=scope
+      @mappings={}
+      @resources={}
+      @default_module=nil
+      @user_classes=[]
+      @modules=[]
+      @routes={}
+      @controllers={}
+    end
+
+    def navigation
+      @navigation||=Lolita::Navigation::Base.new()
+      @navigation
+    end
+
+    def locales=(value)
+      unless value.is_a?(Array)
+        @locales=[value]
+      else
+        @locales=value
+      end
+    end
+
+    def locales
+      @locales || []
+    end
+
+    def locale()
+      @locale || default_locale
+    end
+
+    def locale=given_locale
+      @locale=if locales.include?(given_locale.to_s.to_sym)
+        given_locale.to_s.to_sym
+      else
+        Lolita.default_locale
+      end
+    end
+    # Return default locale. First looks for defined default locale for Lolita, when not found than
+    # take first of defined #locales for Lolita, if there no defined locales for Lolita, than
+    # look for I18n and take default locale from there or if there is no I18n than take :en
+    def default_locale
+      @default_locale || self.locales.first || (defined?(::I18n) ? ::I18n.default_locale : :en)
+    end
+    # Call (with #call) to route klass
+    # And return all names of routes that are needed for resource.
+    # When with #add_module routes are defined like 
+    #     Lolita.add_module MyModule, :route=>:my_module
+    # then this will be passed to the method that creates routes, but 
+    # when Proc is passed to <i>:route</i> then this Proc should return
+    # name of route or nil.
+    # These names then are used for methods like <em>lolita_[route_name]_route</em>
+    # that should be required somewhere in you module.
+    def conditional_routes(klass=nil)
+      @routes.map{|name,route|
+        if route.first
+          if route.last.respond_to?(:call)
+            route.last.call(klass)
+          else
+            route.last
+          end
+        end
+      }.compact
+    end
+
+    # Find all routes that is needed for defined classes
+    # And return only one for each different route.
+    def common_routes(klasses)
+      @routes.map{|name,route|
+        unless route.first
+          klasses.map{|klass| route.last.respond_to?(:call) ? route.last.call(klass) : route.last}
+        end
+      }.flatten.compact.uniq
+    end
+      
+    # Include module in Lolita, don't know why i need this
+    def use(module_name)
+      Lolita.send(:include,module_name)
+    end
+
+    def add_mapping(resource,options={})
+      mapping = Lolita::Mapping.new(resource, options)
+      self.mappings[mapping.name] = mapping
+      mapping
+    end
+
+    # Add new module to Lolita
+    # Accpted options
+    # * <tt>controller</tt> - not in use
+    # * <tt>nested</tt> - is route stands itsefl or is used in combination with resource
+    # * <tt>route</tt> - Symbol of route name or lambad, that return route name based on resource.
+    # Route name is used to call method lolita_[route_name] in Mapper class, and that should draw route.
+    # * <tt>:name</tt> - name of module, underscored symbol. Used to draw default route, by default always
+    # lolita_rest is called, but if route with resource name is found, than by default this route will be drawn.
+    # Like lolita_for :posts, can go to different controller than rest and do other things.
+    # * <tt>:path</tt> - some file that will be included. Deprecated will be removed
+    # ====Example
+    #     Lolita.add_module Lolita::Posts, :route=>:post, :name=>:post
+    #     lolita_for :posts #=> create url whatever is defined in lolita_post method, and goes to :controller=>"lolita/posts"
+    #     Lolita.add_module Lolita::FileUpload, :route=>lambda{|resource| resource.lolita.tabs.by_type(:file) ? :file_upload : nil}
+    #     lolita_for :users #=> creat default rest urls and also call method lolita_file_upload if user lolita define :file tab.
+    # To add route for public interface that goes to added module, than use 
+    #    Lolita.add_module Post, :name=>:posts
+    # And then when in routes.rb will be defined lolita_for(:posts) it will call method <i>lolita_posts_route</i>
+    # and that method should define resource. 
+    # ====Example
+    #     # require this in your gem or lib
+    #     module ActionDispatch::Routing
+    #        class Mapper
+    #          protected
+    #          def lolita_posts_route mapping, controllers
+    #            resources mapping.plural,:only=>[:index,:new,:create],
+    #              :controller=>controllers[:posts],:module=>mapping.module
+    #          end
+    #        end
+    #      end
+    # You open Mapper class and add your method that call #resources or #match or other method that define route
+    # For common route for all lolita resources your method should look like this
+    # ====Example
+    #     def lolita_files_route 
+    #        mapping=Lolita.add_mapping(:files,:class_name=>"Lolita::Multimedia::File",:module=>"file_upload")
+    #        scope :module=>mapping.module do
+    #            resources mapping.name
+    #        end
+    #     end
+    def add_module module_container, options={}
+      raise ArgumentError, "Can't add module without module container!" unless module_container
+      options.assert_valid_keys(:controller,:route,:model,:path,:name,:nested)
+      name=options[:name]||module_container.to_s.to_sym
+      self.modules<<module_container
+
+      if options.has_key?(:route)
+        self.routes[name]=[options.has_key?(:nested) ? options[:nested] : true,options[:route]]
+      end
+      self.controllers[name]=options[:controller] if options.has_key?(:controller)
+
+      if options[:path]
+        require File.join(options[:path],name.to_s)
+      end
+  
+    end
+
+    # Lolita.extend_route_for(:any,:posts,:file_upload) do |resource|
+    #   if resource.tabs.by_type(:metadata)
+    #     with do
+    #       resources :metadata
+    #     end 
+    #   end
+    #end
+    # :any for any
+    # lolita/posts/metadata
+    # lolita/posts/files/metadata
+    def lolita_extend_route_for()
+    end
+  end
 end

data/lib/lolita/builder.rb

@@ -1,250 +1,250 @@
-module Lolita
-  # Any Lolita::Configuration class that should return visual information about itself
-  # can include Builder::Base, that provide default methods for _controllers_ to use.
-  # * #build method is used to render component for class instance.
-  # * #build_options is method that return specific options for builder, to pass to component,
-  #   such as :color,:postition etc.
-  # * #builder is setter/getter method for Lolita::Configuration, that accept Hash or Array or single
-  #   String or Symbol for buider.
-  #
-  # Usage in your model
-  # You can change behaviour of any of configuraton elements, to do so you should specify what 
-  # builder you want to use.
-  #    lolita do
-  #      list do
-  #        column do
-  #          name :my_column
-  #          builder :name => "my_columns",:state => :display, :if=>{:state => :display}
-  #        end
-  #      end
-  #    end
-  # This expample show, how to replace :display component of column by your own :display.
-  # <i>:if</i> is determine, that column use builder provided to component render, but when state is <i>:display</i>
-  # then it will be replaced with this on. There are elements, that only have one <i>:display</i> state, than it's
-  # not necessary to provide <i>:if</i> or <i>:unless</i> state.
-  module Builder
-
-    class Custom
-
-      class << self
-        def create(element, *args)
-          possible_builder = extract_args(*args)
-          if possible_builder.is_a?(Hash)
-            Lolita::Builder::Custom.new(element, possible_builder)
-          else
-            possible_builder
-          end
-        end
-
-        def extract_args(*args)
-          if args && args.any?
-            options = args.extract_options! || {}
-            if args[0] && args[0].is_a?(self)
-              args[0]
-            elsif args[0].is_a?(String) || args[0].is_a?(Symbol)
-              options[:name] = args[0]
-              if args[1]
-                options[:state] = args[1]
-              end
-              options
-            elsif options
-              options
-            else
-               raise ArgumentError, "Don't know how to make builder from #{options}."
-            end
-          else
-            return {}
-          end
-        end
-      end
-
-      attr_accessor :options,:build_attributes
-
-      def initialize(element, attributes_as_hash)
-        @element = element
-        @options = {}
-        @build_attributes = {}
-        @conditions = {}
-        set_attributes(attributes_as_hash)
-        set_default_attribute_values
-      end
-
-      def with(*values)
-        new_values = self.class.extract_args(*values)
-        if new_values.is_a?(Hash)
-          @build_attributes = new_values
-        else
-          raise ArgumentError, "Can't build with other builder, use build on that builder!"
-        end
-        self
-      end
-
-      def build
-        
-        path = if conditions?
-          switch_path do |name,state|
-            if conditions_met?
-              [fixed_name(name).to_sym,state.to_sym]
-            else
-              [self.name, self.state]
-            end
-          end
-        else
-          [self.name,self.state]
-        end
-        result = path + [merged_options]
-        return result
-      end
-
-      def name
-        result = if build_attributes[:name].to_s.size > 0
-          fixed_name(build_attributes[:name])
-        else
-          fixed_name(@name,build_attributes[:name])
-        end
-        result.to_sym
-      end
-
-      def state
-        result = if build_attributes[:state] && build_attributes[:state].to_s.size > 0
-          build_attributes[:state]
-        else
-          @state
-        end
-        result.to_sym
-      end
-
-      private
-
-      def switch_path
-        old_name = @name
-        old_state = @state
-        @name = nil
-        @state = default_state
-        result = yield old_name,old_state
-        @name = old_name
-        @state = old_state
-        result 
-      end
-
-      def conditions?
-        @conditions.any?
-      end
-
-      def conditions_met?
-        @conditions_met = if conditions?
-          if @conditions[:if]
-            compare(@conditions[:if],true)
-          elsif @conditions[:unless]
-            compare(@conditions[:unless],false)
-          end
-        end
-        @conditions_met
-      end
-
-      def compare(pattern,predicate)
-        result = true
-        pattern.each do |key,value|
-          result &&= ((value.to_sym == self.send(key)) == predicate)
-        end
-        result
-      end
-
-      def fixed_name(name_to_fix, first_part = nil)
-        unless name_to_fix.to_s[0] == "/"
-          "/#{first_part.to_s.size > 0 ? first_part : default_name}/#{name_to_fix}".gsub(/\/{2,}/,"/").gsub(/\/$/,"")
-        else
-          name_to_fix
-        end
-      end
-
-      def default_name
-        @element.builder_default_name
-      end
-
-      def default_state
-        @element.builder_default_state
-      end
-
-      def attributes
-        [:name,:state]
-      end
-
-      def conditions
-        [:if,:unless]
-      end
-
-      def merged_options
-        result = {}
-        (@build_attributes || {}).merge(@options).each do |key,value|
-          unless attributes.include?(key.to_sym)
-            result[key.to_sym] = value
-          end
-        end
-        result
-      end
-
-      def set_attributes(attributes_as_hash)
-        attributes_as_hash.each do |attr_name, value|
-          if attributes.include?(attr_name.to_sym)
-            instance_variable_set(:"@#{attr_name}",value)
-          elsif conditions.include?(attr_name.to_sym)
-            @conditions[attr_name.to_sym] = value
-          else
-            @options[attr_name.to_sym] = value
-          end
-        end
-      end
-
-      def set_default_attribute_values
-        @state ||= default_state
-      end
-
-    end
-    
-    def builder *args
-      if args && args.any?
-        set_builder(*args)
-      else
-        @builder||=set_builder(nil)
-        @builder
-      end
-    end
-
-    def builder=(*args)
-      set_builder(*args)
-    end
-
-    def build *values
-      result = builder.with(*values).build
-      result[result.size-1].merge!(default_options)
-      result
-    end
-
-    def default_options
-      {builder_local_variable_name => self}
-    end
-
-    def builder_default_name
-      self.class.to_s.split("::").map(&:underscore).join("/").to_sym
-    end
-
-    alias :builder_name :builder_default_name
-
-    def builder_default_state
-      :display
-    end
-
-    alias :default_build_state :builder_default_state
-
-    private
-
-    def set_builder *args
-      @builder=Lolita::Builder::Custom.create(self,*args)
-    end
-
-    def builder_local_variable_name 
-      self.class.to_s.split("::").last.underscore.to_sym
-    end
-  end
+module Lolita
+  # Any Lolita::Configuration class that should return visual information about itself
+  # can include Builder::Base, that provide default methods for _controllers_ to use.
+  # * #build method is used to render component for class instance.
+  # * #build_options is method that return specific options for builder, to pass to component,
+  #   such as :color,:postition etc.
+  # * #builder is setter/getter method for Lolita::Configuration, that accept Hash or Array or single
+  #   String or Symbol for buider.
+  #
+  # Usage in your model
+  # You can change behaviour of any of configuraton elements, to do so you should specify what 
+  # builder you want to use.
+  #    lolita do
+  #      list do
+  #        column do
+  #          name :my_column
+  #          builder :name => "my_columns",:state => :display, :if=>{:state => :display}
+  #        end
+  #      end
+  #    end
+  # This expample show, how to replace :display component of column by your own :display.
+  # <i>:if</i> is determine, that column use builder provided to component render, but when state is <i>:display</i>
+  # then it will be replaced with this on. There are elements, that only have one <i>:display</i> state, than it's
+  # not necessary to provide <i>:if</i> or <i>:unless</i> state.
+  module Builder
+
+    class Custom
+
+      class << self
+        def create(element, *args)
+          possible_builder = extract_args(*args)
+          if possible_builder.is_a?(Hash)
+            Lolita::Builder::Custom.new(element, possible_builder)
+          else
+            possible_builder
+          end
+        end
+
+        def extract_args(*args)
+          if args && args.any?
+            options = args.extract_options! || {}
+            if args[0] && args[0].is_a?(self)
+              args[0]
+            elsif args[0].is_a?(String) || args[0].is_a?(Symbol)
+              options[:name] = args[0]
+              if args[1]
+                options[:state] = args[1]
+              end
+              options
+            elsif options
+              options
+            else
+               raise ArgumentError, "Don't know how to make builder from #{options}."
+            end
+          else
+            return {}
+          end
+        end
+      end
+
+      attr_accessor :options,:build_attributes
+
+      def initialize(element, attributes_as_hash)
+        @element = element
+        @options = {}
+        @build_attributes = {}
+        @conditions = {}
+        set_attributes(attributes_as_hash)
+        set_default_attribute_values
+      end
+
+      def with(*values)
+        new_values = self.class.extract_args(*values)
+        if new_values.is_a?(Hash)
+          @build_attributes = new_values
+        else
+          raise ArgumentError, "Can't build with other builder, use build on that builder!"
+        end
+        self
+      end
+
+      def build
+        
+        path = if conditions?
+          switch_path do |name,state|
+            if conditions_met?
+              [fixed_name(name).to_sym,state.to_sym]
+            else
+              [self.name, self.state]
+            end
+          end
+        else
+          [self.name,self.state]
+        end
+        result = path + [merged_options]
+        return result
+      end
+
+      def name
+        result = if build_attributes[:name].to_s.size > 0
+          fixed_name(build_attributes[:name])
+        else
+          fixed_name(@name,build_attributes[:name])
+        end
+        result.to_sym
+      end
+
+      def state
+        result = if build_attributes[:state] && build_attributes[:state].to_s.size > 0
+          build_attributes[:state]
+        else
+          @state
+        end
+        result.to_sym
+      end
+
+      private
+
+      def switch_path
+        old_name = @name
+        old_state = @state
+        @name = nil
+        @state = default_state
+        result = yield old_name,old_state
+        @name = old_name
+        @state = old_state
+        result 
+      end
+
+      def conditions?
+        @conditions.any?
+      end
+
+      def conditions_met?
+        @conditions_met = if conditions?
+          if @conditions[:if]
+            compare(@conditions[:if],true)
+          elsif @conditions[:unless]
+            compare(@conditions[:unless],false)
+          end
+        end
+        @conditions_met
+      end
+
+      def compare(pattern,predicate)
+        result = true
+        pattern.each do |key,value|
+          result &&= ((value.to_sym == self.send(key)) == predicate)
+        end
+        result
+      end
+
+      def fixed_name(name_to_fix, first_part = nil)
+        unless name_to_fix.to_s[0] == "/"
+          "/#{first_part.to_s.size > 0 ? first_part : default_name}/#{name_to_fix}".gsub(/\/{2,}/,"/").gsub(/\/$/,"")
+        else
+          name_to_fix
+        end
+      end
+
+      def default_name
+        @element.builder_default_name
+      end
+
+      def default_state
+        @element.builder_default_state
+      end
+
+      def attributes
+        [:name,:state]
+      end
+
+      def conditions
+        [:if,:unless]
+      end
+
+      def merged_options
+        result = {}
+        (@build_attributes || {}).merge(@options).each do |key,value|
+          unless attributes.include?(key.to_sym)
+            result[key.to_sym] = value
+          end
+        end
+        result
+      end
+
+      def set_attributes(attributes_as_hash)
+        attributes_as_hash.each do |attr_name, value|
+          if attributes.include?(attr_name.to_sym)
+            instance_variable_set(:"@#{attr_name}",value)
+          elsif conditions.include?(attr_name.to_sym)
+            @conditions[attr_name.to_sym] = value
+          else
+            @options[attr_name.to_sym] = value
+          end
+        end
+      end
+
+      def set_default_attribute_values
+        @state ||= default_state
+      end
+
+    end
+    
+    def builder *args
+      if args && args.any?
+        set_builder(*args)
+      else
+        @builder||=set_builder(nil)
+        @builder
+      end
+    end
+
+    def builder=(*args)
+      set_builder(*args)
+    end
+
+    def build *values
+      result = builder.with(*values).build
+      result[result.size-1].merge!(default_options)
+      result
+    end
+
+    def default_options
+      {builder_local_variable_name => self}
+    end
+
+    def builder_default_name
+      self.class.to_s.split("::").map(&:underscore).join("/").to_sym
+    end
+
+    alias :builder_name :builder_default_name
+
+    def builder_default_state
+      :display
+    end
+
+    alias :default_build_state :builder_default_state
+
+    private
+
+    def set_builder *args
+      @builder=Lolita::Builder::Custom.create(self,*args)
+    end
+
+    def builder_local_variable_name 
+      self.class.to_s.split("::").last.underscore.to_sym
+    end
+  end
 end