nitro 0.31.0 → 0.40.0

data/lib/nitro/control/attribute/options.rb

@@ -0,0 +1,38 @@
+require 'nitro/control/attribute'
+
+module Nitro
+
+# Controls a Fixnum attribute that can contain discreet values
+# (options).
+#
+# === Example
+#
+# Pass a 'reverse' dictionary. Reverse to reuse the has for 
+# easy rendering of labels. Dictionary to allow for ordered
+# keys.
+# 
+# PRIORITY_VALUES = Dictionary[
+#   0, :trivial,
+#   1, :minor,
+#   2, :major,
+#   3, :blocker
+# ]
+#
+# attr_accessor :priority, Fixnum, :control => :options, :options_data => PRIORITY_VALUES
+
+class OptionsControl < AttributeControl
+  setting :style, :default => 'width: 100px', :doc => 'The default style'
+
+  def render
+    style = @anno.control_style || self.class.style 
+    data = @anno[:options_data]
+    %{
+      #{emit_label}
+      <select id="#{@attribute}_ctl" name="#{@attribute}">
+        #{options :labels => data.values, :values => data.keys, :selected => value}
+      </select>
+    }
+  end  
+end
+
+end

data/lib/nitro/control/attribute/password.rb

@@ -0,0 +1,16 @@
+require 'nitro/control/attribute'
+
+module Nitro
+
+class PasswordControl < AttributeControl
+  setting :style, :default => 'width: 250px', :doc => 'The default style'
+
+  def render
+    %{
+    #{emit_label}
+    <input type="password" id="#{@attribute}_ctl" name="#{@attribute}" value="#{@object.send(@attribute)}"#{emit_style}#{emit_disabled} />
+    }
+  end
+end
+
+end

data/lib/nitro/control/attribute/text.rb

@@ -0,0 +1,16 @@
+require 'nitro/control/attribute'
+
+module Nitro
+
+class TextControl < AttributeControl
+  setting :style, :default => 'width: 250px', :doc => 'The default style'
+
+  def render
+    %{
+    #{emit_label}
+    <input type="text" id="#{@attribute}_ctl" name="#{@attribute}" value="#{@object.send(@attribute)}"#{emit_style}#{emit_disabled} />
+    }
+  end
+end
+
+end

data/lib/nitro/control/attribute/textarea.rb

@@ -0,0 +1,16 @@
+require 'nitro/control/attribute'
+
+module Nitro
+
+class TextareaControl < AttributeControl
+  setting :style, :default => 'width: 500px; height: 100px', :doc => 'The default style'
+  
+  def render
+    %{
+    #{emit_label}
+    <textarea id="#{@attribute}_ctl" name="#{@attribute}"#{emit_style}#{emit_disabled}>#{@object.send(@attribute)}</textarea>
+    }        
+  end
+end
+
+end

data/lib/nitro/control/none.rb

@@ -0,0 +1,16 @@
+require 'nitro/control/attribute'
+
+module Nitro
+
+class NoneControl < AttributeControl
+  def render
+    %{
+    #{emit_label}<br />
+    <div class="none_ctl_container">
+      No control available
+    </div>
+    }
+  end
+end
+
+end

data/lib/nitro/control/relation.rb

