ruby_mvc 0.0.1 → 0.0.2

data/lib/ruby_mvc/models/array_table_model.rb

@@ -23,35 +23,103 @@
 #####################################################################
 #++ 
 
-module ShoesMVC
+module RubyMVC
 module Models
 
-  # This class implements the TableModel interface based on
-  # the data being stored in an array.  The elements in the
-  # array must either be a Hash, or they must respond to the
-  # [] accessors for retrieving elements by key and implement
-  # a #keys method for indicating the properties in each row
-  # instance.
+  # This class provides an adapter to expose an array of
+  # hashes or anything else that responds to the #keys, #[]
+  # and #[]= methods as a TableModel instance.
+  #
+  # Note that the keys of the objects in the array will be
+  # requested as symbols and not as any other object type.
 
-  class ArrayTableModel < TableModel
-    def initialize(data)
+  class HashArrayTableModel < TableModel
+    def initialize(data, options = {})
+      raise ArgumentError, "argument not an Array" if !data.is_a? Array
+      super(options)
+
+      @options = options
       @data = data
     end
 
+    def create_rows(count = 1)
+      if f = @options[:row_factory]
+        f.call(count)
+      else
+        r = []
+        t = @options[:row_template] || @data.last
+        count.times { r << t.clone }
+        r
+      end
+    end
+
+    def insert_row(index, row)
+      @data.insert(index, row)
+      super(index, Model.adapt(row, @options))
+    end
+
+    def insert_rows(index, rows)
+      @data.insert(index, *rows)
+      super(index, rows.collect { |r| Model.adapt(r, @options) })
+    end
+    
+    def remove_row(index)
+      row = Model.adapt(@data.delete_at(index), @options)
+      signal_emit("rows-removed", self, index, [ row ])
+      row
+    end
+
+    def remove_rows(index, count)
+      rows = []
+      count.times do
+        rows << Model.adapt(@data.delete_at(index), @options)
+      end
+      signal_emit("rows-removed", self, index, rows)
+      rows
+    end
+
+    def update_row(index, row)
+      @data[index] = row
+      super(index, Model.adapt(row, @options))
+    end
+
+    # The keys used will come from the first element in the
+    # array or be empty if the array is empty.
+
     def keys
-      if @data && @data.size > 0
-        @data.keys
+      if @data.size > 0
+        @data.first.keys
       else
         {}
       end
     end
 
+    def value_for(row, key)
+      @data[row][key.to_sym]
+    end
+
+    def [](row)
+      @data[row]
+    end
+
+    # Iterates over each of the elements in the array and
+    # provides a Model instance to the caller based on the
+    # keys contained in the object itself.
+
     def each(&block)
-      @data.each(&block)
+      return if !block
+
+      @data.each do |x|
+        block.call(Model.adapt(x, @options))
+      end
     end
 
     def each_with_index(&block)
-      @data.each_with_index(&block)
+      return if !block
+
+      @data.each_with_index do |x, i|
+        block.call(Model.adapt(x, @options), i)
+      end
     end
   end
 

data/lib/ruby_mvc/models/keyed_array_table_model.rb

@@ -23,7 +23,7 @@
 #####################################################################
 #++ 
 
-module ShoesMVC
+module RubyMVC
 module Models
 
   class KeyedArrayTableModel < TableModel

data/lib/ruby_mvc/models/model.rb

