nemo 0.1.0

data/lib/nemo/metaobject/metaobject.rb

@@ -0,0 +1,86 @@
+class Nemo::MetaObject::MetaObject
+
+  attr_accessor :attributes, :baseobject
+
+  def initialize(baseobject, options=Hash.new, &block)
+    @attributes = Array.new
+    @baseobject = baseobject
+    options.each { |k,v| send(k.to_s+'=', v) }
+    collect(&block)
+    refresh_cache
+  end
+
+  def <<(attribute)
+    attribute.metaobject = self
+    @attributes << attribute
+  end
+
+  def [](*symbols)
+    return attribute_of(symbols.first) if symbols.size == 1
+    symbols.collect { |s| attribute_of(s) }
+  end
+
+  def collector_class
+    Nemo::MetaObject::AttributeCollector
+  end
+
+  def collect(&block)
+    collector_class.new(self).collect(&block)
+    @attributes
+  end
+
+  def accept(visitor, &block)
+    visible_attributes.collect{ |a| a.accept(visitor) }.join
+  end
+
+  def attribute_of(symbol)
+    @attributes.find { |a| a.symbol == symbol }
+  end
+
+  def hide_attribute_of(symbol)
+    a = attribute_of(symbol)
+    a.hidden = true if a
+  end
+
+  def hide_attributes_of(*symbols)
+    symbols.each { |s| hide_attribute_of(s) }
+  end
+
+  def hide!(*symbols)
+    hide_attributes_of(*symbols)
+    self
+  end
+
+  def multiple_attributes
+    @attributes.find_all { |a| a.multiple_attribute? }
+  end
+
+  def remove_attribute_of(symbol)
+    @attributes.delete(attribute_of(symbol))
+  end
+
+  def remove_attributes_of(*symbols)
+    symbols.each { |s| remove_attribute(s) }
+  end
+
+  def symbols
+    @attributes.collect { |a| a.symbol }
+  end
+
+  def visible_attributes
+    @attributes.reject { |a| a.hidden? }
+  end
+
+  def commit_cache
+    @attributes.each { |a| a.commit_cache }
+  end
+
+  def refresh_cache
+    @attributes.each { |a| a.refresh_cache }
+  end
+
+  def validate
+    @attributes.collect{ |a| a.validate_cache }.compact
+  end
+
+end

data/lib/nemo/metaobject/validation.rb

@@ -0,0 +1,32 @@
+class Nemo::MetaObject::ValidationError
+
+  attr_accessor :attribute, :error_string
+
+  def initialize(a, error_string)
+    @attribute = a
+    @error_string = error_string
+  end
+
+  def to_s
+    sprintf('%s: %s', @attribute.label, @error_string)
+  end
+
+end
+
+class Nemo::MetaObject::ValidationRule
+
+  extend Nemo::Util::Accessors
+
+  call_accessor :error_string
+  proc_accessor :rule
+
+  def initialize(&block)
+    @error_string = 'not valid'
+    @rule = block
+  end
+
+  def valid?(value)
+    begin Nemo::Util.to_bool(@rule.call(value)) if @rule rescue false end
+  end
+
+end

data/lib/nemo/util.rb

@@ -0,0 +1,31 @@
+# Utility methods and objects
+#
+module Nemo::Util
+
+  module_function
+
+  # Format string as PascalCase (my_var, myVar become MyVar)
+  #
+  def pascal_case(value)
+    value.to_s.split('_').collect{ |w| w[0,1].upcase+w[1..-1] }.join
+  end
+
+  # Converts a value to true or false
+  #
+  # True:: <tt>true, :true, "true", :yes, "yes"</tt>
+  # False:: <tt>false, :false, "false", :no, "no", nil</tt>
+  #
+  # Otherwise (value && true) is applied
+  #
+  def to_bool(value)
+    value = false if [:false, 'false', :no, 'no', nil].include?(value)
+    value = true if [:true, 'true', :yes, 'yes'].include?(value)
+    value && true
+  end
+
+end
+
+require 'nemo/util/accessors'
+require 'nemo/util/blankslate'
+require 'nemo/util/collector'
+require 'nemo/util/date'

