zena 1.0.0.beta2 → 1.0.0.beta3

data/lib/zena/remote/klass.rb

@@ -0,0 +1,14 @@
+module Zena
+  module Remote
+    class Klass
+      attr_accessor :connection, :name
+
+      include Zena::Remote::Interface::ClassMethods
+
+      def initialize(connection, name)
+        @connection = connection
+        @name = name
+      end
+    end
+  end # Remote
+end # Zena

data/lib/zena/remote/mock.rb

@@ -0,0 +1,58 @@
+module Zena
+  module Remote
+    module Mock
+      # Redirect actual request to the integration test.
+      class Request < HTTParty::Request
+        def perform_actual_request
+          # body should contain xml data for post and put (@raw_request.body ?)
+          method  = @raw_request.method.downcase
+          path    = @raw_request.path
+          body    = @raw_request.body
+
+          response = $test_connection.test_request(method, path, body, options[:headers], false)
+          transform_response(response)
+        end
+
+
+        # Transform an ActionController::Response into a Net::HTTP response.
+        # Based on code from fakeweb (thanks Chrisk !)
+        def transform_response(ac_res)
+          code, msg = 200, 'OK'
+          response = Net::HTTPResponse.send(:response_class, code.to_s).new("1.0", code.to_s, msg)
+          response.instance_variable_set(:@body, ac_res.body)
+          ac_res.headers.each do |name, value|
+            if value.respond_to?(:each)
+              value.each { |v| response.add_field(name, v) }
+            else
+              response[name] = value
+            end
+          end
+
+          response.instance_variable_set(:@read, true)
+
+          class << response
+            def read_body(*args, &block)
+              yield @body if block_given?
+              @body
+            end
+          end
+
+          response
+        end
+      end
+
+      # Include this module to mock the connection and use the integration test to execute
+      # the actual request operations.
+      module Connection
+
+        def self.included(base)
+          def base.perform_request(http_method, path, options) #:nodoc:
+            options = default_options.dup.merge(options)
+            process_cookies(options)
+            request = Zena::Remote::Mock::Request.new(http_method, path, options).perform
+          end
+        end
+      end # Connection
+    end # Mock
+  end # Remote
+end # Zena

data/lib/zena/remote/node.rb

@@ -0,0 +1,76 @@
+module Zena
+  module Remote
+    class Node
+      include Zena::Remote::Interface::InstanceMethods
+      attr_accessor :connection, :attributes, :errors
+
+      def initialize(connection, hash)
+        @connection = connection
+        @attributes = {}
+        self.attributes = hash
+      end
+
+      def attributes=(new_attributes)
+        raise Exception.new("Invalid attributes. Expecting a hash, found #{new_attributes.inspect}") unless new_attributes.kind_of?(Hash)
+        new_attributes.stringify_keys.each do |key, value|
+          if value.kind_of?(Array)
+            # setting multiple ids
+            key = "#{key}_ids" unless key =~ /_ids$/
+            @attributes[key] = value.map do |elem|
+              if elem.kind_of?(Remote::Node)
+                elem.id
+              else
+                elem
+              end
+            end
+          elsif value.kind_of?(Remote::Node)
+            key = "#{key}_id" unless key =~ /_id$/
+            @attributes[key] = value.id
+          elsif key =~ /_ids$/ && value.kind_of?(String)
+            @attributes[key] = value.split(',').map(&:to_i)
+          else
+            @attributes[key] = value
+          end
+        end
+      end
+
+      def id
+        @attributes['id']
+      end
+
+      def method_missing(method, *args)
+        method = method.to_s
+        if args.size == 1 && method =~ /(.*)=$/
+          key = $1
+          elem = args.first
+          if elem.kind_of?(Remote::Node)
+            key = "#{key}_id" unless key =~ /_ids?$/
+            @attributes[key] = elem.id
+          elsif elem.kind_of?(Array)
+            key = "#{key}_ids" unless key =~ /_ids?$/
+            @attributes[key] = elem.map do |value|
+              value.kind_of?(Remote::Node) ? value.id : value
+            end
+          else
+            @attributes[$1] = elem
+          end
+        elsif args.size == 0
+          if @attributes.has_key?(method)
+            @attributes[method]
+          elsif method =~ /_ids?$/
+            @attributes[method] ||= []
+          else
+            # build query
+            if method.pluralize == method
+              res = all(method)
+            else
+              res = first(method)
+            end
+          end
+        else
+          super
+        end
+      end
+    end
+  end # Remote
+end # Zena

data/lib/zena/routes.rb

