rtml 2.0.3 → 2.0.4

data/lib/rtml/test/unit.rb

@@ -0,0 +1,13 @@
+require 'test/unit'
+
+class Test::Unit::TestCase
+  def assert_tml_resembles(expected_hash, tml)
+    assert Rtml::Test::ResemblanceTest.new(expected_hash, target).pass?,
+           "Expected #{expected_hash.inspect} to resemble:\n\n#{tml}"
+  end
+
+  def assert_tml_not_resemble(expected_hash, tml)
+    assert !Rtml::Test::ResemblanceTest.new(expected_hash, target).pass?,
+           "Expected #{expected_hash.inspect} not to resemble:\n\n#{tml}"
+  end
+end

data/lib/rtml/test/variable_scope.rb

@@ -0,0 +1,146 @@
+class Rtml::Test::VariableScope
+  class Variable
+    attr_reader :type, :perms, :format
+    attr_reader :value
+    attr_reader :name
+
+    def initialize(name, options = {})
+      options.stringify_keys!.reverse_merge(default_options)
+      @name = name.to_s
+      %w(type perms format).each do |key|
+        instance_variable_set("@#{key}", options[key].to_s) if options.key?(key)
+        instance_variable_set("@#{key}", default_options[key]) unless instance_variable_get("@#{key}")
+      end
+      self.value = options.delete('value') if options.key?('value')
+    end
+
+    # TODO: implement :format option
+    def perform_operation(op)
+      if op.keys?(:lo, :op) && op[:op] == 'number' # list length
+        raise Rtml::Errors::VariableError, "No :ro expected" if op.key?(:ro)
+        self.value = (op[:lo].to_s.split(/\;/).length)
+      elsif op.key?(:lo) && !op.keys?(:op, :ro)          # assignment
+        self.value = op[:lo]
+      elsif op.keys?(:lo, :op, :ro)                   # operation
+        self.value = case op[:op]
+          when 'plus'   then cast_value(op[:lo]) + cast_value(op[:ro])
+          when 'minus'  then cast_value(op[:lo]) - cast_value(op[:ro])
+          when 'format' then raise Rtml::Errors::VariableError, "setvar[op=format] not yet implemented"
+          when 'item'   then op[:lo].to_s.split(/\;/)[op[:ro].to_i]
+          else raise Rtml::Errors::VariableError, "Unknown operation: #{op[:op].inspect}"
+        end
+      else
+        raise Rtml::Errors::VariableError, "Expected :lo, :op, and :ro; or just :lo for assignment"
+      end
+    end
+
+    def value=(value)
+      @value = cast_value(value)
+    end
+
+    def cast_value(value)
+      case type
+        when 'integer' then value.to_i
+        when 'string' then value.to_s
+        when 'opaque' then value.to_s
+        when 'date' then value.kind_of?(DateTime) ? value : DateTime.parse(value.to_s)
+        else raise "Unknown type: #{type.inspect}"
+      end
+    end
+
+    private
+    def default_options
+      {'type' => 'string', 'perms' => 'rwxrw', 'format' => nil, 'value' => ''}
+    end
+  end
+
+  def initialize
+    @variables = {}
+  end
+
+  # Returns a "snapshot" of this variable scope's current state. All known variables are returned, along with their
+  # types, values, etc.
+  def snapshot
+    @variables.values.collect do |variable|
+      { :type => variable.type, :perms => variable.perms, :format => variable.format, :name => variable.name,
+        :value => variable.value }
+    end
+  end
+
+  def inspect
+    @variables.collect do |name, variable|
+      "#{name}={value:#{variable.value.inspect} type:#{variable.type.inspect} perms:#{variable.perms.inspect} format:#{variable.format.inspect}}"
+    end.join("; ")
+  end
+
+  # Accepts a hash according to the TML rules (for example, keys should be :lo, :op, :ro)
+  def true_condition?(condition)
+    condition.reverse_merge!(:op => 'equal')
+    raise Rtml::Errors::VariableError, "Expected :lo, :op and :ro" unless condition.keys?(:lo, :op, :ro)
+    lo = literal_value(condition[:lo])
+    ro = literal_value(condition[:ro])
+    case condition[:op]
+      when 'equal'         then lo == ro
+      when 'not_equal'     then lo != ro
+      when 'less'          then lo < ro
+      when 'less_or_equal' then lo <= ro
+      when 'contains'      then lo =~ /#{Regexp::escape ro}/
+      else raise Rtml::Errors::VariableError, "Invalid operation: #{condition[:op].inspect}"
+    end
+  end
+
+  def update(name, value)
+    find_variable(name).value = literal_value(value)
+  end
+
+  # Accepts a hash, and updates each listed variable with the values in the hash.
+  def update_with(hash)
+    hash.each do |name, value|
+      update(name, value)
+    end
+  end
+
+  def literal_value(value_or_variable_name)
+    if value_or_variable_name.kind_of?(String) && value_or_variable_name =~ /^tmlvar\:/
+      value(value_or_variable_name[7..-1])
+    else
+      value_or_variable_name
+    end
+  end
+  
+  def perform_operation_on(variable_name, operation)
+    operation[:lo] = literal_value(operation[:lo]) if operation.key?(:lo)
+    operation[:ro] = literal_value(operation[:ro]) if operation.key?(:ro)
+    find_variable(variable_name).perform_operation(operation)
+  end
+
+  def exist?(name)
+    name = name.to_s unless name.kind_of?(String)
+    @variables[name]
+  end
+
+  def find_variable(name)
+    name = name.to_s unless name.kind_of?(String)
+    @variables[name] || raise(Rtml::Errors::VariableError, "Undeclared variable #{name.inspect}")
+  end
+
+  def declare_variable(name, options = {})
+    name = name.to_s unless name.kind_of?(String)
+    if @variables.key?(name)
+      raise Rtml::Errors::VariableError, "Already declared variable #{name.inspect} (it's a #{@variables[name].type})"
+    end
+    @variables[name] = Variable.new(name, options)
+  end
+
+  def variable_names
+    @variables.keys
+  end
+
+  def value(name)
+    find_variable(name).value
+  end
+
+  alias_method :[], :value
+  alias_method :[]=, :update
+  alias_method :assign, :update
+end

