nemo 0.1.0

data/lib/nemo/examples/person_editor.rb

@@ -0,0 +1,293 @@
+# Web interface for maintaining a list of Person objects
+#
+module Nemo::Examples::PersonEditor; end
+
+# Wrap standard editor in a page
+#
+class Nemo::Examples::PersonEditor::Editor < Nemo::Visitors::Editor
+
+  def render
+    r.page do
+      r.head do
+        r.title('Person Editor')
+        r.link.type('text/css').rel('stylesheet').href('/nemo/person_editor.css')
+        r.style('body { text-align: center }')
+      end
+      super
+    end
+  end
+
+end
+
+# Used by render to display model as a single table
+# with one row per record, versus one table per record.
+#
+class Nemo::Examples::PersonEditor::ListItemViewer < Nemo::Visitors::Viewer
+
+  def render
+    render_fields
+  end
+
+  def render_label(a, &block)
+    r.table_data { block ? block.call : r.space }
+  end
+
+end
+
+# Maintain a list of Person objects
+#
+class Nemo::Examples::PersonEditor::DomainModel
+
+  attr_accessor :persons
+
+  def initialize
+    @persons = Array.new
+  end
+
+  def add_person(person)
+    @persons << person
+  end
+
+  def remove_person(person)
+    @persons.delete(person)
+  end
+
+  def male_persons
+    @persons.find_all { |p| p.sex == true }
+  end
+
+  def female_persons
+    @persons.find_all { |p| p.sex == false }
+  end
+
+end
+
+class Nemo::Examples::PersonEditor::Session < Wee::Session
+
+  # Initialize the Wee session
+  #
+  def initialize
+    super do
+      self.root_component = Nemo::Examples::PersonEditor::Root.new
+      self.page_store = Wee::Utils::LRUCache.new(25) # backtrack up to 25 pages
+    end
+  end
+
+  # Create a new Person
+  #
+  #  person(:name=>'Joe', birthday=Date.new(1950,1,1))
+  #
+  def person(hash=Hash.new)
+    obj = Nemo::Examples::PersonEditor::Person.new
+    hash.each { |k,v| obj.send(k.to_s+'=', v) }
+    obj
+  end
+
+  # Create a new PhoneNumber
+  #
+  #  phone_number(:type=>'home', :number=>'281-328-1328')
+  #
+  def phone_number(hash=Hash.new)
+    obj = Nemo::Examples::PersonEditor::PhoneNumber.new
+    hash.each { |k,v| obj.send(k.to_s+'=', v) }
+    obj
+  end
+
+  # Create a new DomainModel and populate with data.
+  # Define and store in a constant on creation, return existing if already defined.
+  #
+  def domainmodel
+    unless Nemo::Examples::PersonEditor.const_defined?(:Model)
+      Nemo::Examples::PersonEditor.const_set(:Model, Nemo::Examples::PersonEditor::DomainModel.new)
+      father = person(:name=>'Joe',  :sex=>true,  :birthday=>Date.new(1950,1,1))
+      mother = person(:name=>'Jane', :sex=>false, :birthday=>Date.new(1960,1,1))
+      child1 = person(:name=>'Lisa', :sex=>false, :birthday=>Date.new(1982,1,1), :father=>father, :mother=>mother)
+      child2 = person(:name=>'Liza', :sex=>false, :birthday=>Date.new(1978,1,1), :father=>father, :mother=>mother)
+      father.phone_numbers << phone_number(:number=>'281-328-1328', :type=>'home')
+      child1.phone_numbers << phone_number(:number=>'132-813-2813', :type=>'work')
+      [father, mother, child1, child2].each { |p| Nemo::Examples::PersonEditor::Model.add_person(p) }
+    end
+    Nemo::Examples::PersonEditor::Model
+  end
+
+end
+
+# Display a list of persons for editing or deletion
+#
+class Nemo::Examples::PersonEditor::Root < Wee::Component
+
+  attr_accessor :views
+
+  # Create a ListItemViewer for each record
+  #
+  def initialize
+    super
+    @views = Wee::Session.current.domainmodel.persons.collect { |p| viewer_for(p) }
+    @views.each { |view| @children << view }
+  end
+
+  # Enable Wee backtracking for views
+  #
+  def backtrack_state(snapshot)
+    super
+    snapshot.add(self.children)
+  end
+  
+  # Create a new ListItemViewer for a given metaobject
+  #
+  def viewer_for(obj)
+    Nemo::Examples::PersonEditor::ListItemViewer.new(obj.metaobject.hide!(:password, :interests))
+  end
+
+  # Render the page
+  #
+  def render
+    r.html do
+      r.head { r.title('Person Editor') }
+      r.link.type('text/css').rel('stylesheet').href('/nemo/person_editor.css')
+      r.body do
+        r.h1('Person Editor')
+        r.table.width('100%').with do
+          if @views.empty?
+            r.table_row { r.table_header('No persons found.') }
+          else
+            labels = @views.first.metaobject.visible_attributes.collect { |a| a.label }
+            r.table_row { labels.each { |label| r.table_header(label) }; r.table_header { r.space } }
+            @views.each do |view|
+              r.table_row do
+                r.render(view)
+                r.table_header do
+                  r.anchor.callback{ edit(view.metaobject.baseobject) }.with('edit')
+                  r.space; r.text('|'); r.space
+                  r.anchor.callback{ delete(view.metaobject.baseobject) }.with('delete')
+                end
+              end
+            end
+          end
+        end
+        r.break
+        r.anchor.callback{ add_new }.with('create new person')
+      end
+    end
+  end
+  
+  # Add a new Person
+  #
+  def add_new
+    if obj = call( Nemo::Examples::PersonEditor::Editor.new(Nemo::Examples::PersonEditor::Person.new.metaobject) )
+      session.domainmodel.add_person(obj)
+      @views << viewer_for(obj)
+    end
+  end
+  
+  # Edit a Person
+  #
+  def edit(obj)
+    call( Nemo::Examples::PersonEditor::Editor.new(obj.metaobject) ) # will auto-commit
+  end
+  
+  # Delete a Person.
+  # Requires confirmation: Are you sure you want to delete? [OK] [Cancel]
+  #
+  def delete(obj)
+    if call( Nemo::Components::ConfirmDialog.new("Are you sure you want to delete #{obj.name}?") )
+      session.domainmodel.remove_person(obj)
+      session.domainmodel.persons.each do |person|
+        person.father = nil if person.father == obj
+        person.mother = nil if person.mother == obj
+      end
+      @views.delete_if { |view| view.metaobject.baseobject == obj }
+    end
+  end
+
+end
+
+class Nemo::Examples::PersonEditor::PhoneNumber
+
+  attr_accessor :number, :type
+
+  def metaobject
+    Nemo.metaobject_for(self) {
+      text :type
+        label 'Type'
+        maxlength 10
+        required
+
+      text :number
+        label 'Number'
+        maxlength 20
+        required
+    }
+  end
+
+end
+
+class Nemo::Examples::PersonEditor::Person
+
+  INTERESTS = ['Art', 'Music', 'Coffee', 'Ruby']
+
+  attr_accessor :birthday, :father, :interests, :name, :mother, :password, :phone_numbers, :sex
+
+  def initialize
+    @interests = ['Art', 'Music']
+    @password = 'abc123'
+    @phone_numbers = Array.new
+  end
+
+  def age
+    date = (@birthday || Date.today-1)
+    (Date.today-date).to_i/365
+  end
+
+  def metaobject
+    Nemo.metaobject_for(self) {
+      text :name
+        label 'Full Name'
+        maxlength 30
+        required
+      
+      password :password
+        label 'Password'
+        required
+      
+      date :birthday
+        label 'Birthday'
+        format_with { |date| date.strftime('%b %d, %Y') }
+        required
+      
+      text :age
+        label 'Age'
+        read_only
+      
+      boolean :sex
+        label 'Sex'
+        true_item_string 'male'
+        false_item_string 'female'
+      
+      single_relationship :father
+        label 'Father'
+        relationship_to { Wee::Session.current.domainmodel.male_persons }
+        format_with { |each| sprintf('%s (%s)', each.name, each.metaobject[:sex].formatted_value) }
+        nil_item_string 'unknown'
+      
+      single_relationship :mother
+        label 'Mother'
+        relationship_to { Wee::Session.current.domainmodel.female_persons }
+        format_with { |each| sprintf('%s (%s)', each.name, each.metaobject[:sex].formatted_value) }
+        nil_item_string 'unknown'
+        link_action { |item| puts "==== Action was taken ====" }
+      
+      multiple_relationship :interests
+        label 'Interests'
+        relationship_to { INTERESTS }
+        add_validation_rule { |value| value.size > 1 }.
+          error_string('Select at least two items of interest')
+  
+      multiple :phone_numbers
+        label 'Phone#s'
+        base_class Nemo::Examples::PersonEditor::PhoneNumber
+        format_with { |each| sprintf('%s: %s', each.type, each.number) }
+    }
+  end
+
+end

