lolita 3.2.0.rc.6 → 3.2.0.rc.7

data/app/assets/stylesheets/lolita/style.css.erb

@@ -1,6 +1,7 @@
 html,body{
   height: 100%;
 }
+*:focus {outline: none;}
 body {background: #f3f3f3; font-size: 13px;}
 
 a, a:visited, a:active {color: #7ac1ed; text-decoration: none;}
@@ -57,6 +58,7 @@ header nav .username {margin-right: 15px;}
 #main .box form input {background: #FFF;}
 #main .box form label {color: #c3c3c3; font-size: 13px;}
 #main .box form select {min-width: 150px;}
+#main .box form .date_time select {min-width: 50px;}
 #main .box form .field {margin: 10px 0; overflow: hidden;}
 #main .box form .field:first-child input {
   font-size: 24px;
@@ -98,6 +100,10 @@ header nav .username {margin-right: 15px;}
   padding-bottom: 5px;
   border-bottom: 1px dashed #DDD;
 }
+#main .box form .nested_form.simple .nested-form-fields-container{
+  max-height: 100px;
+  overflow: auto;
+}
 #main .box form .nested_form p {margin-left: 50px;}
 #main .box form .nested_form input {
   border: 1px solid #cdcdcd;
@@ -123,6 +129,10 @@ header nav .username {margin-right: 15px;}
 	margin: 5px 0;
 	padding-bottom: 5px;
 	border-bottom: 1px dashed #DDD;
