lolita 3.0.7 → 3.1.0

data/lib/lolita/adapter/active_record.rb

@@ -64,8 +64,8 @@ module Lolita
       def paginate(opt={})
         #FIXME depend on will_paginate
         if order=opt.delete(:sort)
-          order.map{|c| c.join(" ")}.join(", ")
-          opt[:order_by]=order
+          order=order.map{|c| c.join(" ")}.join(", ")
+          opt[:order]=order
         end
         self.klass.paginate(opt)
       end
@@ -99,13 +99,24 @@ module Lolita
       def field_to_hash(column)
         {
           :name=>column.name,
-          :type=>column.type.to_s,
+          :type=>type_cast(column.type.to_s),
           :title=>column.name.to_s.humanize,
           :options=>{
-            :primary=>column.primary
+            :primary=>column.primary,
+            :native_type=>column.type.to_s
           }
         }
       end
+
+      # Converts SQL types to normal ruby types
+      def type_cast name
+        types = {
+          'decimal' => 'big_decimal',
+          'datetime' => 'time',
+          'text' => 'string'
+        }
+        types[name.to_s] || name
+      end
     end
   end
-end
+end

data/lib/lolita/adapter/mongoid.rb

@@ -47,8 +47,8 @@ module Lolita
 
       def fields
         @fields||=self.klass.fields.collect{|name,field|
-          field_to_hash(name,field)
-        }
+          name[0] == '_' ? nil : field_to_hash(name,field)
+        }.compact
         @fields
       end
 

data/lib/lolita/base_configuration.rb

@@ -5,6 +5,7 @@ module Lolita
   
     attr_reader :scope, :modules, :routes, :controllers,:resources
     attr_accessor :mappings,:default_route,:user_classes,:authentication
+    attr_writer :default_locale
 
     def initialize(scope)
       @scope=scope
@@ -17,15 +18,56 @@ module Lolita
       @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
-            nil
+            route.last
           end
         end
       }.compact
@@ -36,7 +78,7 @@ module Lolita
     def common_routes(klasses)
       @routes.map{|name,route|
         unless route.first
-          klasses.map{|klass| route.last.is_a?(Proc) ? route.last.call(klass) : nil}
+          klasses.map{|klass| route.last.respond_to?(:call) ? route.last.call(klass) : route.last}
         end
       }.flatten.compact.uniq
     end

data/lib/lolita/builder.rb

@@ -8,18 +8,21 @@ module Lolita
   #   String or Symbol for buider.
   #
   module Builder
+    lolita_accessor :builder
 
     # Build response. Render component for current class with given options.
-    def build(options=nil)
+    def build(*args)
+      args||=[]
+      options=args.extract_options!
       builder_options=self.builder_options || {}
       options=(options || {}).merge(builder_options)
-      builder_values=self.builder
-      return builder_values[:name],builder_values[:state],options
+      builder_values=self.get_builder(*args)
+      return builder_values[:name].to_sym,builder_values[:state].to_sym,options
     end
 
     # Default options for class. This method should be overwritten.
     def builder_options
-      {builder_name.to_sym=>self}
+      {builder_local_variable_name=>self}
     end
 
     # Set or get builder for class.
@@ -29,9 +32,11 @@ module Lolita
     # * <tt>String or Symbol (one arg)</tt> - is used as _name_.
     # Default _name_ is Lolita::Configuration class name (example <code>:list</code>) and
     # default state is <code>:display</code>
-    def builder(*value)
+    def get_builder(*value)
       if value && !value.empty?
-        set_builder(*value)
+        set_builder(value)
+      elsif @builder
+        set_builder(@builder)
       else
         unless @builder
           @builder=default_builder
@@ -42,28 +47,40 @@ module Lolita
 
     # Return default builder information.
     def default_builder
-      {:name=>"lolita/#{builder_name}",:state=>default_build_state}
+      {:name=>"/#{builder_name}".to_sym,:state=>default_build_state}
     end
     
     private
 
-    def set_builder *value
-      if value[0].is_a?(Hash)
-        @builder=value[0]
-      elsif value.size>1
-        @builder={:name=>value[0],:state=>value[1]}
+    def set_builder value
+      if value.is_a?(Hash)
+        @builder=value
+      elsif value.is_a?(Array)
+        @builder={:name=>fix_name(value[0]),:state=>value[1] || default_build_state}
       else