data/lib/nemo/metaobject.rb

@@ -0,0 +1,5 @@
+module Nemo::MetaObject; end
+require 'nemo/metaobject/acollector'
+require 'nemo/metaobject/attributes'
+require 'nemo/metaobject/metaobject'
+require 'nemo/metaobject/validation'

data/lib/nemo/metaobject/acollector.rb

@@ -0,0 +1,79 @@
+# Collect a list of Attribute objects using minimal syntax,
+# Use the attribute methods (#text, #date, #boolean, etc) to add new attributes objects.
+# All other messages will be sent to the most recently added attribute.
+#
+#  collector = Nemo::MetaObject::AttributeCollector
+#  attributes = collector.new(metaobject).collect do
+#    text :name
+#      label 'Full Name'
+#      maxlength 30
+#    date :birthday
+#      label 'Birthday'
+#      read_only
+#   end
+#   attributes.inspect
+#   # => [<TextAttribute @label="Kevin", @maxlength=30>,
+#   #     <DateAttribute @label="Birthday", @read_only=true>]
+#
+class Nemo::MetaObject::AttributeCollector < Nemo::Util::ObjectCollector
+
+  attr_accessor :metaobject
+
+  def initialize(metaobject)
+    super()
+    @metaobject = metaobject
+    @index_error = 'no attributes defined'
+  end
+  
+  # Collects to the metaobject
+  #
+  def <<(attr)
+    @metaobject << attr
+    super
+  end
+
+  # Shortcut for creating attribute class instances
+  #
+  #   self[:text, symbol] => Nemo::MetaObject::TextAttribute.new(symbol)
+  #
+  def [](type, symbol)
+    attr = Nemo::Util.pascal_case(type)+'Attribute'
+    Nemo::MetaObject.const_get(attr).new(symbol)
+  end
+
+  def text(symbol)
+    self << self[:text, symbol]
+  end
+
+  def password(symbol)
+    self << self[:password, symbol]
+  end
+
+  def date(symbol)
+    self << self[:date, symbol]
+  end
+
+  def boolean(symbol)
+    self << self[:boolean, symbol]
+  end
+
+  def multiple(symbol)
+    self << self[:multiple, symbol]
+  end
+  
+  # SingleAttribute is simply a MultipleAttribute with an item_limit of 1
+  #
+  def single(symbol)
+    multiple(symbol)
+    item_limit 1
+  end
+
+  def single_relationship(symbol)
+    self << self[:single_relationship, symbol]
+  end
+
+  def multiple_relationship(symbol)
+    self << self[:multiple_relationship, symbol]
+  end
+
+end

