lolita 3.1.16 → 3.1.17

data/Gemfile

@@ -5,10 +5,11 @@ gem "rails", "~>3.0.10"
 gem "kaminari", "~>0.12.4"
 gem "abstract"
 gem "builder", "~> 2.1.2" #cucumber asks for builder 3 but rails supports 2.1
+gem "haml", "~> 3.1.2"
 
 group :mongoid do
 	gem "mongo", "~> 1.3.0"
-	gem "mongoid", "~> 2.0.0"
+	gem "mongoid", "~> 2.1.7"
 	gem "bson_ext", "~> 1.3.0"
 end
 

data/History.rdoc

@@ -1,3 +1,13 @@
+=== Version 3.1.17 / 2011-09-01
+* Bug fixes
+  * Error explanation updated with nested errors
+
+* Enhancements
+  * Array field have special method for values
+  * HAML support added
+  * look improved 
+  * project configuration added
+  
 === Version 3.1.16 / 2011-08-30
 * Bug fixes
   * Component helper name detection fixed

data/VERSION

@@ -1 +1 @@
-3.1.16
+3.1.17

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

@@ -1,4 +1,4 @@
-<div class="field" id="field_<%=field.__id__%>">
+<div class="field <%= field.type %>" id="field_<%=field.__id__%>">
   <% unless field.type == "hidden" %>
     <%= render_component *field.build(:name=>"/lolita/configuration/field", :state => :"label") %>
   <% end %>

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

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

data/app/views/components/lolita/configuration/field/array/habtm/_display.html.haml

@@ -1,5 +1,5 @@
 = hidden_field_tag "#{resource_name}[#{field.name.to_s.singularize}_ids][]",""
-- field.association_values.call.each do |value|
+- field.view_values(self).each do |value|
   - editors = resource.send(:"#{field.name.to_s.singularize}_ids")
   .habtm-container
     = label_tag "#{resource_name}_#{field.name}_#{value.last}",value.first, :class => "habtm-label"

data/app/views/components/lolita/configuration/field/array/select/_display.html.erb

@@ -1,4 +1,4 @@
 <%= tab_form.select field.name,
-            (field.association_values.respond_to?(:call) ? field.association_values.call(self) : field.association_values),
+            (field.view_values(self)),
             {:include_blank => field.include_blank},
             field.html_options || {} %>

data/app/views/components/lolita/configuration/list/_paginator.html.erb

@@ -1 +1 @@
-<%= paginate(page) %>
+<%= paginate page, :theme => "lolita" %>

data/app/views/components/lolita/configuration/nested_form/_display.html.erb

@@ -1,13 +1,13 @@
 <div class="nested_form" id=<%= "nested_form_#{nested_form.__id__}" %>>
   <% unless nested_form.field_style == :normal %>
-	 <%= label_tag nested_form.name %>
+    <%= render_component *nested_form.as_field.build(:name=>"/lolita/configuration/field", :state => :"label") %>
   <% end %>
-	<%= tab_form.fields_for nested_form.name do |form| %>
+	<%= tab_form.fields_for nested_form.name, resource.send(nested_form.build_method) do |form| %>
 		<% tab_form(form) do %>
 				<%= render_component nested_form, :fields %>
 		<% end %>
 	<% end %>
-  <% if nested_form.expandable? %>
+  <% if nested_form.expandable? && !nested_form.update_only? %>
 	 <p><%= link_to_add_fields ::I18n.t("lolita.nested_form.add", :resource_name => nested_form.klass.model_name.human.downcase), tab_form, nested_form %> </p>
   <% end %>
 </div>

data/app/views/components/lolita/configuration/nested_form/_fields.html.erb

@@ -6,7 +6,7 @@
       <%= render_component field %>
     <% end %>
   <% end %>
-  <% if nested_form.expandable? %>
+  <% if nested_form.expandable? && nested_form.allow_destroy? %>
     <%= link_to_remove_fields I18n.t("lolita.shared.delete").downcase, tab_form %>
   <% end %>
 </div>

data/app/views/components/lolita/configuration/tab/_display.html.erb

@@ -1,17 +1,8 @@
-<div class="tab box" id="tab_<%=tab.__id__%>">
-  <div class="tab-title boxtitle black" data-closed="false">
+<div class="tab box <%=resource.lolita.tabs.first == tab ? "first-tab" : "default minimized"%>" id="tab_<%=tab.__id__%>">
+	<div class="tab-title boxtitle <%= resource.lolita.tabs.first == tab ? "black" : "grey"%>" >
     <h1><%= tab.title %></h1>