-        @builder={:name=>value[0],:state=>default_build_state}
+        @builder={:name=>fix_name(value),:state=>default_build_state}
       end
     end
     
+    def fix_name value
+      name=if value.to_s[0] == '/'
+        value
+      else
+        "/#{builder_name}/#{value}"
+      end
+      name.gsub(/\/$/,"")
+    end
+
     def default_build_state
       :display
     end
     
     def builder_name
-      self.class.to_s.split("::").last.downcase.to_sym
+      self.class.to_s.split("::").map(&:underscore).join("/").to_sym
     end
     
+    def builder_local_variable_name 
+      self.class.to_s.split("::").last.underscore.to_sym
+    end
   end
 end

data/lib/lolita/configuration/column.rb

@@ -1,86 +1,92 @@
-module Lolita
-  module Configuration
-    class Column 
-
-      MAX_TEXT_SIZE=20
-      DEFAULT_DATE_FORMAT="%Y-%m-%d"
-      DEFAULT_TIME_FORMAT="%H:%M:%S"
-      lolita_accessor :name,:title,:type,:options,:format
-      
-      def initialize(*args,&block)
-        self.set_attributes(*args)
-        self.instance_eval(&block) if block_given?
-        validate
-        set_default_values
-      end
-      
-      #
-      #  column do
-      #    name "UID"
-      #    format do(values)
-      #      values.first+values.last
-      #    end
-      #  end
-      # <%= column.with_format([@post.id,@post.user_id])%>
-      def with_format(value) #TODO test
-        if @format
-          @format.call(value)
-        else
-          format_from_type(value)
-        end
-      end
-
-      def format_from_type(value) #TODO test
-        if value
-          case self.type.to_s.downcase
-          when "string"
-            value
-          when "integer"
-            value
-          when "text"
-            new_value=value.to_s.gsub(/<\/?[^>]*>/, "").strip
-            if new_value.size>MAX_TEXT_SIZE
-              "#{new_value.slice(0..MAX_TEXT_SIZE)}..."
-            else
-              new_value
-            end
-          when "datetime"
-            value.strftime("#{DEFAULT_DATE_FORMAT} #{DEFAULT_TIME_FORMAT}")
-          when "date"
-            value.strftime(DEFAULT_DATE_FORMAT)
-          when "time"
-            value.strftime(DEFAULT_TIME_FORMAT)
-          else
-            value.to_s
-          end
-        else
-          ""
-        end
-      end
-      
-      def set_attributes(*args)
-        if !args.empty?
-          if args[0].is_a?(Hash)
-            args[0].each{|m,value|
-              self.send("#{m}=".to_sym,value)
-            }
-          elsif args[0].is_a?(Symbol) || args[0].is_a?(String)
-            self.name=args[0].to_s
-          else
-            raise ArgumentError.new("Lolita::Configuration::Column arguments must be Hash or Symbol or String instead of #{args[0].class}")
-          end
-        end
-      end
-      
-      private
-      
-      def set_default_values
-        @title||=@name.to_s.humanize
-      end
-      
-      def validate
-        raise ArgumentError.new("Column must have name.") unless self.name
-      end
-    end
-  end
-end
+module Lolita
+  module Configuration
+    class Column 
+
+      MAX_TEXT_SIZE=20
+      lolita_accessor :name,:title,:type,:options,:format
+      
+      def initialize(*args,&block)
+        self.set_attributes(*args)
+        self.instance_eval(&block) if block_given?
+        validate
+        set_default_values
+      end
+      
+      #
+      #  column do
+      #    name "UID"
+      #    format do(values)
+      #      values.first+values.last
+      #    end
+      #  end
+      # <%= column.with_format([@post.id,@post.user_id])%>
+      def with_format(value) #TODO test
+        if @format.respond_to?(:call)
+          @format.call(value)
+        elsif @format && (value.is_a?(Time) || value.is_a?(Date))
+          format_for_datetime(value)
+        else
+          format_from_type(value)
+        end
+      end
+
+      def format_from_type(value) #TODO test
+        if value
+          if value.is_a?(String)
+            value
+          elsif value.is_a?(Integer)
+            value
+          elsif value.is_a?(Date)
+            if defined?(I18n)
+              I18n.localize(value, :format => :long)
+            else
+              value.to_s
+            end
+          elsif value.is_a?(Time)
+            if defined?(I18n)
+              I18n.localize(value, :format => :long)
+            else
+              value.to_s
+            end
+          else
+            value.to_s
+          end
+        else
+          ""
+        end
+      end
+      
+      def set_attributes(*args)
+        if !args.empty?
+          if args[0].is_a?(Hash)
+            args[0].each{|m,value|
+              self.send("#{m}=".to_sym,value)
+            }
+          elsif args[0].is_a?(Symbol) || args[0].is_a?(String)
+            self.name=args[0].to_s
+          else
+            raise ArgumentError.new("Lolita::Configuration::Column arguments must be Hash or Symbol or String instead of #{args[0].class}")
+          end
+        end
+      end
+      
+      private
+      
+      def set_default_values
+        @title||=@name.to_s.humanize
+      end
+      
+      def format_for_datetime value
+        if defined?(I18n)
+          I18n.localize(value, :format => @format)
+        else
+          value.to_s
+        end
+      end
+
+      def validate
+        raise ArgumentError.new("Column must have name.") unless self.name
+      end
+    end
+  end
+end