+  overflow: hidden;
+}
+.autocomplete-container ul li a {
+  float: right;
 }
 .ui-menu .ui-menu-item a {
 	font-size: 10px;

data/app/controllers/lolita/field_data_controller.rb

@@ -19,14 +19,18 @@ class Lolita::FieldDataController < ApplicationController
   end
 
 	def autocomplete_field
-		model = params[:class].singularize.camelize.constantize
-		column = model.lolita.tabs.first.fields.first.name.to_sym
-		data = model.where(model.arel_table[column].matches("%#{params[:term]}%")).map do |record| 
-			{:id => record.id, 
-			 :value => record.send(column), 
-			 :name => "#{params[:field_class].downcase}[#{params[:class].singularize}_ids][]",
-			 :delete_link => I18n.t("lolita.shared.delete")}
-		end
-		render :json => data
+    klass = params[:field_class].camelize.constantize
+    field = klass.lolita.tabs.fields.detect{|field| field.name.to_s == params[:field_name]}
+    data = if field
+      (field.search || field.create_search(true)).run(params[:term],request).map do |record|
+        {
+          :id => record.id,
+          :value => record.send(field.current_text_method(field.association.klass)),
+          :name => "#{params[:field_class].downcase}[#{params[:field_name].singularize}_ids][]",
+          :delete_link => I18n.t("lolita.shared.delete").to_s.downcase
+        }
+      end
+    end
+    render :json => data || {}
 	end
 end

data/app/controllers/lolita/info_controller.rb

@@ -1,9 +1,16 @@
 class Lolita::InfoController < ApplicationController
   @@properties = []
+  include Lolita::Controllers::UserHelpers
+  include Lolita::Controllers::AuthorizationHelpers
+  before_filter :authenticate_lolita_user!, :only => [:index]
 
   def index
     if Lolita.mappings.any?
-      return redirect_to(lolita_resources_path(Lolita.mappings.values.first))
+      available_mapping = Lolita.mappings.detect{|name,mapping|
+        can?(:read,mapping.to)
+      }
+      available_mapping &&= available_mapping.last
+      return redirect_to(lolita_resources_path(available_mapping)) if available_mapping
     end
     render :layout => false
   end
@@ -16,6 +23,10 @@ class Lolita::InfoController < ApplicationController
     end
   end
 
+  def is_lolita_resource?
+    true
+  end
+
   private
 
   def self.property(name, value = nil)

data/app/views/components/lolita/configuration/column/_header.html.erb

@@ -1,4 +1,4 @@
-<th <%=column.currently_sorting?(params) ? "class='active'" : ""%> >
+<th >
   <% if column.sortable? %>
     <%= render_component column, :sort %>
   <% else %>

data/app/views/components/lolita/configuration/column/_sort.html.erb

@@ -1,4 +1,7 @@
- <% param_options=params.reject{|k,v| [:controller,:action].include?(k)} %>
- <% options=param_options.merge(column.sort_options(params)) %>
- <% direction_indicator=column.currently_sorting?(params) && options[:sd].to_s=="desc" ? raw('&uArr;') : raw('&dArr;') %>
- <%= link_to raw("#{column.title.to_s.capitalize } #{direction_indicator}"), lolita_resources_path(options) %>
+<% 
+  sort_mapping = {"desc" => '&dArr;', "asc" => '&uArr;'}
+  new_params = params.reject{|k,v| ["controller","action"].include?(k.to_s)}
+  direction_indicator = raw(sort_mapping[column.current_sort_state(new_params)[1]])
+  new_params[:s] = column.sort_params(new_params)
+%>
+<%= link_to raw("#{column.title.to_s.capitalize} #{direction_indicator}"), lolita_resources_path(new_params) %>

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

@@ -1,11 +1,13 @@
-<div class="field <%= field.type %>" id="field_<%=field.__id__%>">
-  <% unless field.type == "hidden" %>
-    <%= render_component *field.build(:name=>"/lolita/configuration/field", :state => :"label") %>
-  <% end %>
-  <div class="field-value" id="field_<%=field.__id__%>_value">
-    <%= render_component *field.build %>
+<% if field.match_state_of?(resource) %>
+  <div class="field <%= field.type %>" id="field_<%=field.__id__%>">
+    <% unless field.type == "hidden" %>
+      <%= render_component *field.build(:name=>"/lolita/configuration/field", :state => :"label") %>
+    <% end %>
+    <div class="field-value" id="field_<%=field.__id__%>_value">
+      <%= render_component *field.build %>
+    </div>
+    <% unless resource.errors[field.name.to_s.gsub(/_id$/,"").to_sym].empty? %>
+      <p class="inline-errors"><%= raw resource.errors[field.name.to_s.gsub(/_id$/,"").to_sym].join("<br>") %></p>
+    <% end %>
   </div>
-  <% unless resource.errors[field.name.to_s.gsub(/_id$/,"").to_sym].empty? %>
-    <p class="inline-errors"><%= raw resource.errors[field.name.to_s.gsub(/_id$/,"").to_sym].join("<br>") %></p>
-  <% end %>
-</div>
+<% end %>

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

@@ -1,5 +1,5 @@
 <% if field.association && field.association.macro == :one %>
   <%= render_component :"lolita/configuration/field/array/select", :display, :field=>field %>
 <% else %>
-  <%= render_component :"lolita/configuration/field/array/habtm", :display, :field=>field %>
+  <%= render_component :"lolita/configuration/field/array/autocomplete", :display, :field=>field %>
 <% end %>

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

@@ -0,0 +1,14 @@
+.autocomplete-container
+  - if field.association.macro == :one
+    = tab_form.hidden_field field.association.key
+    = render_component *field.build(:state => "input", :with_value => true)
+  - else
+    - ids_method = field.name.to_s.match(/_ids$/) ? field.name : "#{field.name.to_s.singularize}_ids"
+    = hidden_field_tag "#{resource_name}[#{ids_method}][]",""
+    = render_component *field.build(:state => "input")
+    %ul
+      - resource.persisted? && resource.send(field.name).each do |record|
+        %li
+          = record.send(field.current_text_method(field.association.klass))
+          = link_to I18n.t("lolita.shared.delete").downcase, nil
+          = hidden_field_tag "#{resource_name}[#{ids_method}][]", record.id

data/app/views/components/lolita/configuration/field/array/autocomplete/_input.html.haml

@@ -0,0 +1,19 @@
+- # Set variables, f_cached - recod has methods that keeps cached names, f_name - field name or some other name, if there is no 
+- # need to store autocomplete field information, f_url - request url for search, f_value - value for autocomplete input,
+- # f_options - html options for input are used in js.
+
+- f_cached = field.dbi.klass.respond_to?(:"cached_#{field.name}")
+- f_name = f_cached ? "cached_#{field.name}" : "autocomplete-#{resource_name}-#{field.name}"
+- f_url = autocomplete_field_path(:field_class => resource_class.to_s, :field_name => field.name)
+
+- f_value = if local_assigns[:with_value]
+  - tab_form.object.send(field.association.name) && tab_form.object.send(field.association.name).send(field.current_text_method(field.association.klass))
+- else
+  - nil
+
+- f_options = {:"data-autocomplete-url" => f_url, :"data-macro" => field.association.macro, :"data-cached" => f_cached ? "yes" : "no"}
+
+- if f_cached
+  = tab_form.text_field f_name, f_options
+- else
+  = text_field_tag f_name, f_value, f_options

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

@@ -1,4 +1,6 @@
-<a href="<%= new_lolita_resource_path%>" class="create">
-  <%= ::I18n.t("lolita.list.add_new",:name=>resource_class.model_name.human.downcase) %>
-  <%= image_tag "lolita/plus.png", :alt=>"+" %>
-</a>
+<% if can?(:create,resource_class)
+  <a href="<%= new_lolita_resource_path%>" class="create">
+    <%= ::I18n.t("lolita.list.add_new",:name=>resource_class.model_name.human.downcase) %>
+    <%= image_tag "lolita/plus.png", :alt=>"+" %>
+  </a>
+<% end %>

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

@@ -1,12 +1,14 @@
-<div class="nested_form" id=<%= "nested_form_#{nested_form.__id__}" %>>
+<div class="nested_form <%=nested_form.field_style%>" id=<%= "nested_form_#{nested_form.__id__}" %>>
   <% unless nested_form.field_style == :normal %>
     <%= render_component *nested_form.as_field.build(:name=>"/lolita/configuration/field", :state => :"label") %>
   <% end %>
-	<%= 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 %>
+  <div class="nested-form-fields-container">
+  	<%= 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 %>
+  </div>
   <% 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 %>

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

@@ -3,12 +3,18 @@
     <%= 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
+        if tab.fields.by_name(attr_name.to_sym)
+          klass = resource.lolita.dbi.reflect_on_association(assoc_name.to_sym).klass
+          klass.human_attribute_name(attr_name).downcase
+        end
       else
-        resource.class.human_attribute_name(k)
+        if tab.fields.by_name(k.to_sym)
+          resource.class.human_attribute_name(k)
+        end
+      end
+      if title && resource.errors[k] && resource.errors[k].respond_to?(:any?) && resource.errors[k].any?
+        "#{title.to_s.capitalize}: #{resource.errors[k].join(" #{::I18n.t("lolita.shared.and")} ")}"
       end
-      "#{title.to_s.capitalize}: #{resource.errors[k].join(" #{::I18n.t("lolita.shared.and")} ")}"
     }.compact.join("<br>") %>
   </p>
 <% end %>