data/lib/rtml/version.rb

@@ -2,7 +2,7 @@ module Rtml
   module VERSION
     MAJOR = 2
     MINOR = 0
-    TINY  = 3
+    TINY  = 4
     
     STRING = (defined?(PRE) ? [MAJOR, MINOR, TINY, PRE] : [MAJOR, MINOR, TINY]).join('.')
   end

data/lib/rtml/widget.rb

@@ -1,3 +1,5 @@
+require 'rtml/assigns'
+
 # The Widget is the driving force behind RubyTML. It is interaction with Widgets of all shapes and sizes that produces
 # a document model and, finally, the TML document itself. A Widget is so named because it is a generic class that can
 # be made to encapsulate any desired functionality. The Rtml::Widget base class takes care of interfacing content
@@ -35,6 +37,8 @@
 #   ruby script/generate widget my_widget [entry_point1 entry_point2 . . .]
 #
 class Rtml::Widget
+  include Rtml::Assigns
+
   # These are the accessors that RDoc uses to define what a particular RTML-specific attribute maps to.
   #
   # There are 3 kinds of accessors:
@@ -60,17 +64,22 @@ class Rtml::Widget
   class_inheritable_array :targets
   class_inheritable_array :shared_variables
   class_inheritable_array :entry_points
+  class_inheritable_array :rtml_protected_instance_variables
   read_inheritable_attribute(:targets)          || write_inheritable_attribute(:targets,          [])
   read_inheritable_attribute(:shared_variables) || write_inheritable_attribute(:shared_variables, [])
   read_inheritable_attribute(:entry_points)     || write_inheritable_attribute(:entry_points,     [])