-    <div class="arrow"></div> <%# FIXME more DRY solution is needed for .arrow within .boxtitle, maybe box helper %>
+    <div class="arrow"></div>
   </div>
-  <% if resource.errors.any? %>
-    <p class="errorExplanation" id="errorExplanation">
-      <%= raw resource.errors.keys.collect{|k|
-        if error_tab = tab.fields.by_name(k)
-          "#{error_tab.title.humanize.capitalize}: "+
-            "#{resource.errors[k].collect{|m| m.capitalize}.join(" and ")}"
-        end
-      }.compact.join("<br>") %>
-    </p>
-  <% end %>
+  <%= render_component "lolita/configuration/tab", :error_msg, :tab => tab %>
   <%= render_component "lolita/configuration/tab", :form, :tab => tab %>
 </div>

data/app/views/components/lolita/configuration/tab/_error_msg.html.erb

@@ -0,0 +1,14 @@
+<% if resource.errors.any? %>
+  <p class="errorExplanation" id="errorExplanation">
+    <%= raw resource.errors.keys.collect{|k|
+      title = if k.to_s.match(/\./)
+        assoc_name, attr_name = k.to_s.split(".")
+        klass = resource.lolita.dbi.reflect_on_association(assoc_name.to_sym).klass
+        klass.human_attribute_name(attr_name).downcase
+      else
+        resource.class.human_attribute_name(k)
+      end
+      "#{title.to_s.capitalize}: #{resource.errors[k].join(" #{::I18n.t("lolita.shared.and")} ")}"
+    }.compact.join("<br>") %>
+  </p>
+<% end %>

data/app/views/components/lolita/configuration/tab/_form.html.erb

@@ -1,7 +1,7 @@
 <%
   #This partial is useful for hooks. You don't need to hook in each tab, but you can hook here, that is common to all tabs
 %>
-<%= form_for resource, :url => "#",:html => {:multipart=>true, :id=>"tab-form-#{tab.__id__}",:method => resource.new_record? ? :post : :put} do |form| %>
+<%= form_for resource, :url => "#",:html => {:onsubmit => "return false;",:multipart=>true, :id=>"tab-form-#{tab.__id__}",:method => resource.new_record? ? :post : :put} do |form| %>
   <% self.tab_form = form %>
   <%= render_component *tab.build %>
 <% end %>

data/app/views/components/lolita/shared/_header.html.erb

@@ -1,5 +1,5 @@
 <header>
-  <h1>Lolita</h1>
+  <h1><%=Lolita.application.name %></h1>
   <% if lolita_current_user %>
 	  <nav>
 	    <a href="<%=send(:"edit_#{lolita_current_user.class.to_s.downcase}_password_path")%>" class="username"><%=lolita_current_user.email%></a>

data/app/views/kaminari/lolita/_first_page.html.erb

@@ -0,0 +1,11 @@
+<%# Link to the "First" page
+  - available local variables
+    url:           url to the first page
+    current_page:  a page object for the currently displayed page
+    num_pages:     total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="first">
+  <%= link_to_unless current_page.first?, raw(t 'views.pagination.first'), url, :remote => remote %>
+</span>

data/app/views/kaminari/lolita/_gap.html.erb

@@ -0,0 +1,8 @@
+<%# Non-link tag that stands for skipped pages...
+  - available local variables
+    current_page:  a page object for the currently displayed page
+    num_pages:     total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="page gap"><%= raw(t 'views.pagination.truncate') %></span>

data/app/views/kaminari/lolita/_last_page.html.erb

@@ -0,0 +1,11 @@
+<%# Link to the "Last" page
+  - available local variables
+    url:           url to the last page
+    current_page:  a page object for the currently displayed page
+    num_pages:     total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="last">
+  <%= link_to_unless current_page.last?, raw(t 'views.pagination.last'), url, {:remote => remote} %>
+</span>

data/app/views/kaminari/lolita/_next_page.html.erb

@@ -0,0 +1,11 @@
+<%# Link to the "Next" page
+  - available local variables
+    url:           url to the next page
+    current_page:  a page object for the currently displayed page
+    num_pages:     total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="next">
+  <%= link_to_unless current_page.last?, raw(t 'views.pagination.next'), url, :rel => 'next', :remote => remote %>
+</span>

data/app/views/kaminari/lolita/_page.html.erb