data/app/views/components/lolita/navigation/_tree.html.erb

@@ -11,7 +11,9 @@
     end
   end
 end %>
+
 <% visible ||= (tree.root? || nil) %>
+
 <% if tree.visible?(self) %>
   <ul <%= !tree.root? ? "class='subtree'" : ""%> style="display:<%=visible ? "block" : "none"%>" >
     <% last_branch=tree.branches.last %>

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

@@ -4,11 +4,6 @@
       <h1><%= t "lolita.tabs.save" %></h1>
       <div class="arrow"></div>
     </div>
-    <div class="save black">
-      <div class="last-save">
-        <%= resource.updated_at.strftime("#{t("lolita.tabs.last_save")}: %m/%d/%Y %H:%M ") if resource.respond_to?(:updated_at) && resource.updated_at %>
-      </div>
-      <button class="save-all"><%=::I18n.t("lolita.tabs.save")%></button>
-    </div>
+    <%= render_component "lolita/shared", :save_button%>
   </div>
 </div>

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

@@ -0,0 +1,6 @@
+ <div class="save black">
+  <div class="last-save">
+    <%= resource.updated_at.strftime("#{t("lolita.tabs.last_save")}: %m/%d/%Y %H:%M ") if resource.respond_to?(:updated_at) && resource.updated_at %>
+  </div>
+  <button class="save-all"><%=::I18n.t("lolita.tabs.save")%></button>
+</div>

data/config/routes.rb

@@ -2,5 +2,5 @@ Rails.application.routes.draw do
    match '/lolita' => "lolita/info#index"
    match '/lolita/info/properties' => "lolita/info#properties"
    match "/lolita/array_field/:name/:field_class/:class/:id" => "lolita/field_data#array_polymorphic", :as => "array_field_data_collector"
-	 match "/lolita/autocomplete_field/:field_class/:class" => "lolita/field_data#autocomplete_field", :as => "autocomplete_field"
+	 match "/lolita/autocomplete_field/:field_class/:field_name" => "lolita/field_data#autocomplete_field", :as => "autocomplete_field"
 end

data/lib/lolita.rb

@@ -60,6 +60,7 @@ module Lolita
  
   # Keep all configuration classes and modules, that is used to configure classes with lolita.
   module Configuration
+
     autoload :Base, 'lolita/configuration/base'
     autoload :Column, 'lolita/configuration/column'
     autoload :Columns, 'lolita/configuration/columns'
@@ -98,6 +99,9 @@ module Lolita
     
     def self.included(base)
       base.class_eval do
+        include Lolita::Hooks
+        add_hook :after_lolita_loaded
+
         extend ClassMethods
         def lolita
           self.class.lolita
