wee 0.5.0 → 0.6.0

data/lib/wee/databases/og/application.rb

@@ -0,0 +1,3 @@
+class OgApplication < Wee::Application
+  attr_accessor :db
+end

data/lib/wee/databases/og/old_scaffolder.rb

@@ -0,0 +1,98 @@
+class OgScaffolder < Wee::Component
+
+  def initialize(domain_class)
+    super()
+    @domain_class = domain_class
+    @attributes = domain_class.__props.map {|a| a.name}.reject {|a| a == 'oid'}
+  end
+
+  def delete(obj)
+    call Wee::MessageBox.new('Really delete?'), :confirm_delete, obj
+  end
+
+  def confirm_delete(confirmed, obj)
+    if confirmed
+      @objs.delete(obj)
+      obj.delete!
+    end
+  end
+
+  def edit(obj)
+    @edit = obj
+  end
+
+  def save(obj)
+    obj.save!
+    @edit = nil
+  end
+ 
+  def cancel
+    @objs.delete(@edit) if @edit and @edit.oid.nil?
+    @edit = nil
+  end
+
+  def refresh
+    @objs = @domain_class.all || []
+  end
+
+  def create
+    @objs << (@edit = @domain_class.new)
+  end
+
+  def render
+    refresh if @objs.nil?
+
+    r.h1 "#{ @domain_class } List"
+    r.anchor.callback { refresh }.with("Refresh")
+
+    r.form do
+      r.table.border(1).with {
+
+        r.table_row.with {
+          @attributes.each {|a|
+            r.table_header.with {
+              r.bold(a.capitalize)
+            }
+          }
+          r.table_header.with(" ")
+        }
+
+        @objs.each {|o| 
+          r.table_row.with do 
+            if @edit == o
+
+              @attributes.each { |attr|
+                r.table_data.with { r.text_input.callback {|v| o.send(attr+"=",v) }.value(o.send(attr)) }
+              } 
+
+              r.table_data.with {
+                r.submit_button.callback { save(o) }.value("Save")
+                r.space
+                r.submit_button.callback { cancel() }.value("Cancel")
+                r.space
+                r.anchor.callback { delete(o) }.with("Delete")
+              }
+
+            else
+
+              @attributes.each { |attr|
+                r.table_data(o.send(attr))
+              } 
+
+              r.table_data.with {
+                r.anchor.callback { edit(o) }.with("Edit")
+                r.space
+                r.anchor.callback { delete(o) }.with("Delete")
+              }
+
+            end
+          end 
+        }
+      }
+    end
+
+    r.anchor.callback { create() }.with("Add new #{ @domain_class }")
+
+  end
+
+end

data/lib/wee/databases/og/scaffolder.rb

