lolita 3.1.6 → 3.1.7

data/lib/lolita/builder.rb

@@ -7,79 +7,242 @@ module Lolita
   # * #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
-    lolita_accessor :builder
-
-    # Build response. Render component for current class with given options.
-    def build(*args)
-      args||=[]
-      options=args.extract_options!
-      builder_options=self.builder_options || {}
-      options=(options || {}).merge(builder_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_local_variable_name=>self}
-    end
+    class Custom
 
-    # Set or get builder for class.
-    # _Value_ can be
-    # * <tt>Hash</tt> where key <code>:name</code> is component name and <code>:state</code> is component state
-    # * <tt>Array or two args</tt> - first is used as _name_ and second as _state_.
-    # * <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 get_builder(*value)
-      if value && !value.empty?
-        builder_values_from(value)
-      elsif @builder
-        builder_values_from(@builder)
-      else
-        unless @builder
-          default_builder
+      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
-          @builder
+          raise ArgumentError, "Can't build with other builder, use build on that builder!"
         end
+        self
       end
-    end
 
-    # Return default builder information.
-    def default_builder
-      {:name=>"/#{builder_name}".to_sym,:state=>default_build_state}
-    end
-    
-    private
+      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 builder_values_from value
-      if value.is_a?(Hash)
-        value
-      elsif value.is_a?(Array)
-        {:name=>fix_name(value[0]),:state=>value[1] || default_build_state}
-      else
-        {:name=>fix_name(value),:state=>default_build_state}
+      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 fix_name value
-      name=if value.to_s[0] == '/'
-        value
+    def builder *args
+      if args && args.any?
+        set_builder(*args)
       else
-        "/#{builder_name}/#{value}"
+        @builder||=set_builder(nil)
+        @builder
       end
-      name.gsub(/\/$/,"")
     end
 
-    def default_build_state
-      :display
+    def builder=(*args)
+      set_builder(*args)
     end
-    
-    def builder_name
+
+    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

data/lib/lolita/configuration/filter.rb

@@ -101,7 +101,7 @@ module Lolita
 
       def html_option_for_select field
         {
-          :include_blank => I18n.t('lolita.filter.include_blank_by_title', :title => field.title)
+          :include_blank => ::I18n.t('lolita.filter.include_blank_by_title', :title => field.title)
         }
       end
     end

data/lib/lolita/configuration/tab.rb

@@ -158,8 +158,8 @@ module Lolita
         end
         
         def set_default_title
-          if defined?(I18n)
-            I18n.translate("lolita.tabs.titles.#{@type}")
+          if defined?(::I18n)
+            ::I18n.translate("lolita.tabs.titles.#{@type}")
           else
             @type.to_s.humanize
           end

data/lib/lolita/controllers/component_helpers.rb

@@ -28,7 +28,6 @@ module Lolita
       def render_component *args
         name,state,options=get_render_options(*args)
         format=options.delete(:format)
-
         raise "Can't render component without name!" unless name
         will_use_component name 
         component_name=File.join(name.to_s,state ? state.to_s : nil)
@@ -60,12 +59,12 @@ module Lolita
       end
 
       def output_with_callbacks(partial_name,name,locals)
-        output= Lolita::Hooks.component(name).run(:before,:run_scope=>self).to_s
-        block_output=Lolita::Hooks.component(name).run(:around, :run_scope=>self) do
-          render(:partial=>partial_name,:locals=>locals)
+        output = Lolita::Hooks.component(name).run(:before,:run_scope => self).to_s
+        block_output = Lolita::Hooks.component(name).run(:around, :run_scope => self) do
+          render(:partial => partial_name,:locals=>locals)
         end
         output << block_output.to_s
-        output << Lolita::Hooks.component(name).run(:after,:run_scope=>self).to_s
+        output << Lolita::Hooks.component(name).run(:after,:run_scope => self).to_s
         output
       end
 

data/lib/lolita/controllers/internal_helpers.rb

@@ -68,10 +68,9 @@ module Lolita
       def build_response_for(conf_part,options={})
         # FIXME when asked for some resources that always create new object, there may
         # not be any args, like lolita.report on something like that
-        
-        @component_options=options
-        @component_object=resource_class.lolita.send(conf_part.to_sym)
-        @component_builder=@component_object.build(@component_options)
+        @component_options = options
+        @component_object = resource_class.lolita.send(conf_part.to_sym)
+        @component_builder = @component_object.build(@component_options)
       end
       
 

data/lib/lolita/rails/routes.rb

@@ -12,6 +12,10 @@ module ActionDispatch::Routing
       end
       Lolita.run(:before_routes_loaded)
       draw_without_lolita *args,&block
+      draw_without_lolita *args, do
+          match '/lolita' => "lolita/info#index"
+          match '/lolita/info/properties' => "lolita/info#properties"
+      end
       Lolita.run(:after_routes_loaded)
     end
 