@@ -0,0 +1,129 @@
+#--
+######################################################################
+#
+# Copyright 2011 Andrew S. Townley
+#
+# Permission to use, copy, modify, and disribute this software for
+# any purpose with or without fee is hereby granted, provided that
+# the above copyright notices and this permission notice appear in
+# all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL
+# WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL THE
+# AUTHORS BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT OR
+# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+# LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#
+# File:     model.rb
+# Created:  Fri 30 Dec 2011 12:46:32 CET
+#
+#####################################################################
+#++ 
+
+module RubyMVC
+module Models
+
+  # This class defines the generic API for models in RubyMVC.
+  # Models expose key/value pairs to other parts of the
+  # system, but they are more than simple Hash instances
+  # because not all properties of a model are always editable.
+
+  class Model
+    include Toolkit::SignalHandler
+    extend Toolkit::SignalHandler::ClassMethods
+
+    # this signal is emitted when any property is changed on
+    # the model.  The arguments are the sender, the old and
+    # the new values
+
+    signal "property-changed"
+
+    # This method is used to use the Model class to adapt any
+    # object that responds to the #keys, #size, #[] and #[]=
+    # methods
+
+    def self.adapt(obj, options = {})
+      return obj if obj.is_a? Model
+      self.new(options.merge({:data => obj}))
+    end
+
+    # The base model is backed by a simple Hash, and supports
+    # specifying the following options for defining which
+    # properties are editable or not.
+
+    def initialize(options = {})
+      @data = options.delete(:data) || {}
+      @options = options
+    end
+
+    # This method is used to provide the property keys of the
+    # model as symbols.
+
+    def keys
+      @data.keys.sort.collect { |k| k.to_sym }
+    end
+
+    # This method is used to retrieve the property key and the
+    # display label for the key to be used by views when
+    # displaying model data.
+
+    def labels
+      @labels = {}
+      self.keys.collect do |k|
+        x = { :key => k.to_sym, :label => k.to_s.capitalize }
+        @labels[x[:key]] = x[:label]
+        x
+      end
+    end
+
+    # This method is used to check whether a property key is
+    # editable or not
+
+    def is_editable?(key)
+      (@options[:editable] || {})[key.to_sym] || true
+    end
+
+    def [](key)
+      @data[key.to_sym]
+    end
+
+    def []=(key, val)
+      k = key.to_sym
+      old = @data[k]
+      @data[k] = val
+
+      if old != val
+        signal_emit("property-changed", self, k, old, val)
+      end
+    end
+
+    def size
+      @data.size
+    end
+
+    # This method is used to iterate over the properties of
+    # the model.  For each property, the key, label and value
+    # are provide as arguments to the block
+
+    def each_label(&block)
+      labels.each do |l|
+        block.call((k = l[:key]), l[:label], @data[k])
+      end
+    end
+
+    # This method is used to retrieve the label for the
+    # specified model key.
+
+    def label_for(key)
+      if !@labels
+        labels
+      end
+      @labels[key.to_sym]
+    end
+  end
+
+end
+end

data/lib/ruby_mvc/models/table_model.rb

@@ -23,19 +23,116 @@
 #####################################################################
 #++ 
 
-module ShoesMVC
+module RubyMVC
 module Models
 
-  # This class defines the behavior of a base TableModel API
-  # that is used by the TableView class.  The model represents
-  # an ordered set of data rows which are "square" in that
-  # they are expected to all have the same number of columns.
-  #
-  # Logically, each of the elements in the table model is a
-  # row instance that provides keyed property access to the
-  # data in the model based on the [] method.
+  # The TableModel class expands the concepts of the Model
+  # class to a number of related rows with the same properties
+  # defined for the model.
 
-  class TableModel
+  class TableModel < Model
+    # This signal is triggered when contiguous rows are
+    # inserted into the model.  The arguments are the sender
+    # model, the insertion index and the row models that were
+    # inserted.
+    
+    signal "rows-inserted"
+
+    # This signal is triggered when contiguous rows are
+    # removed from the model.  The arguments are the index at
+    # which the removal took place and the row models that
+    # were removed from the model.
+
+    signal "rows-removed"
+
+    # This signal is triggered when an existing row has been
+    # changed.  The arguments are the sender, the index and
+    # the changed row model
+
+    signal "row-changed"
+
+    # This method is used to create a number of row data
+    # elements that will be inserted into the model at the
+    # specified location using the #insert_row or #insert_rows
+    # method.
+    #
+    # The result is an array of row data instances in whatever
+    # format is deemed suitable for the model instance to
+    # create.
+
+    def create_rows(count = 1)
+    end
+
+    # This method is used to insert a single row into the
+    # model at the given row index.
+
+    def insert_row(index, row)
+      signal_emit("rows-inserted", self, index, [ row ])
+    end
+
+    # This method is used to insert an array of row objects
+    # into the model at the specified index
+
+    def insert_rows(index, rows)
+      signal_emit("rows-inserted", self, index, rows)
+    end
+
+    # This method is used remove a single row from the model
+    # and return a reference to the row model removed to the
+    # caller.
+    #
+    # Note, the derived classes are responsible for emitting
+    # the appropriate signal since the data access is opaque
+    # to the base class.
+
+    def remove_row(index)
+    end
+
+    # This method is used remove multiple rows from the model
+    # and return a reference to the row models removed to the
+    # caller.
+    #
+    # Note, the derived classes are responsible for emitting
+    # the appropriate signal since the data access is opaque
+    # to the base class.
+
+    def remove_rows(index, count)
+    end
+
+    # This method is used to update the specified row in the
+    # model and ensure that the appropriate notifications for
+    # all linked views are sent.
+
+    def update_row(index, row)
+      signal_emit("row-changed", index, row)
+    end
+
+    # This method will iterate over each of the rows and
+    # provide the caller with a reference to the row instance,
+    # which is also conformant with the Model API
+
+    def each(&block)
+    end
+
+    # This method will iterate over each of rows and provide
+    # the caller with a reference to the row instance as a
+    # model and the index of the row.
+
+    def each_with_index(&block)
+    end
+
+    # This method allows direct access into the model rows, in
+    # row-major order for the specified, zero-based index and
+    # property key
+
+    def value_for(row, key)
+    end
+
+    # This method is used to retrieve the model instance for
+    # the given row index
+
+    def [](idx)
+    end
   end
 
 end