@@ -0,0 +1,12 @@
+<%# Link showing page number
+  - available local variables
+    page:          a page object for "this" page
+    url:           url to this page
+    current_page:  a page object for the currently displayed page
+    num_pages:     total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="page<%= ' current' if page.current? %>">
+  <%= link_to_unless page.current?, page, url, opts = {:remote => remote, :rel => page.next? ? 'next' : page.prev? ? 'prev' : nil} %>
+</span>

data/app/views/kaminari/lolita/_paginator.html.erb

@@ -0,0 +1,23 @@
+<%# The container tag
+  - available local variables
+    current_page:  a page object for the currently displayed page
+    num_pages:     total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+    paginator:     the paginator that renders the pagination tags inside
+-%>
+<%= paginator.render do -%>
+  <nav class="pagination">
+    <%= first_page_tag unless current_page.first? %>
+    <%= prev_page_tag unless current_page.first? %>
+    <% each_page do |page| -%>
+      <% if page.left_outer? || page.right_outer? || page.inside_window? -%>
+        <%= page_tag page %>
+      <% elsif !page.was_truncated? -%>
+        <%= gap_tag %>
+      <% end -%>
+    <% end -%>
+    <%= next_page_tag unless current_page.last? %>
+    <%= last_page_tag unless current_page.last? %>
+  </nav>
+<% end -%>

data/app/views/kaminari/lolita/_prev_page.html.erb

@@ -0,0 +1,11 @@
+<%# Link to the "Previous" page
+  - available local variables
+    url:           url to the previous page
+    current_page:  a page object for the currently displayed page
+    num_pages:     total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote
+-%>
+<span class="prev">
+  <%= link_to_unless current_page.first?, raw(t 'views.pagination.previous'), url, :rel => 'prev', :remote => remote %>
+</span>

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

@@ -4,7 +4,7 @@
 <!--[if IE 7 ]>    <html class="no-js ie7" lang="en"> <![endif]-->
 <!--[if IE 8 ]>    <html class="no-js ie8" lang="en"> <![endif]-->
 <!--[if (gte IE 9)|!(IE)]><!-->
-<html class="no-js" lang="en">
+<html class="no-js" lang="en" style="height:100%">
   <!--<![endif]-->
   <head>
     <meta charset="utf-8"><meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1">
@@ -38,8 +38,10 @@
           <%= yield %>
         </div>
       </div>
-      <footer>
-      </footer>
+      <div class="push"></div>
     </div>
+    <footer> 
+      <div id="powered"><%= ::I18n.t("lolita.shared.powered", :year => Date.today.year)%></div>
+    </footer>
   </body>
 </html>

data/config/locales/en.yml

@@ -6,6 +6,8 @@ en:
       log_out: Log out
       edit: Edit
       delete: Delete
+      and: and
+      powered: Powered by Lolita (2010-%{year})
     nested_form:
       add: "Add %{resource_name}"
     tabs:

data/config/locales/lv.yml

@@ -6,6 +6,8 @@ lv:
       log_out: Atteikties
       edit: Labot
       delete: Dzēst
+      and: un
+      powered: Darbojas ar Lolita (2010-%{year})
     nested_form:
       add: "Pievienot %{resource_name}"
     tabs:
@@ -20,4 +22,11 @@ lv:
       confirm: "Vai esat pārliecināts, ka vēlaties dzēst ierakstu?"
     filter:
       apply_button: Pielietot
-      include_blank_by_title: " -- Filtrēt pēc %{title} -- "
+      include_blank_by_title: " -- Filtrēt pēc %{title} -- "
+  views:
+    pagination:
+      previous: "« Atpakaļ"
+      next: "Uz priekšu »"
+      last: "Beigas"
+      first: "Sākums"
+      truncate: "..."

data/lib/lolita/configuration/field/array.rb

@@ -47,6 +47,16 @@ module Lolita
           @association_values
         end
 
+        # used in views for shorter accessing to values
+        def view_values(view)
+          values = association_values
+          if values.respond_to?(:call)
+            values.call(view)
+          else
+            association_values
+          end
+        end
+
       private
 
       def set_association_type #TODO test

data/lib/lolita/configuration/helper.rb

@@ -15,7 +15,7 @@ module Lolita
             key_method = dbi.adapter_name == :active_record ? :association_foreign_key : :key
             !dbi.associations.values.detect{|assoc| assoc.send(key_method) == name}
           elsif dbi.klass.respond_to?(:uploaders)
-            dbi_klass.uploaders.keys.include?(name.to_sym)
+            dbi.klass.uploaders.keys.include?(name.to_sym)
           end
         end
       end

data/lib/lolita/configuration/nested_form.rb