+  read_inheritable_attribute(:rtml_protected_instance_variables) || write_inheritable_attribute(:rtml_protected_instance_variables, %w(
+    @document @parent @source_type
+  ))
   attr_reader :parent
   attr_reader :source_type
   extend Rtml::WidgetCore::ClassMethods
 
   def validate_parent(*options)
     options = options.flatten.collect { |o| o.kind_of?(String) ? o : o.to_s }
-    unless options.include?(parent.name)
-      raise ArgumentError, "Expected parent to be one of #{options.to_sentence(:language => :en)}; found #{parent.name}"
+    unless options.include?(parent.name) || options.include?(parent.class.name) ||
+            ((options.include?(:document) || options.include?('document')) && parent.kind_of?(Rtml::Document))
+      raise ArgumentError, "Expected parent to be one of #{options.to_sentence}; found #{parent.name}"
     end
   end
 
@@ -83,21 +92,24 @@ class Rtml::Widget
     @widget_id ||= (@@widget_id_tracker += 1)
   end
 
+  # Any method other than one of this widget's entry points will be delegated into #parent.
+  # The parent's methods are not known until runtime, and it's extraordinarily slow to generate
+  # delegation for those methods on the fly. Method_missing is the happy middle ground.
+  def method_missing(name, *args, &block)
+    name = name.to_s unless name.kind_of?(String)
+    return parent.send(name, *args, &block) unless entry_points.include?(name) || !parent.respond_to?(name)
+    # FIXME: Why does super raise an ArgumentError("no id given")?
+    raise NoMethodError, "Method missing: #{name}"
+  end
+
+  def respond_to?(*a, &b)
+    super || parent.respond_to?(*a, &b)
+  end
+
   def initialize(parent)
     @parent = parent
     set_source_type!
     parent.widget_instances << self
-    # proxy parent methods into parent, unless they exist for widget already
-    singleton_class = (class << self; self; end)
-    (@parent.public_methods - self.public_methods).each do |proxy_method|
-      # don't delegate entry points -- this addresses the infinite loop issue in which calling a method that's been
-      # defined as an entry point but hasn't been created in the Widget itself would recurse back into the parent
-      # object forever.
-      unless entry_points.include? proxy_method
-        singleton_class.send(:delegate, proxy_method, :to => :parent)
-      end
-    end
-
 
     self.class.shared_variables.each do |sv|
       unless @parent.instance_variable_get("@#{sv[:name]}")
@@ -144,7 +156,7 @@ class Rtml::Widget
       when Rtml::Document
         @source_type = :document
       else
-        @source_type = parent.name.to_sym
+        @source_type = parent.respond_to?(:name) ? parent.name.to_sym : parent.class.name.to_sym
     end
   end
 end

data/lib/rtml/widget_core/class_methods.rb

@@ -106,10 +106,13 @@ module Rtml::WidgetCore::ClassMethods
 
   # Goes through each of the targets of this Widget, looks up its mapping in Rtml::Widgets.mapping, and calls
   # proxy_module.append_features(mapping) for each of those mappings.
+  #
   def reinclude_proxy_module
     targets.each do |target|
       Rtml::Widgets.mapping(target).imbue(proxy_module)
     end
+    # FIXME: Um... Maybe this is fine, but it seems out of place.
+    Rtml::Widgets.bases.each { |base| Rtml::Widgets.add_proxies_to_base(base) }
   end
 
   # Specifies entry points, which are names of methods that can be called from the targets to invoke this Widget.
@@ -119,10 +122,9 @@ module Rtml::WidgetCore::ClassMethods
   #
   def entry_point(*names)
     names.each do |name|
-      name = name.to_s
+      #name = name.to_sym unless name.kind_of?(Symbol)
       unless entry_points.include?(name)
-        entry_points << name
-        add_entry_point(name)
+        entry_points << add_entry_point(name)
       end
     end
   end