@@ -109,6 +113,7 @@ module Lolita
       def lolita(&block)
         Lolita::LazyLoader.lazy_load(self,:@lolita,Lolita::Configuration::Base,self,&block)
       end
+      
       def lolita=(value)
         if value.is_a?(Lolita::Configuration::Base)
           @lolita=value

data/lib/lolita/adapter/active_record.rb

@@ -202,21 +202,25 @@ module Lolita
 
       def search(query, options = {})
         #TODO raise error or warn when there are lot of records and no index on field
-        resources = self.klass.arel_table
-        content_fields = @dbi.fields.map{|field| field.type!="string" ? nil : field.name.to_sym}.compact
-        if options[:fields] && options[:fields].any?
-          content_fields = content_fields & options[:fields]
-        end
-        scope = nil
-        content_fields.each_with_index do |field,index|
-          new_scope = resources[field].matches("%#{query}%")
-          unless index == 0
-            scope = scope.or(new_scope)
-          else
-            scope = new_scope
+        unless query.blank?
+          resources = self.klass.arel_table
+          content_fields = @dbi.fields.map{|field| field.type!="string" ? nil : field.name.to_sym}.compact
+          if options[:fields] && options[:fields].any?
+            content_fields = content_fields & options[:fields]
           end
+          scope = nil
+          content_fields.each_with_index do |field,index|
+            new_scope = resources[field].matches("%#{query}%")
+            unless index == 0
+              scope = scope.or(new_scope)
+            else
+              scope = new_scope
+            end
+          end
+          self.klass.where(scope)
+        else
+          self.klass.where(nil)
         end
-        self.klass.where(scope)
       end
 
       def db

data/lib/lolita/adapter/mongoid.rb

@@ -185,25 +185,29 @@ module Lolita
       end
 
       def search(query, options = {})
-        content_fields = @dbi.fields.map{|field| 
-          if field.type!="string" || field.name.match(/^_/)
-            nil
-          else
-            field.name.to_sym
+        unless query.blank?
+          content_fields = @dbi.fields.map{|field| 
+            if field.type!="string" || field.name.match(/^_/)
+              nil
+            else
+              field.name.to_sym
+            end
+          }.compact
+          if options[:fields] && options[:fields].any?
+            content_fields = content_fields & options[:fields]
           end
-        }.compact
-        if options[:fields] && options[:fields].any?
-          content_fields = content_fields & options[:fields]
-        end
-        content_fields = content_fields.slice(0..3)
-        #result = self.map_reduce_search(content_fields,query)
-        #debugger
-        #result
-        where_hash = {}
-        content_fields.each do |field|
-          where_hash[field] = /#{Regexp.escape(query.to_s)}/
+          content_fields = content_fields.slice(0..3)
+          #result = self.map_reduce_search(content_fields,query)
+          #debugger
+          #result
+          where_hash = {}
+          content_fields.each do |field|
+            where_hash[field] = /#{Regexp.escape(query.to_s)}/
+          end
+          klass.where(where_hash)
+        else
+          klass.where(nil)
         end
-        klass.where(where_hash)
       end
 
       #FIXME

data/lib/lolita/configuration/base.rb

@@ -15,9 +15,11 @@ module Lolita
 
       attr_reader :dbi,:klass
       @@generators=[:tabs,:list]
+
       class << self
+
         def add_generator(method)
-          @@generators<<method.to_sym
+          @@generators<<method.to_sym 
         end
       end
       # When configuration is defined in class than you don't need to worry about
@@ -38,6 +40,7 @@ module Lolita
       #     Person.lolita=Lolita::Configuration::Base.new(Person)
       #     Person.lolita.klass #=> Person
       def initialize(orm_class,&block)
+        @in_callback_mode = false
         @klass=orm_class
         @dbi=Lolita::DBI::Base.create(orm_class)
         block_given? ? self.instance_eval(&block) : self.generate!
@@ -50,6 +53,10 @@ module Lolita
         Lolita::LazyLoader.lazy_load(self,:@list,Lolita::Configuration::List,@dbi,&block)
       end
 
+      def list=(new_list)
+        @list = new_list if new_list.is_a?(Lolita::Configuration::List)
+      end
+
       # Create collection of Lolita::Configuration::Tab, loading lazy.
       # See Lolita::Configuration::Tabs for details.
       def tabs &block
@@ -69,7 +76,13 @@ module Lolita
           self.send(generator)
         }
       end
-      
+
+      private
+
+      def after_initialize
+        @dbi.klass.run(:after_lolita_loaded, :once => self)
+      end
+
     end
   end
 end