rtml 2.0.3 → 2.0.4

data/do_profile.rb

@@ -0,0 +1,15 @@
+if ENV["_"] =~ /ruby\-prof/
+  if ARGV.empty?
+    ARGV.concat Dir[File.join(File.dirname(__FILE__), 'spec/**/*_spec.rb')]
+  end
+  ARGV.each do |fi|
+    next unless File.file? fi
+    load fi
+  end
+else
+  puts <<-end_banner
+    This script will use ruby-prof to run the specs.
+
+    Usage: ruby-prof do_profile.rb
+  end_banner
+end

data/lib/extensions/action_controller/response.rb

@@ -8,23 +8,5 @@ module ActionController
       end
       body.valid_tml?
     end
-
-    # Verifies that the produced TML resembles the given structure. See +Rtml::Rules::DomValidation#validate_tml_dom+
-    # for more information.
-    def tml_should_resemble(structure)
-      body.validate_tml_structure(structure)
-    end
-
-    # Verifies that the produced TML does NOT resemble the given structure.
-    # See +Rtml::Rules::DomValidation#validate_tml_dom+ for more information.
-    def tml_should_not_resemble(structure)
-      inspected = structure.inspect
-      begin
-        body.validate_tml_structure(structure)
-      rescue
-        return true
-      end
-      raise Rtml::Errors::ProcessingError, "TML was expected not to resemble #{inspected}, but it did!", caller
-    end
   end
 end

data/lib/extensions/action_controller/routing/route_set.rb

@@ -9,32 +9,42 @@ module ActionController
         # options, the /index.tml path will be updated to reflect the new options.
         #
         # To use, just add the following to your /config/routes.rb file:
-        # map.connect_rtml :controller => "start_page"
+        #   map.connect_rtml :controller => "start_page"
+        #
+        # Note that you should do this for each RTML controller in your application. To prevent
+        # overriding the /index.tml page, pass :no_index => true:
+        #   map.connect_rtml :controller => "another_page", :no_index => true
         #
         def connect_rtml(options = {})
-          make_rtml_connection('/:controller/:action.:format', '/rtml/index.rtml')
-          make_rtml_connection('/:controller/:action.:id.:format', '/rtml/index.1.rtml')
-          make_rtml_connection('/:controller/:action/:id', '/rtml/index/1')
+          no_index = options.delete(:no_index)
+          
+          make_rtml_connection('/rtml/:action.:format', '/rtml/index.rtml', :controller => 'rtml')
+          make_rtml_connection('/rtml/:action.:id.:format', '/rtml/index.1.rtml', :controller => 'rtml')
+          #make_rtml_connection('/:controller/:action/:id', '/rtml/index/1')
 
-          connect_options = !options.empty?
-          ActionController::Routing::Routes.routes.each do |route|
-            segs = route.segments.to_s[0...-1]
-            if segs =~ /^\/index.tml(\/|)$/ && connect_options
-              route.requirements.merge! options.reverse_merge(:format => 'rtml')
-              connect_options = false
-            end
+          unless options.empty? || no_index
+            connect '/index.tml', options.reverse_merge(:format => 'rtml')
           end
-
-          if connect_options
-            connect '/index.tml', options.reverse_merge(:format => 'rtml') unless options.empty?
+          
+          if options[:controller]
+            controller = options[:controller]
+            make_rtml_connection("/#{controller}/:action.:format",     "/#{controller}/index.rtml",   :controller => controller)
+            make_rtml_connection("/#{controller}/:action.:id.:format", "/#{controller}/index.1.rtml", :controller => controller)
           end
         end
 
         private
-        def make_rtml_connection(connection, example)
-          ActionController::Routing::Routes.recognize_path(example)
-        rescue ActionController::RoutingError
-          connect connection
+        def route_exists?(path)
+          path = "/#{path}" unless path[0] == ?/
+          ActionController::Routing::Routes.routes.each do |route|
+            segs = route.segments.to_s
+            return true if segs =~ /^#{Regexp::escape path}(\/|)$/
+          end
+          false
+        end
+
+        def make_rtml_connection(connection, example, options = {})
+          connect connection, options unless route_exists?(example)
         end
       end
     end

data/lib/extensions/hpricot/doc.rb

@@ -1,5 +1,5 @@
-module Hpricot
-  class Doc
-    include Rtml::ReverseEngineering::Simulator::Casting
+class Hpricot::Doc
+  def to_tml_simulator
+    Rtml::Test::Simulator.new(self)
   end
 end

data/lib/extensions/hpricot/elem.rb

@@ -1,5 +1,5 @@
-module Hpricot
-  class Elem
-    include Rtml::ReverseEngineering::Simulator::Casting
+class Hpricot::Elem
+  def to_tml_simulator
+    Rtml::Test::Simulator.new(self)
   end
 end