@@ -25,7 +25,8 @@ module Zena
         :collection => { :asearch => :get, :search => :get },
         :member =>     { :import => :post, :export => :get, :save_text => :put,
                          :order => :any, :clear_order => :any,
-                         :zafu => :get, :drop => :put, :attribute => :get
+                         :zafu => :get, :drop => :put, :attribute => :get,
+                         :find => :get # same as search but starting on current node instead of root
                        }.merge(Zena::Use::Grid::Routes) do |nodes|
         nodes.resources :versions,
                         :member => { :edit    => :get,

data/lib/zena/use.rb

@@ -9,16 +9,16 @@ module Zena
     class << self
       attr_accessor :modules
 
-      # Delcare a module (or list of modules) that should be used in Zena. The module should implement
+      # Declare a module (or list of modules) that should be used in Zena. The module should implement
       # sub-modules named ControllerMethods, ViewMethods or ZafuMethods in order to add features to
       # the controller, view or zafu compiler respectively.
       def module(*modules)
         create_module_hash
 
         modules.flatten.each do |mod|
-          MODULE_NAME.each do |key, module_name|
+          MODULE_NAME.each do |key, sub_module_name|
             begin
-              self.modules[key] << mod.const_get(module_name)
+              self.modules[key] << mod.const_get(sub_module_name)
             rescue NameError
               # ignore
             end
@@ -28,11 +28,16 @@ module Zena
 
       def each_module_for(name)
         create_module_hash
-        (self.modules[name] || []).each do |mod|
+        modules_for(name).each do |mod|
           yield(mod)
         end
       end
 
+      def modules_for(name)
+        create_module_hash
+        self.modules[name] || []
+      end
+
       private
         def create_module_hash
           if self.modules.nil?

data/lib/zena/use/ajax.rb

@@ -232,7 +232,7 @@ module Zena
 
           dom_id = node.dom_id(:erb => false)
 
-          out %Q{<%= form_remote_tag(:url => zafu_node_path(#{node}), :method => :get, :html => {:id => \"#{dom_id}_f\"}) %>
+          out %Q{<%= form_remote_tag(:url => zafu_node_path(#{node}.zip), :method => :get, :html => {:id => \"#{dom_id}_f\"}) %>
           <div class='hidden'>
             <input type='hidden' name='t_url' value='#{template_url(upd)}'/>
             <input type='hidden' name='dom_id' value='#{upd}'/>
@@ -297,7 +297,7 @@ module Zena
           return parser_error("missing 'set' or 'add' parameter") unless role = @params.delete(:set) || @params.delete(:add)
           return parser_error("missing 'for' parameter") unless finder = @params.delete(:for)
 
-          finder = RubyLess.translate(finder, self)
+          finder = RubyLess.translate(self, finder)
           return parser_error("Invalid class 'for' parameter: #{finder.klass}") unless finder.klass <= Node
 
           set_dom_prefix
@@ -315,7 +315,7 @@ module Zena
             return
           end
 
-          finder = RubyLess.translate(finder, self)
+          finder = RubyLess.translate(self, finder)
           unless finder.klass <= Node
             out parser_error("Invalid class 'for' parameter: #{finder.klass}")
             return

data/lib/zena/use/authlogic.rb

@@ -20,6 +20,13 @@ module Zena
         private
 
           def save_after_login_url
+            # prevent redirect to favicon or css
+            return unless request.format == Mime::HTML
+            path = params[:path]
+            if path && path.last =~ /\.(.+)\Z/
+              return if $1 != 'html'
+            end
+
             session[:after_login_url] = request.parameters
           end
 
@@ -92,7 +99,7 @@ module Zena
                 # Allow xml without :prefix in NodesController because it is rendered with zafu.
 
                 # Authentication token required for xml.
-                render :xml => 'Authentication token needed.', :status => 401
+                render :xml => [{:message => 'Authentication token needed.'}].to_xml(:root => 'errors'), :status => 401
               end
             end
           end

data/lib/zena/use/context.rb

@@ -12,6 +12,7 @@ module Zena
 
         # Group an array of records by key.
         def group_array(list)
+          return nil if list.empty?
           groups = []
           h = {}
           list.each do |e|
@@ -148,38 +149,38 @@ module Zena
           # end
 
           if %w{parent project section}.include?(key)
-            key = "e.#{key}"
+            key = "e.#{key}_id"
           else
-            key = "e.#{RubyLess.translate(key, node.klass.first)}"
+            receiver = RubyLess::TypedString.new('e', :class => node.klass.first, :query => node.opts[:query])
+            key = RubyLess.translate(receiver, key)
           end
 
           #if sort_block
           #  out "<% grp_#{list_var} = sort_array(#{group_array}) #{sort_block} -%>"
           #else
-            out "<% #{var} = group_array(#{node}) {|e| #{key}} -%>"
           #end
+          method = "group_array(#{node}) {|e| #{key}}"
+          out "<% if #{var} = #{method} -%>"
+            open_node_context({:method => method}, :node => node.move_to(var, [node.klass], :query => node.opts[:query])) do
+              if child['each_group']
+                out expand_with
+              else
+                @var = nil
+                r_each
+              end
+            end
+          out "<% end -%>"
 
-          if descendant('each_group')
-            out expand_with(:group => var)
-          else
-            @context[:group] = var
-            r_each_group
-          end
+          #if descendant('each_group')
+          #  out expand_with(:group => var)
+          #else
+          #  @context[:group] = var
+          #  r_each_group
+          #end
         end
 
-
         def r_each_group
-          return parser_error("must be used inside a group context") unless group = @context[:group]
-          if join = @params[:join]
-            join = join.gsub(/&lt;([^%])/, '<\1').gsub(/([^%])&gt;/, '\1>')
-            out "<% #{group}.each_with_index do |#{var}, #{var}_i| -%>"
-            out "<%= #{var}_i > 0 ? #{join.inspect} : '' %>"
-          else
-            out "<% #{group}.each do |#{var}| -%>"
-          end
-
-          out wrap(expand_with(:group => nil, :node => node.move_to(var, node.klass)))
-          out "<% end -%>"
+          r_each
         end
       end # ZafuMethods
     end # Context

data/lib/zena/use/dates.rb

@@ -279,9 +279,32 @@ EOL
         end
 
         # Select a date for the current context
-        # def r_date
-        #   set_context_var('set_var', 'date', get_attribute_or_eval)
-        # end
+        def r_date
+          return nil unless code = get_attribute_or_eval
+
+          if format = @params[:format]
+            format = RubyLess.translate_string(self, format)
+          else
+            format = "'%Y-%m-%d %H:%M:%S'"
+          end
+
+          if code.klass <= String
+            if code.could_be_nil?
+              code = "(#{code} || '').to_utc(#{format})"
+            else
+              code = "#{code}.to_utc(#{format})"
+            end
+            could_be_nil = true
+          elsif code.klass <= Time
+            could_be_nil = code.could_be_nil?
+          else
+            return parser_error("should evaluate to a String or Time (found #{code.klass})")
+          end
+          v = get_var_name('set_var', 'date')
+          out "<% #{v} = #{code} -%>"
+          set_context_var('set_var', 'date', RubyLess::TypedString.new(v, :class => Time, :nil => could_be_nil))
+          out expand_with
+        end
 
       end
     end # Dates

data/lib/zena/use/display.rb

@@ -387,11 +387,32 @@ module Zena
       end # ViewMethods
 
       module ZafuMethods
+        SHOW_KEYS = [:tz, :tformat, :format, :lang, :zero]
+
         include Common
         include RubyLess
 
         safe_method [:zazen, String] => :r_zazen
 
+        # As a last resort, if the method cannot be compilated, use <r:show eval='...'/>
+        def self.included(base)
+          base.process_unknown :show_eval
+        end
+
+        # Transform <p do='created_at' format='%d'/> into
+        #           <p do='show' eval='created_at' format='%d'/>
+        def show_eval
+          if !@params.empty? && !(@method =~ /. ./) && (@params.keys - SHOW_KEYS == [])
+            # try to use r_show without using params as arguments
+            code = RubyLess.translate(self, @method)
+            r_show(code)
+          else
+            nil
+          end
+        rescue RubyLess::Error
+          nil
+        end
+
         # Parse text with zazen helper
         def r_zazen(signature = nil)
           @markup.prepend_param(:class, 'zazen')
@@ -421,15 +442,15 @@ module Zena
         end
 
         # Display an attribute or RubyLess code
-        def r_show
+        def r_show(code = nil)
           if node.list_context?
-            @context[:node] = node.move_to("#{node}.first", node.klass.first)
+            @context[:node] = node.move_to("#{node}.first", node.klass.first, :query => node.opts[:query])
             return r_show
           elsif node.will_be?(String)
             return "<%= #{node} %>"
           end
 
-          return nil unless method = get_attribute_or_eval
+          return nil unless method = code || get_attribute_or_eval
 
           klass = method.klass
 
@@ -505,7 +526,7 @@ module Zena
           return unless node.will_be?(Node)
 
           if src = @params[:src]
-            finder = ::RubyLess.translate(@params[:src], self) #build_finder(:first, @params[:src])
+            finder = ::RubyLess.translate(self, @params[:src]) #build_finder(:first, @params[:src])
             return parser_error("invalid class (#{finder.klass})") unless finder.klass <= Node
 
             img = finder
@@ -522,7 +543,7 @@ module Zena
           res += ", :host => #{@context["exp_host"]}" if @context["exp_host"]
           res += ")"
           if finder = @params[:link]
-            finder = ::RubyLess.translate(finder, self)
+            finder = ::RubyLess.translate(self, finder)
 
             return parser_error("Invalid class (#{finder.klass})") unless finder.klass <= Node
 
@@ -586,8 +607,15 @@ module Zena
           end
 
           def show_time(method)
+            if tformat = @params.delete(:tformat)
+              tformat = RubyLess.translate(self, "t(%Q{#{tformat}})")
+              method = "#{method}, :format => #{tformat}"
+            end
+
             if hash_arguments = extract_from_params(:tz, :lang, :format)
               "<%= format_date(#{method}, #{hash_arguments.join(', ')}) %>"
+            elsif tformat
+              "<%= format_date(#{method}) %>"
             else
               "<%= #{method} %>"
             end

data/lib/zena/use/forms.rb

@@ -2,6 +2,13 @@ module Zena
   module Use
     module Forms
       module ViewMethods
+
+        # Create a new instance of the given class name
+        def new_instance(class_name, params = {})
+          return nil unless klass = Node.get_class(class_name, :create => true)
+          klass.new_instance(Node.transform_attributes(params))
+        end
+
         def make_checkbox(node, values, relation_name, attribute)
           relation_proxy = node.relation_proxy(relation_name)
           return nil unless values && relation_proxy
@@ -39,6 +46,43 @@ module Zena
       end # ViewMethods
 
       module ZafuMethods
+
+        # Enter the context of a newly created object
+        def r_new
+          return parser_error("missing 'klass' parameter") unless class_name = @params[:klass]
+          return parser_error("invalid 'klass' parameter (not a Node)") unless klass = get_class(class_name)
+
+          res  = []
+          keys = {:klass => 'klass'}
+          @params.each do |key, value|
+            next if key == :klass
+            # TODO: maybe it would be safer to check with [:"key="] and change safe_property to
+            # authorize both ?
+            next unless type = klass.safe_method_type([key.to_s])
+            # Store how to access current value to show hidden field in form.
+            keys[key] = type[:method]
+            res << ":#{key} => #{RubyLess.translate_string(self, value)}"
+          end
+
+          if res == []
+            method = "new_instance(#{class_name.inspect})"
+          else
+            method = "new_instance(#{class_name.inspect}, #{res.join(', ')})"
+          end
+
+          expand_with_finder(
+            :method   => method,
+            :class    => klass,
+            :nil      => true,
+            :new_keys => keys
+          )
+        end
+
+        def r_errors
+          # Very basic for the moment
+          "<%= error_messages_for(#{node.form_name}, :object => #{node}) %>"
+        end
+
         def make_input(form_helper, name, type, textarea = false)
           if type == Time
             "<%= date_box(#{node}, :#{name}) %>"
@@ -112,19 +156,31 @@ module Zena
               # Saved form
               opts[:id]          = "<%= ndom_id(#{node}) %>"
 
-              opts[:form_tag]    = <<-END_TXT
-<% remote_form_for(:#{node.form_name}, #{node}, :url => #{node}.new_record? ? #{node.form_name.pluralize}_path : #{node.form_name}_path(#{node}), :method => #{node}.new_record? ? :post : :put, :html => {:id => \"\#{ndom_id(#{node})}_form_t\"}) do |f| %>
-END_TXT
+              opts[:form_tag]    = %Q{
+<% remote_form_for(:#{node.form_name}, #{node}, :url => #{node}.new_record? ? #{node.form_name.pluralize}_path : #{node.form_name}_path(#{node}.zip), :html => {:method => #{node}.new_record? ? :post : :put, :id => \"\#{ndom_id(#{node})}_form_t\"}) do |f| %>
+}
 
-              opts[:form_cancel] = <<-END_TXT
+              opts[:form_cancel] = %Q{
 <% if #{node}.new_record? -%>
   <p class='btn_x'><a href='#' onclick='[\"<%= params[:dom_id] %>_add\", \"<%= params[:dom_id] %>_form\"].each(Element.toggle);return false;'>#{_('btn_x')}</a></p>
 <% else -%>
-  <p class='btn_x'><%= link_to_remote(#{_('btn_x').inspect}, :url => #{node.form_name}_path(#{node}.id) + \"/zafu?t_url=#{CGI.escape(template_url)}&dom_id=\#{params[:dom_id]}#{@context[:has_link_id] ? "&link_id=\#{#{node}.link_id}" : ''}\", :method => :get) %></p>
+  <p class='btn_x'><%= link_to_remote(#{_('btn_x').inspect}, :url => #{node.form_name}_path(#{node}.zip) + \"/zafu?t_url=#{CGI.escape(template_url)}&dom_id=\#{params[:dom_id]}#{@context[:has_link_id] ? "&link_id=\#{#{node}.link_id}" : ''}\", :method => :get) %></p>
 <% end -%>
-END_TXT
+}
             end
+          else
+            # no ajax
+            if descendants('errors')
+              error_messages = ''
+            else
+              error_messages = r_errors + "\n"
+            end
+
+            opts[:form_tag]    = %Q{
+<% form_for(:#{node.form_name}, #{node}, :url => #{node}.new_record? ? #{node.form_name.pluralize}_path : #{node.form_name}_path(#{node}.zip), :html => {:method => #{node}.new_record? ? :post : :put, :id => \"\#{ndom_id(#{node})}_form_t\"}) do |f| %>
+#{error_messages}}
           end
+
           opts
         end
 
@@ -234,8 +290,27 @@ END_TXT
 
           hidden_fields['node[v_status]'] = Zena::Status[:pub].to_s if add_params[:publish] || auto_publish_param
 
+          # All default values set in the <r:new> field should at least appear as hidden fields
+          if new_keys = node.opts[:new_keys]
+            input_keys = (
+              (descendants('input') || []).map {|e| e.params[:name]} +
+              hidden_fields.keys.map do |e|
+                if e =~ /.*\[(.*)\]/
+                  $1.to_sym
+                else
+                  nil
+                end
+              end
+            ).compact.uniq
+
+            new_keys.each do |key, value|
+              next if input_keys.include?(key)
+              hidden_fields["node[#{key}]"] = "<%= #{node}.#{value} %>"
+            end
+          end
           # ===
           # TODO: reject set_fields from hidden_fields
+          # ? what is this ?
           # ===
 
           hidden_fields.reject! do |k,v|
@@ -257,7 +332,7 @@ END_TXT
           return parser_error("missing name") unless attribute
 
           if value = @params[:selected]
-            selected = ::RubyLess.translate_string(value, self)
+            selected = ::RubyLess.translate_string(self, value)
           elsif @context[:in_filter]
             selected = "params[#{attribute.to_sym.inspect}].to_s"
           elsif %w{parent_id}.include?(attribute)
@@ -396,13 +471,13 @@ END_TXT
 
             if sub_attr
               type = node.klass.safe_method_type([attribute])
-              if sub_attr_ruby = RubyLess.translate(%Q{this.#{attribute}[#{sub_attr.inspect}]}, self)
+              if sub_attr_ruby = RubyLess.translate(self, %Q{this.#{attribute}[#{sub_attr.inspect}]})
                 res[:value] = "<%= fquote #{sub_attr_ruby} %>"
               end
             else
               if value = params[:value]
                 # On refactor, use append_markup_attr(markup, key, value)
-                value = RubyLess.translate_string(value, self)
+                value = RubyLess.translate_string(self, value)
 
                 if value.literal
                   res[:value] = value.literal.to_s.gsub("'",'&apos;')
@@ -432,6 +507,9 @@ END_TXT
             #    res[:value] = ["''"]
             #  end
             #end
+          elsif node.will_be?(Column)
+            res[:name]  = "node[<%= #{node}.name %>]"
+            res[:value] = "<%= fquote #{node(Node)}.prop[#{node}.name] %>"
           end
 
           if node.dom_prefix
@@ -474,7 +552,7 @@ END_TXT
 
           # Get current attribute in forms
           def node_attribute(attribute)
-            node_attribute = ::RubyLess.translate(attribute, node.klass)
+            node_attribute = ::RubyLess.translate(node.klass, attribute)
             "#{node}.#{node_attribute}"
           rescue ::RubyLess::NoMethodError
             if node.will_be?(Node)
@@ -517,8 +595,8 @@ END_TXT
                 nodes = finder[:method]
               end
 
-              set_attr  = ::RubyLess.translate(@params[:attr] || 'id', klass)
-              show_attr = ::RubyLess.translate(@params[:show] || 'title', klass)
+              set_attr  = ::RubyLess.translate(klass, @params[:attr] || 'id')
+              show_attr = ::RubyLess.translate(klass, @params[:show] || 'title')
 
               options_list = "[['','']] + (#{nodes} || []).map{|r| [r.#{show_attr}, r.#{set_attr}.to_s]}"
             elsif values = @params[:values]