@@ -39,7 +43,7 @@ module ActionDispatch::Routing
     #     # lolita_for try to call :lolita_gallery in Mapper class
     def lolita_for *resources
   
-      return if migrating?
+      return if migrating? || generating_instalation?
       options = resources.extract_options!
 
       # if as = options.delete(:as)
@@ -91,7 +95,7 @@ module ActionDispatch::Routing
        
         tree=Lolita::Navigation::Tree[:"left_side_navigation"]
         unless tree.branches.detect{|b| b.object.is_a?(Lolita::Mapping) && b.object.to==mapping.to}
-          tree.append(mapping,:title=>mapping.to.human_name(:count=>2))
+          tree.append(mapping,:title=>mapping.to.model_name.human(:count=>2))
         end
       }
       Lolita.common_routes(all_resource_classes).each do |route_name|
@@ -123,7 +127,11 @@ module ActionDispatch::Routing
     private
 
     def migrating?
-      File.basename($0)=="rake" && (ARGV.include?("db:migrate"))
+      File.basename($0).match(/^rake/) && (ARGV.include?("db:migrate"))
+    end
+
+    def generating_instalation?
+      File.basename($0).match(/^rails/) && (ARGV.detect{|arg| arg.to_s.match(/lolita[^:]*:.*/)})
     end
   end
-end
+end

data/lolita.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{lolita}
-  s.version = "3.1.6"
+  s.version = "3.1.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["ITHouse (Latvia) and Arturs Meisters"]
-  s.date = %q{2011-05-19}
+  s.date = %q{2011-06-10}
   s.description = %q{Great Rails CMS, that turns your business logic into good-looking, fully functional workspace. }
   s.email = %q{support@ithouse.lv}
   s.extra_rdoc_files = [
@@ -26,6 +26,7 @@ Gem::Specification.new do |s|
     "README.rdoc",
     "Rakefile",
     "VERSION",
+    "app/controllers/lolita/info_controller.rb",
     "app/controllers/lolita/rest_controller.rb",
     "app/helpers/components/lolita/configuration/list_component.rb",
     "app/helpers/lolita_helper.rb",
@@ -78,6 +79,7 @@ Gem::Specification.new do |s|
     "app/views/components/lolita/shared/_header.html.erb",
     "app/views/components/lolita/shared/_right_sidebar.html.erb",
     "app/views/layouts/lolita/application.html.erb",
+    "app/views/lolita/info/index.html.erb",
     "app/views/lolita/rest/form.html.erb",
     "app/views/lolita/rest/index.html.erb",
     "author",
@@ -149,6 +151,7 @@ Gem::Specification.new do |s|
     "public/images/lolita/plus.png",
     "public/javascripts/jquery-1.6.min.js",
     "public/javascripts/jquery-ui-1.8.13.min.js",
+    "public/javascripts/lolita/application.js",
     "public/javascripts/lolita/main.js",
     "public/javascripts/lolita/tab.js",
     "public/javascripts/modernizr-1.7.min.js",
@@ -324,7 +327,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/ithouse/lolita}
   s.licenses = ["MIT"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.6.1}
+  s.rubygems_version = %q{1.6.2}
   s.summary = %q{Great Rails CMS.}
   s.test_files = [
     "spec/adapter_helper.rb",
@@ -385,7 +388,7 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<rails>, ["~> 3.0"])
-      s.add_runtime_dependency(%q<kaminari>, ["~> 0.11.0"])
+      s.add_runtime_dependency(%q<kaminari>, ["~> 0.12.4"])
       s.add_runtime_dependency(%q<abstract>, [">= 0"])
       s.add_runtime_dependency(%q<builder>, ["~> 2.1.2"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
@@ -400,7 +403,7 @@ Gem::Specification.new do |s|
       s.add_development_dependency(%q<akephalos>, [">= 0"])
     else
       s.add_dependency(%q<rails>, ["~> 3.0"])
-      s.add_dependency(%q<kaminari>, ["~> 0.11.0"])
+      s.add_dependency(%q<kaminari>, ["~> 0.12.4"])
       s.add_dependency(%q<abstract>, [">= 0"])
       s.add_dependency(%q<builder>, ["~> 2.1.2"])
       s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
@@ -416,7 +419,7 @@ Gem::Specification.new do |s|
     end
   else
     s.add_dependency(%q<rails>, ["~> 3.0"])
-    s.add_dependency(%q<kaminari>, ["~> 0.11.0"])
+    s.add_dependency(%q<kaminari>, ["~> 0.12.4"])
     s.add_dependency(%q<abstract>, [">= 0"])
     s.add_dependency(%q<builder>, ["~> 2.1.2"])
     s.add_dependency(%q<jeweler>, ["~> 1.5.2"])