data/lib/extensions/string.rb

@@ -1,6 +1,5 @@
 class String
   include Rtml::Rules::DomValidation
-  include Rtml::ReverseEngineering::Simulator::Casting
 
   def to_controller
     camel = self.camelize
@@ -14,22 +13,7 @@ class String
     true
   end
 
-  def validate_tml_structure(structure)
-    validate_tml_dom(self, structure)
-    true
-  end
-
-  # Verifies that the produced TML does NOT resemble the given structure.
-  # See +Rtml::Rules::DomValidation#validate_tml_dom+ for more information.
-  def tml_should_not_resemble(structure)
-    inspected = structure.inspect
-    begin
-      validate_tml_dom(self, structure)
-    rescue
-      return true
-    end
-    raise Rtml::ProcessingError, "TML was expected not to resemble #{inspected}, but it did!", caller
+  def to_tml_simulator
+    Rtml::Test::Simulator.new(self)
   end
-
-  alias tml_should_resemble validate_tml_structure
 end

data/lib/rtml.rb

@@ -68,18 +68,6 @@ module Rtml
         controller.rtml_actions.concat new_methods
 
         new_methods.each do |method_name|
-          unless helpers.hidden_action?(method_name)
-            helpers.class_eval(<<-end_code, __FILE__, __LINE__+1)
-              def #{method_name}_with_ivars
-                copy_ivars_from(controller)
-                # Give rtml actions access to the controller's view helpers
-                (class << self; self; end).send(:include, controller.response.template.helpers)
-                #{method_name}_without_ivars
-              end
-            end_code
-
-            helpers.send(:alias_method_chain, method_name, :ivars)
-          end
           unless helpers.hidden_action?(method_name) || controller.instance_methods.include?(method_name)
             controller.add_rtml_proxy_action(method_name)
           end

data/lib/rtml/assigns.rb

@@ -0,0 +1,32 @@
+# Included into most RTML classes
+module Rtml::Assigns
+  # Returns all instance variables EXCEPT those returned by #protected_instance_variables or
+  # #rtml_protected_instance_variables. If one of those methods doesn't exist, it is ignored.
+  #
+  # The returned instance variables are mapped to a hash so that they are ready to be passed
+  # (for example) into ActionController#render as a value for the :assigns option.
+  #
+  # If this object responds to 'parent', then the return value is merged with parent#assigns.
+  #
+  # If the :without option is specified, the variables in that array are omitted.
+  def assigns(options = {})
+    ivars = assignment_names(options)
+
+    assigns = ivars.inject({}) { |hash, ivar| hash[ivar[1..-1]] = instance_variable_get(ivar); hash }
+    if respond_to?(:parent) && parent.respond_to?(:assigns)
+      parent.assigns(:without => (options[:without] || []) + ivars).merge(assigns)
+    else
+      assigns
+    end
+  end
+
+  # Returns the name of each variable that would be returned by #assigns. The options are
+  # the same.
+  def assignment_names(options = {})
+    ivars = instance_variables
+    ivars -= options[:without] if options[:without]
+    ivars -= protected_instance_variables if respond_to?(:protected_instance_variables)
+    ivars -= rtml_protected_instance_variables if respond_to?(:rtml_protected_instance_variables)
+    ivars
+  end
+end

data/lib/rtml/controller/document_generator.rb

@@ -40,14 +40,23 @@ module Rtml::Controller::DocumentGenerator
       end
 
       def method_missing(name, *args, &block)
+        rtml_document.copy_ivars_from(self)
         rtml_document.send(name, *args, &block)
       rescue
         raise $!, $!.message, caller
       end
 
+      def fire_action(action_name)
+        copy_ivars_from(controller)
+        # Give rtml actions access to the controller's view helpers
+        (class << self; self; end).send(:include, controller.response.template.helpers)
+        __send__(action_name)
+      end
+
       def copy_ivars_from(source)
         ivars = source.instance_variables
         ivars -= source.protected_instance_variables if source.respond_to?(:protected_instance_variables)
+        ivars -= source.rtml_protected_instance_variables if source.respond_to?(:rtml_protected_instance_variables)
         ivars.each { |ivar| instance_variable_set(ivar, source.instance_variable_get(ivar)) }
         rtml_document.copy_ivars_from(self)
       end

data/lib/rtml/controller/render_helpers.rb

@@ -1,29 +1,53 @@
 module Rtml::Controller::RenderHelpers
   def render_with_rtml_option(options = nil, extra_options = {}, &block)