@@ -19,31 +19,56 @@ module Lolita
       
       attr_reader :parent, :options, :field_style
       attr_accessor :name, :expandable, :field_rejection_proc
+      attr_writer :build_method
 
       def initialize parent,name=nil, options ={}
         @parent=parent
         @options = options
         self.name=name || "nested_form_#{next_nested_form}"
+        set_attributes_from(options)
       end
 
+      def allow_destroy?
+        dbi.klass.nested_attributes_options[name][:allow_destroy]
+      end
+
+      def update_only?
+        dbi.klass.nested_attributes_options[name][:update_only]
+      end
+
+      def build_method
+        @build_method || self.name
+      end
+      # Set field style - normal or simple. Default - normal.      
       def field_style=(value)
         allowed_values = [:normal,:simple]
         raise ArgumentError, "Only #{allowed_values.inspect} are allowed" unless allowed_values.include?(value)
         @field_style = value
       end
 
+      # Detect if it's possible to add more than one field group, like if model has many other objects.
       def expandable?
         @expandable == true || (@expandable == nil && macro == :many)
       end
 
+      # Create field, that is not real field, but represents nested attributes as one.
+      # It is used to create label.
+      def as_field
+        Lolita::Configuration::Field.add(dbi,self.name, :string)
+      end
+
+      # Parent (a.k.a tab) dbi
       def dbi
         @parent.dbi
       end
 
+      # Fields setter. Fields should be array and each element should be Lolita::Configuration::Field object.
       def fields=(new_fields)
         @fields = new_fields
       end
 
+      # Return all fields. Each time fields ar returned from @fields if its defined or calculated by using #field_rejection_proc
+      # or collected from parent (tab) where fields nested form is same with self.
       def fields
         if @fields
           @fields
@@ -54,10 +79,12 @@ module Lolita
         end
       end
 
+      # Parent (tab) dbi klass
       def klass
         dbi.reflect_on_association(name).klass
       end
 
+      # Parent (tab) dbi klass reflection with #name and macros of that.
       def macro
         dbi.association_macro(dbi.reflect_on_association(name))
       end
@@ -67,6 +94,12 @@ module Lolita
       def next_nested_form
         @@last_nested_form+=1
       end
+
+      def set_attributes_from(options)
+        options.each{|key,value|
+          instance_variable_set(:"@#{key}",value)
+        }
+      end
     end
   end
 end

data/lib/lolita/rails.rb

@@ -1,5 +1,5 @@
 require 'lolita/rails/routes'
-
+require 'haml'
 
 ActiveSupport.on_load(:action_controller) {
 	include Lolita::Controllers::ViewUserHelpers
@@ -16,5 +16,9 @@ module Lolita
 	class Engine < Rails::Engine
 		config.lolita=Lolita
 	  config.i18n.load_path += Dir[File.join(Lolita.root,'config', 'locales','default', '*.{yml}')]
+    config.before_initialize do
+      Haml.init_rails(binding)
+      Haml::Template.options[:format] = :html5
+    end	  
 	end
 end

data/lib/lolita/system_configuration/application.rb

@@ -0,0 +1,21 @@
+module Lolita
+  module SystemConfiguration
+    class Application
+
+      attr_writer :name
+
+      def name
+        @name || default_name
+      end
+
+      def default_name
+        if defined?(Rails)
+           Rails::Application.subclasses.first.to_s.split("::").first
+        else
+          "Lolita"
+        end
+      end
+
+    end
+  end
+end

data/lib/lolita/system_configuration/base.rb

@@ -0,0 +1,161 @@
+module Lolita
+  module SystemConfiguration
+    class Base
+      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 application &block
+        @application ||= Lolita::SystemConfiguration::Application.new
+        if block_given?
+          yield @application
+        end
+        @application
+      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
+
+    end
+  end
+end

data/lib/lolita.rb

@@ -42,7 +42,11 @@ module Lolita
   module Builder
     autoload(:Custom, 'lolita/builder')
   end
-  autoload(:BaseConfiguration,'lolita/base_configuration')
+
+  module SystemConfiguration
+    autoload :Base, 'lolita/system_configuration/base'
+    autoload :Application, 'lolita/system_configuration/application'
+  end
 
   module Adapter
     autoload :AbstractAdapter, 'lolita/adapter/abstract_adapter'
@@ -146,7 +150,7 @@ module Lolita
 
   def self.scope name=nil
     name||=scope_name
-    @@scopes[name]||=Lolita::BaseConfiguration.new(name)
+    @@scopes[name]||=Lolita::SystemConfiguration::Base.new(name)
     @@scopes[name]
   end