data/lib/nemo/metaobject/attributes.rb

@@ -0,0 +1,282 @@
+class Nemo::MetaObject::Attribute
+
+  extend Nemo::Util::Accessors
+
+  attr_accessor :cache, :metaobject, :symbol, :validation_rules
+  call_accessor :label
+  bool_accessor :hidden, :multiple_attribute, :read_only
+  proc_accessor :format_with
+
+  def initialize(symbol)
+    @format_with = Proc.new { |value| value.nil? ? value : value.to_s }
+    @hidden = false
+    @label = String.new
+    @multiple_attribute = false
+    @read_only = false
+    @symbol= symbol
+    @validation_rules = Array.new
+  end
+
+  def error_class
+    Nemo::MetaObject::ValidationError
+  end
+
+  def rule_class
+    Nemo::MetaObject::ValidationRule
+  end
+
+  def accept(visitor)
+    raise NotImplementedError, 'subclass responsibility'
+  end
+
+  def commit_cache
+    @metaobject.baseobject.send(@symbol.to_s+'=', @cache) unless read_only?
+  end
+
+  def refresh_cache
+    @cache = value
+  end
+
+  def validate_cache
+    error = @validation_rules.find_all { |rule| ! rule.valid?(@cache) }.first
+    error_class.new(self, error.error_string) if error
+  end
+
+  def value
+    @metaobject.baseobject.send(@symbol)
+  end
+
+  def format(value)
+    @format_with ? @format_with.call(value).to_s : value.to_s
+  end
+
+  def formatted_value
+    format(value)
+  end
+
+  def add_required_rule
+    add_validation_rule { |value| ! value.nil? }.error_string('required')
+  end
+  
+  def required
+    add_required_rule
+  end
+  
+  def required?
+    @validation_rules.size > 0
+  end
+
+  def add_validation_rule(&block)
+    @validation_rules << rule_class.new(&block)
+    @validation_rules.last
+  end
+
+end
+
+class Nemo::MetaObject::TextAttribute < Nemo::MetaObject::Attribute
+
+  call_accessor :maxlength
+  bool_accessor :multiline
+
+  def initialize(symbol)
+    super
+    @maxlength = 255
+    @multiline = false
+  end
+
+  def accept(visitor)
+    visitor.visit_text_attribute(self)
+  end
+
+  def add_required_rule
+    add_validation_rule { |value| ! value.to_s.strip.empty? }.error_string('required')
+  end
+
+  def cache
+    @cache.to_s
+  end
+
+end
+
+class Nemo::MetaObject::PasswordAttribute < Nemo::MetaObject::TextAttribute
+
+  attr_accessor :cache_confirm
+
+  def accept(visitor)
+    visitor.visit_password_attribute(self)
+  end
+
+  def refresh_cache
+    super
+    @cache_confirm = @cache
+  end
+
+  def validate_cache
+    return error_class.new(self, 'Confirmation of password is not correct.') if @cache != @cache_confirm
+    super
+  end
+
+end
+
+class Nemo::MetaObject::DateAttribute < Nemo::MetaObject::TextAttribute
+
+  def initialize(symbol)
+    super
+    @format_with = Proc.new { |value| value.to_s }
+  end
+
+  def accept(visitor)
+    visitor.visit_date_attribute(self)
+  end
+
+  def add_required_rule
+    add_validation_rule { |value| date_from_cached(value) && true }
+  end
+  
+  def date_from_cache
+    date_from_cached(@cache)
+  end
+  
+  def date_from_cached(value)
+    begin Date.parse(value.to_s) rescue nil end
+  end
+  
+  def date_to_cache(date)
+    @cache = begin @format_with.call(date) rescue date.to_s end
+  end
+
+  def refresh_cache
+    date_to_cache(value)
+  end
+
+  def commit_cache
+    @metaobject.baseobject.send(@symbol.to_s+'=', date_from_cache) unless read_only?
+  end
+
+end
+
+class Nemo::MetaObject::MultipleAttribute < Nemo::MetaObject::Attribute
+
+  call_accessor :base_class, :item_limit
+  bool_accessor :item_delete
+  proc_accessor :link_action
+  
+  def initialize(symbol)
+    super
+    @multiple_attribute = true
+    @item_limit = 1_000_000
+    @item_delete = true
+  end
+
+  def add_required_rule
+    add_validation_rule { |value| ! value.to_s.empty? }.error_string('required')
+  end
+
+  def accept(visitor)
+    visitor.visit_multiple_attribute(self)
+  end
+
+  def formatted_value
+    value.collect { |item| format(item) }
+  end
+
+  def add_to_cache(item)
+    @cache ||= Array.new
+    @cache << item
+  end
+
+  def refresh_cache
+    @cache = value.collect
+    @cache = @cache[0,@item_limit] if @cache.size > @item_limit
+  end
+
+  def remove_from_cache(item)
+    cache.delete(item)
+  end
+
+end
+
+class Nemo::MetaObject::RelationshipAttribute < Nemo::MetaObject::Attribute
+
+  proc_accessor :link_action, :relationship_to
+
+  def items
+    return @relationship_to.call if @relationship_to
+    Array.new
+  end
+
+  def formatted_items
+    return @relationship_to.call.collect { |i| format(i) } if @relationship_to
+    Array.new
+  end
+
+end
+
+class Nemo::MetaObject::BooleanAttribute < Nemo::MetaObject::RelationshipAttribute
+
+  call_accessor :true_item_string, :false_item_string
+
+  def initialize(symbol)
+    super
+    @true_item_string = 'yes'
+    @false_item_string = 'no'
+    @relationship_to = Proc.new { [true,false] }
+    @format_with = Proc.new { |value| value ? @true_item_string : @false_item_string }
+  end
+
+  def accept(visitor)
+    visitor.visit_boolean_attribute(self)
+  end
+
+end
+
+class Nemo::MetaObject::SingleRelationshipAttribute < Nemo::MetaObject::RelationshipAttribute
+
+  call_accessor :nil_item_string
+
+  def accept(visitor)
+    visitor.visit_single_relationship_attribute(self)
+  end
+
+  def has_nil_item?
+    Nemo::Util.to_bool(@nil_item_string)
+  end
+
+  def items
+    @nil_item_string ? [nil]+super : super
+  end
+
+  def formatted_items
+    @nil_item_string ? [@nil_item_string]+super : super
+  end
+
+end
+
+class Nemo::MetaObject::MultipleRelationshipAttribute < Nemo::MetaObject::RelationshipAttribute
+
+  def accept(visitor)
+    visitor.visit_multiple_relationship_attribute(self)
+  end
+
+  def add_required_rule
+    add_validation_rule { |value| ! value.to_s.empty? }.error_string('required')
+  end
+
+  def add_to_cache(item)
+    @cache ||= Array.new
+    @cache << item
+  end
+
+  def refresh_cache
+    @cache = value.collect
+  end
+
+  def remove_from_cache(item)
+    cache.delete(item)
+  end
+
+  def formatted_value
+    value.collect { |item| format(item) }
+  end
+
+end