-    if (h = options).is_a?(Hash) || (h = extra_options).is_a?(Hash)
-      h = extra_options if !h.key?(:rtml) && extra_options.is_a?(Hash)
-      if rtml_action = h.delete(:rtml)
-        if rtml_helpers.respond_to?(rtml_action)
-          request.format = :rtml
-          rtml_helpers.send(rtml_action)
-          set_rtml_headers
-          response.template.template_format = :rtml
-          tml = rtml_document.to_tml
-          if Rtml.configuration.log_tml
-            Rails.logger.debug tml
-          end
-          return render_without_rtml_option(h.merge(:text => tml))
-        else
-          raise Rtml::Errors::UnknownRtmlAction,
-                "No RTML action responded to #{rtml_action}. RTML actions: #{rtml_actions.sort.to_sentence(:locale => :en)}",
-                caller
-        end
+    if (rtml_options = options).is_a?(Hash) || (rtml_options = extra_options).is_a?(Hash)
+      rtml_options = extra_options if !rtml_options.key?(:rtml) && extra_options.is_a?(Hash)
+      if rtml_action = rtml_options.delete(:rtml)
+        return attempt_rtml_action(rtml_action)
       end
     end
     render_without_rtml_option(options, extra_options, &block)
   end
 
+  def attempt_rtml_action(rtml_action, options = {})
+    if rtml_helpers.respond_to?(rtml_action)
+      tml = perform_rtml_action(rtml_action)
+      return render_without_rtml_option(options.merge(:text => tml))
+    else
+      raise Rtml::Errors::UnknownRtmlAction,
+            "No RTML action responded to #{rtml_action}. RTML actions: #{rtml_actions.sort.to_sentence(:locale => :en)}",
+            caller
+    end
+  end
+
+  def perform_rtml_action(rtml_action)
+    request.format = :rtml
+    feigning_action(rtml_action) do
+      rtml_helpers.fire_action(rtml_action)
+    end
+    force_rtml_format
+
+    returning rtml_document.to_tml do |tml|
+      if Rtml.configuration.log_tml
+        Rails.logger.debug "(RTML: Response Headers: " + response.headers.inspect + ")"
+        Rails.logger.debug tml
+      end
+    end
+  end
+
+  def feigning_action(name)
+    action_name, self.action_name = self.action_name, name
+    yield
+    self.action_name = action_name
+  end
+
+  def force_rtml_format
+    set_rtml_headers
+    response.template.template_format = :rtml
+  end
+
   def self.included(base)
     base.send(:alias_method_chain, :render, :rtml_option)
+    base.send(:hide_action, :attempt_rtml_action, :perform_rtml_action, :feigning_action, :force_rtml_format)
   end
 end

data/lib/rtml/controller/state.rb

@@ -1,5 +1,6 @@
 module Rtml::Controller::State
   def find_or_build_state
+    headers = request.headers
     if params[:terminal] && params[:terminal][:itid]
       itid = params[:terminal][:itid]
     elsif request.terminal?
@@ -27,7 +28,7 @@ module Rtml::Controller::State
           value = nil
         end
       end
-      state[state_attribute] = value
+      state[state_attribute] = value if value
     end
   end
 

data/lib/rtml/dependencies.rb

@@ -1,21 +1,26 @@
-unless defined?(Gem) && defined?(ActiveSupport::Dependencies) && defined?(ActionController::Base)
-  require 'rubygems'
-  gem 'hpricot', ">= 0.8.2"
-  gem 'sc-core-ext', ">= 1.1.1"
-  gem 'activesupport', '>= 2.3.5'
-  gem 'actionpack', '>= 2.3.5'
-  gem 'activerecord', '>= 2.3.5'
+if defined?(Rails)
+  Rails.configuration.gem 'hpricot', '>= 0.8.2'
+  Rails.configuration.gem 'sc-core-ext', '>= 1.1.1'
+else
+  unless defined?(Gem) && defined?(ActiveSupport::Dependencies) && defined?(ActionController::Base)
+    require 'rubygems'
+    gem 'hpricot', ">= 0.8.2"
+    gem 'sc-core-ext', ">= 1.1.1"
+    gem 'activesupport', '>= 2.3.5'
+    gem 'actionpack', '>= 2.3.5'
+    gem 'activerecord', '>= 2.3.5'
+  
+    require 'active_support'
+    require 'action_controller'
+    require 'action_view'
+    require 'active_record'
+    require 'active_resource'
+  end
 
-  require 'active_support'
-  require 'action_controller'
-  require 'action_view'
-  require 'active_record'
-  require 'active_resource'
+  require 'hpricot'
+  require 'sc-core-ext'
 end
 