@@ -0,0 +1,174 @@
+# This is a Rails-like scaffolder for use with Og (http://navel.gr/nitro)
+# domain objects.
+
+class OgScaffolder < Wee::Component
+  def initialize(domain_class)
+    super()
+    @domain_class = domain_class
+    # DON'T use @properties here as it is already used by Wee
+    @props = @domain_class.__props.reject {|a| a.name == 'oid'}
+  end
+
+  def render
+    r.h1 "List #{ @domain_class }"
+    r.paragraph
+    r.table.border(1).with {
+      render_header
+      render_body
+    }
+    r.paragraph
+    r.anchor.callback(:add).with("Add new #{ @domain_class }")
+  end
+
+  def render_header
+    r.table_row.with {
+      @props.each {|prop|
+        render_property_header(prop)
+      }
+      render_action_header
+    }
+  end
+
+  def render_action_header
+    r.paragraph
+    r.table_header.with { r.space(2) }  # the action column
+  end
+
+  def render_property_header(prop)
+    r.table_header.with {
+      r.bold(prop.name.to_s.capitalize)
+    }
+  end
+
+  def render_body
+    domain_objects.each {|obj| render_object(obj) }
+  end
+
+  def render_object(obj)
+    r.table_row {
+      @props.each {|prop| render_property(obj, prop) } 
+      render_action(obj)
+    }
+  end
+
+  def render_action(obj)
+    r.table_data.with {
+      r.anchor.callback(:edit, obj).with("Edit")
+      r.space
+      r.anchor.callback(:destroy, obj).with("Destroy")
+    }
+  end
+
+  def render_property(obj, prop)
+    r.table_data(obj.send(prop.name).to_s)
+  end
+
+  def edit(obj)
+    call Editor.new(obj).add_decoration(Wee::FormDecoration.new)
+  end
+
+  def add
+    call Editor.new(@domain_class.new, "Create").
+      add_decoration(Wee::FormDecoration.new)
+  end
+
+  def destroy(obj)
+    call Wee::MessageBox.new('Do you really want to destroy the object?'), 
+      :confirm_destroy, obj
+  end
+
+  def confirm_destroy(obj, confirmed)
+    obj.delete! if confirmed
+  end
+
+  def domain_objects
+    @domain_class.all || []
+  end
+end
+
+class OgScaffolder::Editor < Wee::Component
+
+  def initialize(domain_object, action="Edit")
+    super()
+    @domain_object = domain_object
+    @action = action
+  end
+
+  def render
+    render_header
+    each_property {|prop| 
+      render_property(prop) unless prop.name == 'oid'
+    }
+    render_buttons
+  end
+
+  def render_header
+    r.h1 "#{ @action } #{ @domain_object.class }"
+  end
+
+  def render_property(prop)
+    render_label(prop)
+
+    if prop.klass.ancestors.include?(Numeric)
+      render_numeric(prop)
+    elsif prop.klass.ancestors.include?(String)
+      render_string(prop)
+    elsif prop.klass.ancestors.include?(TrueClass)
+      render_bool(prop)
+    end
+  end
+
+  def render_numeric(prop)
+    r.text_input.value(get_value_of(prop)).callback(:set_value_of, prop) 
+  end
+
+  def render_string(prop)
+    if prop.meta[:ui] == :textarea
+      r.text_area.callback(:set_value_of, prop).with(get_value_of(prop))
+    else
+      r.text_input.value(get_value_of(prop)).callback(:set_value_of, prop)
+    end
+  end
+
+  def render_bool(prop)
+    selected = [ get_value_of(prop) ? true : false ]
+    r.select_list([true, false]).labels(["Yes", "No"]).selected(selected).
+      callback {|choosen| set_value_of(prop, choosen.first) }
+  end
+
+  def render_buttons
+    r.paragraph
+    r.submit_button.value('Save').callback(:save)
+    r.space
+    r.submit_button.value('Cancel').callback(:cancel)
+  end
+
+  def render_label(prop)
+    r.paragraph
+    r.text prop.name.capitalize
+    r.break
+  end
+
+  private
+
+  def each_property(&block)
+    @domain_object.class.__props.each(&block)
+  end
+
+  def get_value_of(prop)
+    @domain_object.send(prop.symbol)
+  end
+
+  def set_value_of(prop, value)
+    @domain_object.send(prop.symbol.to_s + "=", value)
+  end
+
+  def save
+    @domain_object.save!
+    answer @domain_object
+  end
+
+  def cancel
+    answer nil
+  end
+end

data/lib/wee/databases/og/session.rb

@@ -0,0 +1,9 @@
+class OgSession < Wee::Session
+  def awake
+    application.db.get_connection
+  end
+
+  def sleep
+    application.db.put_connection
+  end
+end

data/lib/wee/idgen/md5.rb

@@ -0,0 +1,21 @@
+# Returned ids might not be unique, but it should be very hard to guess the
+# next id.
+
+require 'digest/md5'
+
+class Wee::Md5IdGenerator
+  def initialize(salt='wee')
+    @salt = salt
+  end
+
+  def next
+    now = Time.now
+    md5 = Digest::MD5.new
+    md5.update(now.to_s)
+    md5.update(now.usec.to_s)
+    md5.update(rand(0).to_s)
+    md5.update($$.to_s)
+    md5.update(@salt.to_s)
+    md5.hexdigest
+  end
+end