@@ -0,0 +1,53 @@
+require 'nitro/control/attribute'
+
+module Nitro
+
+# The base class for controls used to inspect object 
+# relations.
+#--
+# FIXME: this is a temp hack.
+# TODO: Fix mismatches with attributes.
+#++
+
+class RelationControl < AttributeControl
+  
+  # === Input
+  #
+  # * object = the object to inspect
+  # * symbol = the relation symbol
+  # * anno = the relation annotations
+  # * options = additional options
+ 
+  def initialize object, rel, options
+    @object = object
+    @anno = rel
+    @value = options[:value] || object.send(rel.name.to_sym)
+    @options = options
+  end
+
+  def symbol
+    @anno[:symbol]
+  end
+  
+  def rel
+    @anno
+  end
+
+private
+
+  # Emit the label for this control.
+  # The label is skipped if the control is created with the
+  # option :no_label set to true.
+  #--
+  # TODO: reuse attribute control version.
+  #++
+  
+  def emit_label
+    return '' if @options[:no_label]
+    title = @anno[:title] || @options[:label] || @anno[:name].to_s.humanize
+    %{<label for="#{@anno[:name]}">#{title}</label>}
+  end
+
+end
+
+end

data/lib/nitro/control/relation/has_many.rb

@@ -0,0 +1,97 @@
+require 'nitro/control/relation'
+
+module Nitro
+
+# HasMany, ManyToMany and JoinsMany
+
+class HasManyControl < RelationControl
+  
+  #pre :do_this, :on => :populate_object
+  
+  def render
+    str = "#{emit_label}"
+    str << emit_container_start
+    str << emit_js
+    if selected_items.empty?
+      str << emit_selector(:removable => false)
+    else
+      removable = selected_items.size != 1 ? true : false
+      selected_items.each do |item|
+        str << emit_selector(:selected => item.pk)
+      end
+    end
+    str << emit_container_end
+  end
+  
+  private 
+  
+  # these parts are seperated from render to make it easier
+  # to extend and customise the HasManyControl
+  
+  def all_items
+    return @all_items unless @all_items.nil?
+    @all_items = rel.target_class.all
+  end
+  
+  def selected_items
+    if @object.saved?
+      values
+    else
+      [] # gmosx, THINK: this is a hack fix!
+    end
+  end
+  
+  def emit_container_start
+    %{<div class="many_to_many_container">}
+  end
+  
+  def emit_container_end
+    '</div>'
+  end
+  
+  # :removable controls wether the minus button is active
+  # :selected denotes the oid to flag as selected in the list
+  
+  def emit_selector(options={})
+    removable = options.fetch(:removable, true)
+    selected = options.fetch(:selected, nil)
+    %{
+    <div>
+    <select class="has_many_ctl" name="#{rel.name}[]" #{emit_style}#{emit_disabled}>
+      <option value="">None</option>
+      #{options(:labels => all_items.map{|o| o.to_s}, :values => all_items.map{|o| o.pk}, :selected => selected)}
+    </select>
+    <input type="button" class="#{rel.name}_remove_btn" value=" - " onclick="rm_#{rel.name}_rel(this);" #{'disabled="disabled"' unless removable} />
+    <input type="button" class="#{rel.name}_add_btn" value=" + " onclick="add_#{rel.name}_rel(this);"#{emit_disabled} />
+    </div>
+    }
+  end
+  
+  # Inline script: override this to change behavior
+  
+  def emit_js
+    %{
+    <script type="text/javascript">
+      rm_#{rel.name}_rel = function(el){
+        ctl=el.parentNode; 
+        container=ctl.parentNode; 
+        container.removeChild(ctl); 
+        inputTags = container.getElementsByTagName('input');
+        if(inputTags.length==2) 
+          inputTags[0].disabled='disabled';
+      }
+      add_#{rel.name}_rel = function(el){
+        ctl=el.parentNode; 
+        container=ctl.parentNode; 
+        node=ctl.cloneNode(true); 
+        node.getElementsByTagName('input')[0].removeAttribute('disabled'); 
+        if(container.lastChild==ctl) container.appendChild(node);
+        else container.insertBefore(node, ctl.nextSibling);
+        if(container.childNodes.length>1) container.getElementsByTagName('input')[0].disabled='';
+      }
+    </script>
+    }
+  end
+end
+
+end

data/lib/nitro/control/relation/refers_to.rb

@@ -0,0 +1,29 @@
+require 'nitro/control/relation'
+
+module Nitro
+
+# RefersTo. Also used for BelongsTo.
+
+class RefersToControl < RelationControl
+
+  def render
+    %{
+    #{emit_label}
+    <select id="#{rel.name}_ctl" name="#{rel.name}"#{emit_disabled}>
+    #{emit_options}
+    </select>
+    }
+  end
+  
+  def emit_options
+    objs = rel.target_class.all
+    selected = selected.pk if selected = value
+    %{
+      <option value="">--</option>
+      #{options(:labels => objs.map{|o| o.to_s}, :values => objs.map{|o| o.pk}, :selected => selected)}
+    }
+  end
+
+end
+
+end

data/lib/nitro/controller.rb

@@ -1,8 +1,8 @@
-require 'facet/annotation'
-require 'facet/inheritor'
+require 'facets/more/annotation'
+require 'facets/more/inheritor'
 require 'facets/more/aspects'
 
-require 'glue/markup'
+require 'nitro/markup'
 
 require 'nitro'
 require 'nitro/render'