-require 'hpricot'
-require 'sc-core-ext'
-
 path = File.expand_path(File.join(File.dirname(__FILE__), '../..'))
 %w(lib
    builtin/controllers

data/lib/rtml/dsl.rb

@@ -38,7 +38,7 @@ module Rtml::DSL
     rescue NameError
       Rtml::Dom::Element
     end
-    if new_record? || changed?
+    #if new_record? || changed?
       element = type.new(:name => name, :document => document)
       if respond_to?(:elements)
         elements << element
@@ -48,15 +48,15 @@ module Rtml::DSL
 #      element = elements.build(:name => name, :document => document, :type => type.to_s)
 #      element.document = document if element.respond_to?(:document)
       element.parent = self if element.respond_to?(:parent)
-    else
-      element = type.create!(:name => name, :document => document)
-      if respond_to?(:elements)
-        elements << element
-      elsif respond_to?(:root)
-        self.root = element
-      end
-      #element = elements.create!(:name => name, :document => document, :type => type.to_s)
-    end
+#    else
+#      element = type.create!(:name => name, :document => document)
+#      if respond_to?(:elements)
+#        elements << element
+#      elsif respond_to?(:root)
+#        self.root = element
+#      end
+#      #element = elements.create!(:name => name, :document => document, :type => type.to_s)
+#    end
     #element = type.new(:name => name, :document => document)
     #self.elements << element if respond_to?(:elements)
 #    element = if respond_to?(:elements) && elements.respond_to?(:build)

data/lib/rtml/environment.rb

@@ -19,10 +19,22 @@ end
 require File.join(path, 'builtin/rtml_helpers/rtml/get_state')
 require File.join(path, 'builtin/rtml_helpers/rtml/rescue_action')
 
-Dir[File.join(path, 'lib/extensions/**/*.rb')].each { |fi| require fi if File.file?(fi) }
+if defined?(Rails)
+  Rails.configuration.after_initialize do
+    Dir[File.join(path, 'lib/extensions/**/*.rb')].each { |fi| require fi if File.file?(fi) }
+  end
+else
+  Dir[File.join(path, 'lib/extensions/**/*.rb')].each { |fi| require fi if File.file?(fi) }
+end
 
 # Add RTML routes
 routes_file = File.join(Rtml.root, 'lib/rtml_routes.rb')
 unless ActionController::Routing::Routes.configuration_files.include? routes_file
   ActionController::Routing::Routes.configuration_files << routes_file
 end
+
+Mime::TML = Mime::Type.lookup("text/tml")
+require File.join(path, "lib/rtml/rules/tml_param_parser")
+ActionController::Base.param_parsers[Mime::TML] = proc { |data|
+  Rtml::Rules::TmlParamParser.new(data).params
+}

data/lib/rtml/errors/application_error.rb

@@ -0,0 +1,5 @@
+# Raised when Rtml::Test::TmlApplication is directed to do something that is not possible
+# due to application design.
+class Rtml::Errors::ApplicationError < StandardError
+
+end

data/lib/rtml/errors/simulation_error.rb

@@ -0,0 +1,4 @@
+# Raised when the simulator hits a high-level error, such as a hyperlink not found on the current screen.
+class Rtml::Errors::SimulationError < StandardError
+
+end

data/lib/rtml/errors/variable_error.rb

@@ -0,0 +1,5 @@
+# Raised when Rtml::Test::VariableScope encounters an error such as variable undefined, variable already defined,
+# variable cannot be cast, etc.
+class Rtml::Errors::VariableError < StandardError
+
+end

data/lib/rtml/high_level/variable_manager.rb

@@ -3,14 +3,18 @@ class Rtml::HighLevel::VariableManager
 
   def initialize()
     @vars = HashWithIndifferentAccess.new
+    Rtml::Test::BuiltinVariables::BUILTIN_VARIABLES.each do |name, options|
+      @vars[name] = Rtml::HighLevel::ManagedVariable.new(name)
+    end
   end
 
   def [](variable_name)
-    variable_name = variable_name.to_s
-    vardec = screen.document.variable_definitions.select { |i| i['name'] == variable_name }
-    vardec = vardec.collect { |i| i['name'] }.first
-    raise Rtml::Errors::MissingVariableError, "Could not find a TML variable named #{variable_name}. "+
-            "Did you forget to declare it?" unless vardec
+    variable_name = variable_name.to_s unless variable_name.kind_of?(String)
+    if !@vars.key?(variable_name)
+      vardec = screen.document.variable_names.include?(variable_name)
+      raise Rtml::Errors::MissingVariableError, "Could not find a TML variable named #{variable_name.inspect}. "+
+              "Did you forget to declare it?" unless vardec
+    end
     @vars[variable_name] ||= Rtml::HighLevel::ManagedVariable.new(variable_name)
   end
 
@@ -25,9 +29,9 @@ class Rtml::HighLevel::VariableManager
 
   def method_missing(name, *args, &block)
     if args.empty? && !block_given?
-      self.send("[]", name)
+      self.send(:[], name)
     elsif name.to_s[-1] == ?= && args.length == 1 && !block_given?
-      self.send("[]=", name.to_s[0...-1], *args)
+      self.send(:[]=, name.to_s[0...-1], *args)
     else
       super
     end