data/lib/wee/{idgen.rb → idgen/simple.rb}

@@ -1,12 +1,10 @@
+# Returned ids are guaranteed to be unique, but they are easily guessable.
+
 class Wee::SimpleIdGenerator
   def initialize(initial_value=0)
     @value = initial_value
   end
 
-  def current
-    @value
-  end
-
   def next
     @value += 1
   end

data/lib/wee/pageless.rb

@@ -0,0 +1,3 @@
+require 'wee/pageless/application'
+require 'wee/pageless/session'
+require 'wee/pageless/request'

data/lib/wee/pageless/application.rb

@@ -0,0 +1,9 @@
+class Wee::PagelessApplication < Wee::Application
+  def request_handler_expired(context)
+    context.response = Wee::RedirectResponse.new(context.request.application_path)
+    # TODO: depends on WEBrick
+    cookie = WEBrick::Cookie.new('SID', '')
+    cookie.max_age = 0
+    context.response.cookies << cookie
+  end
+end

data/lib/wee/pageless/request.rb

@@ -0,0 +1,15 @@
+class Wee::PagelessRequest < Wee::Request
+
+  def build_url(request_handler_id=nil, page_id=nil, callback_id=nil)
+    url = "" 
+    url << @app_path
+    url << ('?' + callback_id) if callback_id
+    return url
+  end
+
+  def parse_path
+    if sid = @cookies.find {|c| c.name == 'SID'}
+      @request_handler_id = sid.value
+    end
+  end
+end

data/lib/wee/pageless/session.rb

@@ -0,0 +1,89 @@
+require 'thread'
+
+# A session class, which does not have a page-store and as such cannot
+# backtrack.
+
+class Wee::PagelessSession < Wee::Session
+  attr_accessor :root_component
+  undef page_store
+
+  attr_accessor :callbacks
+  alias current_callbacks callbacks
+
+  def initialize(&block)
+    Thread.current[:wee_session] = self
+
+    # to serialize the requests we need a mutex
+    @mutex = Mutex.new    
+
+    block.call(self)
+
+    raise ArgumentError, "No root component specified" if @root_component.nil?
+    
+    super()
+  ensure
+    Thread.current[:wee_session] = nil
+  end
+
+  def process_request
+      p @context.request.fields if $DEBUG
+
+      if @context.request.fields.empty?
+
+        # No action/inputs were specified -> render page
+        #
+        # 1. Reset the action/input fields (as they are regenerated in the
+        #    rendering process).
+        # 2. Render the page (respond).
+        # 3. Store the page back into the store
+
+        new_callbacks = Wee::CallbackRegistry.new(Wee::SimpleIdGenerator.new)
+        respond(@context, new_callbacks)                    # render
+        self.callbacks = new_callbacks
+
+      else
+
+        # Actions/inputs were specified.
+        #
+        # We process the request and invoke actions/inputs. Then we generate a
+        # new page view. 
+
+        callback_stream = Wee::CallbackStream.new(self.callbacks, @context.request.fields) 
+
+        if callback_stream.all_of_type(:action).size > 1 
+          raise "Not allowed to specify more than one action callback"
+        end
+
+        live_update_response = catch(:wee_live_update) {
+          catch(:wee_back_to_session) {
+            @root_component.process_callbacks_chain(callback_stream)
+          }
+          nil
+        }
+
+        if live_update_response
+          @context.response = live_update_response
+        else
+          handle_new_page_view(@context)
+        end
+
+      end
+
+  end
+
+  private
+
+  def handle_new_page_view(context)
+    redirect_url = context.request.build_url(context.request.request_handler_id, nil)
+    set_response(context, Wee::RedirectResponse.new(redirect_url))
+  end
+
+  def set_response(context, response)
+    # TODO: depends on WEBrick!
+    response.cookies << WEBrick::Cookie.new('SID', self.id)
+    response.header.delete('Expire')
+    response.header['Pragma'] = 'No-Cache'
+    super
+  end
+
+end