data/lib/lolita/configuration/columns.rb

@@ -1,65 +1,65 @@
-module Lolita
-  module Configuration
-    class Columns
-
-      include Enumerable
-      include ObservedArray
-      
-      attr_accessor :list
-      attr_reader :dbi
-      
-      def initialize(list,dbi=nil)
-        @list=list
-        @dbi=dbi || list.dbi
-        @columns=[]
-      end
-      
-      def each
-        @columns.each_with_index{|column,index|
-          if column.is_a?(Lolita::Configuration::Column)
-            yield column
-          else
-            raise "Any column must be Lolita::Configuratin::Column object instead of #{column.class}."
-          end
-        }
-      end
-
-      def generate!
-        @columns.clear
-        @dbi.fields.each_with_index{|field,index|
-          @columns[index]=Lolita::Configuration::Column.new(field)
-        }
-      end
-
-      def add attributes={},&block
-        if block_given?
-          @columns<<build_element(&block)
-        else
-          @columns<<build_element(attributes)
-        end
-        self
-      end
-
-      private
-
-      def collection_variable
-        @columns
-      end
-      
-      def build_element(column=nil,&block)
-        if column.is_a?(Lolita::Configuration::Column)
-          column
-        elsif column.is_a?(Proc)
-          Lolita::Configuration::Column.new(&column)
-        elsif block_given?
-          Lolita::Configuration::Column.new(&block)
-        elsif [Symbol,String,Hash].include?(column.class)
-          Lolita::Configuration::Column.new(column)
-        else
-          raise ArgumentError.new("Column can not be defined with #{column.class}.")
-        end
-      end
-
-    end
-  end
-end
+module Lolita
+  module Configuration
+    class Columns
+
+      include Enumerable
+      include ObservedArray
+      
+      attr_accessor :list
+      attr_reader :dbi
+      
+      def initialize(list,dbi=nil)
+        @list=list
+        @dbi=dbi || list.dbi
+        @columns=[]
+      end
+      
+      def each
+        @columns.each_with_index{|column,index|
+          if column.is_a?(Lolita::Configuration::Column)
+            yield column
+          else
+            raise "Any column must be Lolita::Configuratin::Column object instead of #{column.class}."
+          end
+        }
+      end
+
+      def generate!
+        @columns.clear
+        @dbi.fields.each_with_index{|field,index|
+          @columns[index]=Lolita::Configuration::Column.new(field)
+        }
+      end
+
+      def add attributes={},&block
+        if block_given?
+          @columns<<build_element(&block)
+        else
+          @columns<<build_element(attributes)
+        end
+        self
+      end
+
+      private
+
+      def collection_variable
+        @columns
+      end
+      
+      def build_element(column=nil,&block)
+        if column.is_a?(Lolita::Configuration::Column)
+          column
+        elsif column.is_a?(Proc)
+          Lolita::Configuration::Column.new(&column)
+        elsif block_given?
+          Lolita::Configuration::Column.new(&block)
+        elsif [Symbol,String,Hash].include?(column.class)
+          Lolita::Configuration::Column.new(column)
+        else
+          raise ArgumentError.new("Column can not be defined with #{column.class}.")
+        end
+      end
+
+    end
+  end
+end