data/lib/ruby_mvc/models/view_model_template.rb

@@ -0,0 +1,140 @@
+#--
+######################################################################
+#
+# Copyright 2011 Andrew S. Townley
+#
+# Permission to use, copy, modify, and disribute this software for
+# any purpose with or without fee is hereby granted, provided that
+# the above copyright notices and this permission notice appear in
+# all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL
+# WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
+# WARRANTIES OF MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL THE
+# AUTHORS BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT OR
+# CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+# LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT,
+# NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+# CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#
+# File:     view_model_template.rb
+# Created:  Mon 12 Dec 2011 06:30:57 CST
+#
+#####################################################################
+#++ 
+
+module RubyMVC
+module Models
+
+  # This class provides a proxy for Model instances that
+  # allows them to control the visibility of which properties
+  # are exposed for a given view.  ViewModelTemplate instances can
+  # be reused across view instances where the same properties
+  # are to be exposed.
+  #
+  # The ViewModelTemplate class implements the same interface as
+  # Model instances so that they can be used as drop-in
+  # replacements everywhere a model instance can be used.
+  #
+  # The key difference is that the ViewModelTemplate exists outside
+  # of any particular model instances, allowing the same view
+  # binding to work for numerous concrete model instances,
+  # effectively speifying the template through which the model
+  # may be accessed.
+  
+  class ViewModelTemplate
+    attr_accessor :title
+
+    # When the ViewModelTemplate is initialized, it requires a set
+    # of options and/or an optional initializer block that is
+    # executed within the scope of the newly created instance.
+
+    def initialize(options = {}, &block)
+      @options = options
+      @labels = []
+      @options[:editable] ||= {}
+      @options[:properties] ||= []
+      self.instance_eval(&block) if block
+    end
+
+    def keys
+      @options[:properties]
+    end
+
+    # Implement the Model#labels method in terms of the
+    # template definition
+
+    def labels
+      @labels
+    end
+
+    # Implement the Model#is_editable? method in terms of the
+    # template definition.  If the template doesn't further
+    # restrict the behavior, the model's definition is used
+    # instead.
+
+    def is_editable?(key)
+      k = key.to_sym
+      if @options[:editable].has_key? k
+        @options[:editable][k]
+      else
+        true
+      end
+    end
+
+    # This method is used to mark a property key editable or
+    # not through the view.  This method does not impact the
+    # editability of the underlying model
+
+    def editable(key, val = true)
+      @options[:editable][key.to_sym] = val
+    end
+
+    # This method is used to mark a property visible or not
+    # through the view.
+
+    def property(key, options = {})
+      puts "options: #{options.inspect}"
+      key = key.to_sym
+      
+      if false == options[:show]
+        show = false
+      else
+        show = true
+      end
+
+      editable(key, false) if false == options[:editable]
+
+      if show && !@options[:properties].include?(key)
+        @options[:properties] << key
+        l = options[:alias] || key.to_s.capitalize
+        @labels << options.merge({ :key => key, :label => l })
+      elsif !show
+        @options[:properties].delete(key)
+        @labels.delete_if do |k|
+          k[:key] == key
+        end
+      end
+    end
+
+    # This method is used to apply the template to a specific,
+    # concrete model instance, creating a clone of the
+    # template in the process so that multiple different
+    # models can be used with the same template definition.
+
+    def apply(model)
+      @model = model
+      self.clone
+    end
+
+    def method_missing(m, *args, &block)
+      if @model
+        @model.send(m, *args, &block)
+      else
+        super
+      end
+    end
+  end
+
+end
+end