@@ -11,297 +11,10 @@ require 'nitro/caching'
 require 'nitro/flash'
 require 'nitro/helper'
 require 'nitro/compiler'
+require 'nitro/publishable'
 
 module Nitro
 
-# Include this Mixin to a class to make objects of this class
-# publishable, ie accessible through a standard web (REST) 
-# interface.
-#
-# === Instance variables
-#
-# ==== mount_path
-#
-# Where the publishable is mounted.
-#
-# ==== template_root
-#
-# Where to look for templates for this publishable
-# object / controller. The template root is actually a stack
-# to implement some form of template root inheritance, 
-# thus allowing for more reusable controllers. Ie you can
-# 'extend' a controller, and only override the templates
-# you want to change. The compiler will traverse the 
-# template root stack and use the templates from parent
-# controllers if they are not overriden.
-
-
-module Publishable
-
-  def self.included(base)
-    super
-
-    base.module_eval do
-      include Render
-      include ::Aspects
-      include Flashing
-      include Helpers
-
-      # The collection of 'models' ie classes that are linked
-      # to this Publishable/Controller.
-      
-      ann :self, :models => []
-
-      # This is a helper that 'links' one or more classes to this
-      # controller. In practice it annotates each class with the 
-      # controller and stores the controller's list of 'models'.
-      
-      def self.model *classes
-        for c in classes
-          c.ann :self, :controller => self
-          self.ann.self.models! << c
-        end
-      end
-    end
-
-    # Aliases an action
-    #--
-    # gmosx, FIXME: better implementation needed.
-    # gmosx, FIXME: copy all annotations.
-    #++
-
-    base.module_eval do
-      def self.alias_action(new, old)
-        alias_method new, old
-        ann new, :view => old        
-      end
-    end
-
-    # Return the 'action' methods for this Controller.
-    # Some dangerous methods from ancestors are removed.
-    # All private methods are ignored.
-    
-    base.module_eval do
-      def self.action_methods
-        classes = self.ancestors.reject do |a| 
-          [Object, Kernel, Render, Controller, Caching].include?(a) 
-        end
-
-        classes.delete(PP::ObjectMixin) if defined?(PP::ObjectMixin)
-        
-        methods =  classes.inject([]) do |action_methods, klass| 
-          action_methods + klass.public_instance_methods(false) 
-        end
-
-        # gmosx: add the default action (leave this?)
-        # methods << 'index'
-                
-        return methods
-      end
-    end
-        
-    # Use the method_missing hook to compile the actions
-    # for this controller.
-  
-    base.module_eval do
-      def method_missing(action, *args)
-        if Compiler.new(self.class).compile(action)
-          send(action, *args)
-        else
-          super
-        end
-      end
-    end    
-
-    # Does this publishable respond to the given action?
-    
-    base.module_eval do
-      class << self
-        def respond_to_action?(action)
-          action_methods.include?(action.to_s)              
-        end
-        alias_method :action?, :respond_to_action?
-      end
-    end
-        
-    # Does this class respond to the given action? 
-    # Also looks for templates in the template root.
-    #
-    # Prefer to use the compiler for this.
-    #--
-    # THINK: maybe move template? here
-    #++
-  
-    base.module_eval do
-      class << self
-        def respond_to_action_or_template?(sym)
-          return self.respond_to_action?(sym.to_s) || Compiler.new(self).template?(sym)             
-        end
-      end
-    end
-        
-    base.module_eval do
-      class << self
-        # Override this method to customize the template_root.
-        # Typically used in controllers defined in reusable Parts.
-        # Call super to include the parent class's customizations.
-        #
-        # def setup_template_root(path)
-        #   super
-        #   @template_root << "custom/route/#{path}"
-        #   @template_root << "another/route/#{path}"
-        # end  
-        
-        def setup_template_root(path)
-        end
-        
-        def mount_at(path)
-          # Store the mount_path (where the controller is mounted).
-          
-          @mount_path = path
-          
-          # Update template_root. Unshift the PROTO_TEMPLATE_ROOT, 
-          # and unshift a template_root relative to the 
-          # application template root.
-        
-          @template_root = []
-          @template_root << File.join(Compiler::PROTO_TEMPLATE_ROOT, path).gsub(/\/$/, '')
-          setup_template_root(path)
-          @template_root << File.join(Glue::Template.root, path).gsub(/\/$/, '')
-          @template_root.reverse!
-        end
-        alias_method :mount, :mount_at
-
-        # Returns the path where this controller is mounted.
-        
-        def mount_path
-          @mount_path
-        end
-        alias_method :mount_point, :mount_path
-      end
-    end
-    
-  end
-
-private
-
-  # Cookie helpers.
-  #--
-  # TODO: move elsewhere, probably to a default helper.
-  #++
-  
-  def cookies
-    @context.cookies
-  end  
-
-  # Send the cookie to the response stream.
-  
-  def send_cookie(name, value = nil)
-    @context.add_cookie(name, value)
-  end
-
-  # Delete the cookie by setting the expire time to now and 
-  # clearing the value.
-  
-  def delete_cookie(name)
-    cookie = Cookie.new(name, '')
-    cookie.expires = Time.now  
-    @context.add_cookie(cookie)    
-  end
-  
-  # Encode controller, action, params into a valid url.
-  # Automatically respects nice urls and routing.
-  #
-  # Handles parameters either as a hash or as an array.
-  # Use the array method to pass parameters to 'nice' actions.
-  #
-  # Pass Controller, action, and (param_name, param_value) 
-  # pairs.
-  #
-  # === Examples
-  #
-  # encode_url ForaController, :post, :title, 'Hello', :body, 'World'
-  # encode_url :post, :title, 'Hello', :body, 'World' # => implies controller == self
-  # encode_url :kick, :oid, 4
-  # encode_url article # => article.to_href
-  # 
-  # Alternatively you can pass options with a hash:
-  #
-  # encode_url :controller => ForaController, :action => :delete, :params => { :title => 'Hello' }
-  # encode_url :action => :delete
-  #--
-  # FIXME: better implementation? optimize this?
-  # TODO: move elsewhere.
-  #++
-  
-  def encode_url *args
-    f = args.first
-    
-    # A standard url as string, return as is.
-    
-    if f.is_a? String
-      return f
-    end
-  
-    # If the passed param is an object that responds to :to_href
-    # returns the url to this object.
-    
-    if f.respond_to? :to_href
-      return args.first.to_href
-    end
-    
-    if f.is_a? Symbol
-      # no controller passed, imply controller == self!
-      args.unshift(self.class)
-    end
-
-    # Try to encode using the router.
-    
-    if url = context.dispatcher.encode_route(*args)
-      return url
-    end
-    
-    # No routing rule, manual encoding.
-    
-    controller = args.shift
-    action = args.shift.to_sym
-    
-    url = "#{controller.mount_path}/#{action}"
-    
-    unless args.empty?
-      if controller.respond_to_action_or_template? action
-        param_count = controller.instance_method(action).arity
-        if param_count != 0
-          param_count.times do
-            args.shift # name 
-            url << "/#{CGI.escape(args.shift.to_s)}"
-          end        
-        end
-      end
-      
-      unless args.empty?
-        url << '?'
-        params = []
-        (args.size / 2).times do
-          params << "#{args.shift}=#{args.shift}" 
-        end
-        url << params.join(';')
-      end
-    end
-    
-    return url  
-  end
-  alias_method :R, :encode_url
-    
-  # Just like encode_url, but generates an absolute url instead.
-  
-  def encode_absolute_url(*args)
-    return "#{request.host_url}#{encode_url(*args)}"
-  end
-  alias_method :RA, :encode_absolute_url
-    
-end
-
 # The Controller part in the MVC paradigm. The controller's 
 # published methods are called actrions. The controller class
 # contains the Publishable mixin and additional helper mixins.
@@ -311,11 +24,11 @@ class Controller
   include Scaffolding
   include Caching
   include Helpers
-  helper Glue::Markup
+  helper Nitro::Markup
 
   # This callback is called after the Controller is mounted.
   
-  def self.mounted path
+  def self.mounted(path)
     # Resolve aspects.
     
     Aspects.include_advice_modules(self)
@@ -338,7 +51,7 @@ class Controller
   # This is an internal method.
   #++
   
-  def self.replace_current controller # :nodoc:
+  def self.replace_current(controller) # :nodoc:
     old = Thread.current[:CURRENT_CONTROLLER]
     Thread.current[:CURRENT_CONTROLLER] = controller
     return old
@@ -347,5 +60,3 @@ class Controller
 end
 
 end
-
-# * George Moschovitis <gm@navel.gr>