@@ -135,6 +137,7 @@ module Rtml::WidgetCore::ClassMethods
 #      raise Rtml::Errors::RulesViolationError,
 #            "Widget entry point #{entry_point} cannot be defined because it already exists!"
 #    end
+    #entry_point = entry_point.to_sym unless entry_point.is_a?(Symbol)
     entry_point = entry_point.to_s if entry_point.is_a?(Symbol)
     
     enter_from_hash = "#{entry_point}_from_hash"
@@ -174,6 +177,7 @@ module Rtml::WidgetCore::ClassMethods
     end_code
     proxy_module.class_eval code, __FILE__, line
     reinclude_proxy_module
+    entry_point
   end
 
   # Returns true if the specified class is a valid target of this Widget
@@ -181,7 +185,7 @@ module Rtml::WidgetCore::ClassMethods
     if base.respond_to?(:name)
       name = base.name.underscore.sub(/^.*\//, '')
       targets.each do |target|
-        if base.kind_of?(ActiveRecord::Base) # it's an instance, so we should check the tag name, not the class name
+        if base.kind_of?(ActiveRecord::Base) || base.kind_of?(Rtml::DocumentModelObject) # it's an instance, so we should check the tag name, not the class name
           return true if target == base.name
         else
           return true if target == name

data/lib/rtml/widget_core/widget_accessor_instance_methods.rb

@@ -5,13 +5,13 @@ module Rtml::WidgetCore::WidgetAccessorInstanceMethods
 
   delegate :class_widget_proxies, :class_widget_entry_points, :to => 'self.class'
 
-  def singleton_widgets; (class << self; self; end).class_widgets end
-  def singleton_widget_proxies; (class << self; self; end).class_widget_proxies end
-  def singleton_widget_entry_points; (class << self; self; end).class_widget_entry_points end
+  def singleton_widgets; (class << self; self; end).class_widgets ||= [] end
+  def singleton_widget_proxies; (class << self; self; end).class_widget_proxies ||= [] end
+  def singleton_widget_entry_points; (class << self; self; end).class_widget_entry_points ||= [] end
 
-  def widgets; singleton_widgets + class_widgets end
-  def widget_proxies; singleton_widget_proxies + class_widget_proxies end
-  def widget_entry_points; singleton_widget_entry_points + class_widget_entry_points end
+  def widgets; singleton_widgets + (self.class_widgets ||= []) end
+  def widget_proxies; singleton_widget_proxies + (self.class_widget_proxies ||= []) end
+  def widget_entry_points; singleton_widget_entry_points + (self.class_widget_entry_points ||= []) end
 
   alias class_widget_methods     class_widget_entry_points
   alias singleton_widget_methods singleton_widget_entry_points

data/lib/rtml/widgets.rb

@@ -10,6 +10,9 @@
 
 module Rtml::Widgets
   class << self
+    # A list of all objects that have included Rtml::Widgets, marking them as compatible with Widgets.
+    attr_reader :bases
+
     # The Widget mapping is a hash whose keys are symbols and whose values are instances of Module. The symbols
     # represent either RTML models or TML tag names, while the Modules represent the proxy from the representation's
     # class into the Widget itself. This way, the Module can be mixed-in with the target, and Widgets added after
@@ -25,12 +28,14 @@ module Rtml::Widgets
     #   target_instance.say_hi        # => hello
     #   target_instance.say_bye       # => goodbye
     def mapping(key)
+      name = (key.respond_to?(:name) ? key.name : key.to_s).underscore
       @widget_mapping ||= {}
-      @widget_mapping[key.to_s] ||= Rtml::WidgetCore::WidgetProxy.new
+      @widget_mapping[name] ||= Rtml::WidgetCore::WidgetProxy.new
     end
 
     # Returns all Widgets which affect the specified target.
     def affecting(target)
+      target = (target.respond_to?(:name) ? target.name : target.to_s).underscore
       mapping(target).proxied_widgets
     end
 
@@ -44,14 +49,28 @@ module Rtml::Widgets
       base.send(:extend,  Rtml::WidgetCore::WidgetAccessorClassMethods)
       load_widgets
       add_proxies_to_base(base)
+
+      base.class_eval do
+        if defined?(initialize)
+          def initialize_with_widgets(*args, &block)
+            initialize_without_widgets(*args, &block)
+            Rtml::Widgets.add_proxies_to_base(self)
+          end
+          alias_method_chain :initialize, :widgets
+        else
+          def initialize
+            Rtml::Widgets.add_proxies_to_base(self)
+          end
+        end
+      end
     end
 
     # Mixes the various proxy methods into the specified base.
     def add_proxies_to_base(base)
-      target_name = base.respond_to?(:name) ? base.name.underscore.sub(/^.*\//, '') : nil
+      target_name = base.respond_to?(:name) ? (base.name || base.class.name).underscore.sub(/^.*\//, '') : nil
       (@widget_mapping ||= {}).each do |key, mixin|
         klass = base
-        if base.kind_of? ActiveRecord::Base
+        if base.kind_of?(ActiveRecord::Base) || base.kind_of?(Rtml::DocumentModelObject)
           klass = class << base; self; end
         end
 

data/lib/rtml_routes.rb

@@ -1,3 +1,3 @@
 ActionController::Routing::Routes.draw do |map|
-  map.connect_rtml :controller => 'rtml'
+  map.connect_rtml :controller => 'rtml', :no_index => true
 end

data/rails_generators/rtml/rtml_generator.rb

@@ -59,6 +59,9 @@ class RtmlGenerator < Rails::Generator::Base
       20100127173146_add_parent_type_to_rtml_dom_elements.rb
       20100208114234_create_rtml_states.rb
       20100303021609_add_x_and_y_to_rtml_instructions.rb
+      20100513165226_add_options_to_rtml_documents.rb
+      20100513165242_remove_dom_elements_mirror.rb
+      20100513165249_remove_dom_properties_mirror.rb
     )
 
 end

data/rails_generators/rtml/templates/db/migrate/20100513165226_add_options_to_rtml_documents.rb

@@ -0,0 +1,9 @@
+class AddOptionsToRtmlDocuments < ActiveRecord::Migration
+  def self.up
+    add_column :rtml_documents, :options, :text
+  end
+
+  def self.down
+    remove_column :rtml_documents, :options
+  end
+end

data/rails_generators/rtml/templates/db/migrate/20100513165242_remove_dom_elements_mirror.rb

@@ -0,0 +1,16 @@
+class RemoveDomElementsMirror < ActiveRecord::Migration
+  def self.up
+    drop_table :rtml_dom_elements
+  end
+
+  def self.down
+    create_table :rtml_dom_elements do |t|
+      t.string :name
+      t.string :type, :default => 'Rtml::Dom::Element'
+
+      t.references :parent
+      t.references :document
+      t.timestamps
+    end
+  end
+end

data/rails_generators/rtml/templates/db/migrate/20100513165249_remove_dom_properties_mirror.rb

@@ -0,0 +1,16 @@
+class RemoveDomPropertiesMirror < ActiveRecord::Migration
+  def self.up
+    drop_table :rtml_dom_properties
+  end
+
+  def self.down
+    create_table :rtml_dom_properties do |t|
+      t.string :name
+      t.text :value
+      t.string :type
+
+      t.references :element
+      t.timestamps
+    end
+  end
+end

data/rails_generators/rtml/templates/lib/tasks/rtml.rake

@@ -5,9 +5,9 @@ end
 
 # This is a tiny bit faster than the bootstrapper because we can skip some of the dependencies, which matters a lot more
 # in potentially-often-run rake tasks.
-module Rtml; module WidgetCore; end; end
 require 'rtml'
 unless defined?(Rtml::Widget)
+  module Rtml; module WidgetCore; end; end
   require 'rtml/widget_core/class_methods'
   require 'rtml/widget'
 end