data/lib/nemo/util/accessors.rb

@@ -0,0 +1,85 @@
+# Alternate attr_accessor methods
+#
+module Nemo::Util::Accessors
+
+  # Call syntax
+  # 
+  #   class Foo
+  #     extend Nemo::Util::Accessors
+  #     call_accessor :bar
+  #   end
+  #   foo = Foo.new
+  #   foo.bar = 1   # @bar = 1 (standard writer)
+  #   foo.bar(1)    # @bar = 1 (call writer)
+  #   foo.bar       # => 1     (standard reader)
+  # 
+  def call_accessor(*symbols)
+    str = String.new
+    class_eval { attr_accessor(*symbols) }
+    symbols.each do |symbol|
+      str << "
+        def #{symbol}(*args)
+          @#{symbol} = args.first if args.size > 0
+          @#{symbol}
+        end
+      "
+      class_eval(str)
+    end
+  end
+
+  # Boolean syntax
+  # 
+  #   class Foo
+  #     extend Nemo::Util::Accessors
+  #     bool_accessor :bar
+  #   end
+  #   foo = Foo.new
+  #   foo.bar = false # @bar = false (standard writer)
+  #   foo.bar         # @bar = true  (always sets to true)
+  #   foo.bar(false)  # @bar = false (call writer)
+  #   foo.bar?        # => true      (true or false)
+  # 
+  def bool_accessor(*symbols)
+    str = String.new
+    class_eval { attr_accessor(*symbols) }
+    symbols.each do |symbol|
+      str << "
+        def #{symbol}(*args)
+          @#{symbol} = (args.size > 0) ? Nemo::Util.to_bool(args.first) : true
+        end
+        def #{symbol}?
+          Nemo::Util.to_bool(@#{symbol})
+        end
+      "
+      class_eval(str)
+    end
+  end
+
+  # Procedure syntax
+  # 
+  #   class Foo
+  #     extend Nemo::Util::Accessors
+  #     proc_accessor :bar
+  #   end
+  #   foo = Foo.new
+  #   block = Proc.new { 1 }
+  #   foo.bar = block        # @bar = Proc.new { 1 } (standard writer)
+  #   foo.bar { 1 }          # @bar = Proc.new { 1 } (&block writer)
+  #   foo.bar                # @bar => <Proc:x>      (standard reader)
+  #   foo.bar.call           # => 1
+  # 
+  def proc_accessor(*symbols)
+    str = String.new
+    class_eval { attr_accessor(*symbols) }
+    symbols.each do |symbol|
+      str << "
+        def #{symbol}(&block)
+          @#{symbol} = block if block_given?
+          @#{symbol}
+        end
+      "
+      class_eval(str)
+    end
+  end
+
+end

data/lib/nemo/util/blankslate.rb

@@ -0,0 +1,6 @@
+# Minimal object with only three methods: <tt>\_\_id__, \_\_send__ and instance_eval</tt>
+#
+class Nemo::Util::BlankSlate
+  safe_methods = ['__id__', '__send__', 'instance_eval']
+  (instance_methods-safe_methods).each { |m| undef_method m }
+end

data/lib/nemo/util/collector.rb

@@ -0,0 +1,54 @@
+# Collect a list of objects using minimal syntax,
+# used in conjunction with Nemo::Util::Accessors.
+# Use the << or o methods to add an object.
+# All other messages are forwarded to the most recently added object.
+#
+#   class Person
+#     extend Nemo::Util::Accessors
+#     call_accessor :name, :age
+#   end
+#   collector = Nemo::Util::ObjectCollector.new
+#   people = collector.collect do
+#     o Person.new
+#       name 'Kevin'
+#       age 28
+#     o Person.new
+#       name 'Sara'
+#       age 22
+#   end
+#   people.inspect
+#   # => [<Person @age=28, @name="Kevin">, <Person @age=22, @name="Sara">]
+#
+class Nemo::Util::ObjectCollector < Nemo::Util::BlankSlate
+
+  attr_accessor :index_error
+  attr_accessor :objects
+
+  def self.collect(&block)
+    self.new.collect(&block)
+  end
+
+  def initialize
+    @objects = Array.new
+    @index_error = 'no objects defined'
+  end
+
+  def <<(object)
+    @objects << object
+  end
+  
+  def o(object)
+    self << object
+  end
+
+  def collect(&block)
+    instance_eval(&block) if block_given?
+    @objects
+  end
+
+  def method_missing(symbol, *args, &block)
+    raise IndexError, @index_error if @objects.size == 0
+    @objects.last.send(symbol, *args, &block)
+  end
+
+end

data/lib/nemo/util/date.rb

@@ -0,0 +1,41 @@
+class Date
+
+  # Calendar representation of a month. Consists of an
+  # array of weeks, each week an array of 7 days, each day a Date object.
+  # Padded with days showing for previous and next month.
+  #
+  def calendar
+    # months
+    curr_month = Date.new(self.year, self.month, 1)
+    prev_month = (curr_month << 1)
+    next_month = (curr_month >> 1)
+
+    # previous month days
+    prev_days = Array.new
+    prev_in_curr = curr_month.wday
+    ((curr_month-1)-(prev_in_curr-1)).upto(curr_month-1) { |d| prev_days << d }
+
+    # current month days
+    curr_days = Array.new
+    curr_month.upto(next_month-1) { |d| curr_days << d }
+    
+    # next month days
+    next_days = Array.new
+    days = prev_days+curr_days
+    weeks = (days.size.to_f/7).ceil
+    cdays_size = weeks*7
+    next_in_curr = (cdays_size-days.size)
+    next_month.upto(next_month+(next_in_curr-1)) { |d| next_days << d }
+    days += next_days
+    
+    # split into weeks
+    table = Array.new
+    days.each do |day|
+      table << Array.new if table.size == 0 or table.last.size == 7
+      table.last << day
+    end
+
+    table
+  end
+
+end

data/lib/nemo/visitors.rb

@@ -0,0 +1,4 @@
+module Nemo::Visitors; end
+require 'nemo/visitors/visitor'
+require 'nemo/visitors/viewer'
+require 'nemo/visitors/editor'

data/lib/nemo/visitors/editor.rb

@@ -0,0 +1,186 @@
+class Nemo::Visitors::Editor < Nemo::Visitors::Visitor
+
+  attr_accessor :validation_errors, :multiple_attribute_editors
+  bool_accessor :subform
+
+  def initialize(metaobject)
+    super
+    @subform = false
+    @validation_errors = Array.new
+    initialize_subforms
+  end
+
+  def multiattr_class
+    Nemo::Components::MultipleAttributeContainer
+  end
+
+  def calendar_class
+    Nemo::Components::MiniCalendar
+  end
+
+  def initialize_subforms
+    @multiple_attribute_editors = Hash.new
+    @metaobject.multiple_attributes.each do |a|
+      @multiple_attribute_editors[a] = multiattr_class.new(a)
+    end
+  end
+
+  def valid?
+    @validation_errors = @metaobject.validate
+    @validation_errors.empty?
+  end
+
+  def validation_errors?
+    @validation_errors.size > 0
+  end
+
+  def children
+    @multiple_attribute_editors.values
+  end
+
+  def backtrack_state(snapshot)
+    super
+    snapshot.add(self.children)
+  end
+
+  def commit
+    @metaobject.commit_cache
+  end
+
+  def cancel
+    answer nil
+  end
+
+  def save
+    if valid?
+      commit
+      answer @metaobject.baseobject
+    end
+  end
+  
+  def remove_errors(a)
+    @validation_errors.delete_if { |e| e.attribute == a }
+  end
+
+  def call_date_selector(a)
+    current = (a.date_from_cache || Date.today)
+    if date = call( calendar_class.new(current) )
+      a.date_to_cache(date)
+      remove_errors(a)
+      if error = a.validate_cache
+        @validation_errors << error
+      end
+    end
+  end
+
+  def render_buttons
+    r.table_row do
+      r.table_data.colspan(2).with do
+        r.submit_button.id(@metaobject.object_id.to_s+'_save').value('save').callback{ save }
+        r.space
+        r.submit_button.id(@metaobject.object_id.to_s+'_cancel').value('cancel').callback{ cancel }
+      end
+    end
+  end
+
+  def render
+    if subform?
+      render_main
+    else
+      r.form.id(@metaobject.object_id).with { render_main }
+    end
+  end
+
+  def render_label(a, &block)
+    r.table_row do
+      r.table_header(a.label)
+      r.table_data { block ? block.call : r.space }
+    end
+  end
+
+  def render_main
+    r.table do
+      render_validation_errors
+      render_fields
+      render_buttons
+    end
+  end
+
+  def render_fields
+    @metaobject.accept(self)
+  end
+
+  def render_validation_errors
+    if validation_errors?
+      r.table_row { r.table_header.colspan(2).with('The following fields are not valid. Please correct.') }
+      r.table_row { r.table_data.colspan(2).with { @validation_errors.each { |e| r.text('&bull;&nbsp;'); r.encode_text(e.to_s); r.break } } }
+    end
+  end
+
+  def visit_text_attribute(a)
+    return if a.read_only?
+    render_label(a) do
+      if a.multiline?
+        r.textarea.id(a.object_id).callback{ |input| @metaobject[a.symbol].cache = input }.with { r.encode_text(a.cache) }
+      else
+        r.text_input.id(a.object_id).maxlength(a.maxlength).value(a.cache).callback { |input| @metaobject[a.symbol].cache = input }
+      end
+    end
+  end
+
+  def visit_password_attribute(a)
+    return if a.read_only?
+    render_label(a) do
+      r.text_input.id(a.object_id).type('password').maxlength(a.maxlength).value(a.cache).callback { |input| @metaobject[a.symbol].cache = input }
+      r.break
+      r.text_input.id(a.object_id.to_s+'_confirm').type('password').maxlength(a.maxlength).value(a.cache_confirm).callback { |input| @metaobject[a.symbol].cache_confirm = input }
+    end
+  end
+  
+  def visit_date_attribute(a)
+    return if a.read_only?
+    date = a.cache
+    render_label(a) do
+      r.text_input.id(a.object_id).maxlength(a.maxlength).value(a.cache).callback { |input| @metaobject[a.symbol].cache = input }
+      r.space
+      r.nemo_calendar_button.callback { call_date_selector(a) }
+    end
+  end
+
+  def visit_boolean_attribute(a)
+    return if a.read_only?
+    render_label(a) do
+      r.select_list(a.items).id(a.object_id).labels(a.formatted_items).selected([a.cache]).callback do |input|
+        @metaobject[a.symbol].cache = Nemo::Util.to_bool(input.first)
+      end
+    end
+  end
+
+  def visit_multiple_attribute(a)
+    return if a.read_only?
+    render_label(a) do
+      r.render( @multiple_attribute_editors[a] )
+    end
+  end
+
+  def visit_single_relationship_attribute(a)
+    return if a.read_only?
+    render_label(a) do
+      r.select_list(a.items).id(a.object_id).labels(a.formatted_items).selected([a.cache]).callback do |input|
+        @metaobject[a.symbol].cache = input.first
+      end
+    end
+  end
+
+  def visit_multiple_relationship_attribute(a)
+    return if a.read_only?
+    items = a.items
+    size = (items.size < 8) ? items.size : 8
+    render_label(a) do
+      r.select_list(a.items).id(a.object_id).size(size).multiple.labels(a.formatted_items).selected(a.cache).callback do |input|
+        @metaobject[a.symbol].cache = input
+      end
+    end
+  end
+
+end