rtml 2.0.3 → 2.0.4

data/lib/rtml/high_level/subroutine.rb

@@ -1,22 +0,0 @@
-class Rtml::HighLevel::Subroutine
-  def initialize(name, parent, options = {}, &blk)
-    @block = blk
-    @name = name
-    @parent = parent
-  end
-
-  def call(context, args)
-    method_name = @name
-    block = @block
-    
-    (class << context; self; end).instance_eval do
-      define_method method_name, &block
-      new_method = instance_method(method_name)
-      define_method method_name do |arguments|
-        new_method.bind(self).call(arguments)
-      end
-    end
-
-    context.send(method_name, args)
-  end
-end

data/lib/rtml/reverse_engineering/crawler.rb

@@ -1,58 +0,0 @@
-class Rtml::ReverseEngineering::Crawler
-  attr_reader :simulator, :session
-  delegate :tml, :route, :set, :to => :simulator
-  delegate :response, :request, :controller, :get, :post, :put, :delete, :to => :session
-
-  def tml=(tml)
-    @path = nil
-    simulator.tml = tml
-  end
-
-  def initialize(options = {})
-    @simulator = Rtml::ReverseEngineering::Simulator.new(options.delete(:tml))
-    @session = ActionController::Integration::Session.new
-  end
-
-  def visit(path, screen = nil)
-    path, screen = split_path_and_screen_name_out_of(path) unless screen
-    unless path.blank? or path == @path
-      get @path = path
-      format = response.template.template_format
-      if format == :rtml then simulator.tml = response.body
-      else raise Rtml::Errors::InvalidFormat, "Response must be in :rtml format; found #{format.inspect}:\n#{response.body}"
-      end
-    end
-    
-    @simulator.visit screen
-  end
-
-  def split_path_and_screen_name_out_of(path)
-    path, screen = path.split(/#/)
-    if screen =~ /\?/
-      screen, query = screen.split(/\?/)
-      path = "#{path}?#{query}"
-    end
-    [path, screen]
-  end
-
-  def current_screen
-    route.last
-  end
-
-  private
-  # Since we're using ActionController::Integration::Session instead of including ActionController::TestProcess,
-  # this method isn't used any more and should really be removed.
-  def setup_controller_request_and_response
-    # How to get this info into a TestResult so we don't have to create 2 requests?! TestResult seems to always override
-    # the env with Rack::MockRequest.env_for("/"), even though it looks like it SHOULD be merging the two. Bug?
-    temp_request = ActionController::Request.new(Rack::MockRequest.env_for(@path))
-    @path_params = ActionController::Routing::Routes.recognize_path(temp_request.path)
-    @request = ActionController::TestRequest.new
-    @request.remote_addr = '123.231.12.3'
-    @response = ActionController::TestResponse.new
-    @controller = @path_params[:controller].to_controller.new
-    @controller.request = @request
-    @controller.params = temp_request.parameters
-    @controller.send(:initialize_current_url)
-  end
-end

data/lib/rtml/reverse_engineering/simulator.rb

@@ -1,269 +0,0 @@
-class Rtml::ReverseEngineering::Simulator
-  include Rtml::Rules::DomValidation
-  include Rtml::ReverseEngineering::Simulator::VariableLookup
-  attr_reader :tml
-
-  def initialize(tml = nil)
-    self.tml = tml if tml
-  end
-
-  def set(values)
-    variables.merge!(values.with_indifferent_access)
-  end
-
-  def route
-    @stack.last ? @stack.last[4] : []
-  end
-
-  # Visits the specified screen. Evaluates variable assignments and follows TML logical flow, but does not interact
-  # with hotkeys, hyperlinks, etc.
-  #
-  # Timeouts are not evaluated because they *usually* indicate that some interaction is required by the user.
-  #
-  # The return value is the last screen to be visited with the above exceptions. Circular paths return the last
-  # screen in the path before it would loop over; external references return the URL of the reference.
-  def visit(screen_name = nil)
-    raise Rtml::Errors::ScreenNotFound, "No screens found to visit in RTML document!" unless first_screen
-    screen_name = first_screen['id'] if screen_name.blank?
-    response = analyze screen_name, :ignore_pathlist => true, :interaction => :none
-    response.kind_of?(Symbol) ? route.last || response : response
-  end
-
-  # Analyzes the specified path (which can be one or more symbols and/or strings) and verifies
-  # that screens with the specified IDs are followed, in the specified order. If any screen is encountered
-  # which is NOT in the list, no error is raised as long as the next screen in the list is visited at some point.
-  # Returns one of the following values:
-  #
-  #   :completion - each screen was visited in the specified order.
-  #   :assertion  - a TML assertion error was raised in the form of the "assert" screen being visited.
-  #   :no_route   - The TML pathway did not result in the specified screens being visited in the expected order.
-  #   :dead_end   - The TML pathway ended abruptly, and did not visit all of the specified screens before doing so.
-  #   :circular   - The TML pathway was a circular route which never touched one or more nodes.
-  #   :error      - Processing ended abruptly, for an unknown reason.
-  #   a String    - The TML pathway encountered a link to an external document, and not an anchor. The String returned
-  #                 is the reference to the external document.
-  #
-  # This method also builds the #route up, so that you can analyze the order in which screens were visited.
-  #
-  def analyze(*path)
-    raise Rtml::Errors::ScreenNotFound, "No screens found to visit in RTML document!" unless first_screen
-    options = path.extract_options!
-    path.flatten!
-    raise ArgumentError, "Expected at least one screen ID as an argument" unless path.length > 0
-    @ignore_pathlist = path.empty? || options.delete(:ignore_pathlist)
-    @interaction = options.delete(:interaction) || options.delete(:interactions) || :all
-    @recursion_limit = options.delete(:recursion_limit) || options.delete(:max_depth) || 150
-
-    r = catch(:completion) do
-      current = path.shift || first_screen['id']
-      #route << current
-      @pathlist = path
-      catch(:abort) do
-        trace(find_screen(current))
-        :error
-      end
-    end
-    r
-  end
-
-  def tml=(value)
-    reset!
-    case value
-      when String        then @tml = Hpricot::XML(value).root
-      when Hpricot::Doc  then @tml = value.root
-      when Hpricot::Elem then @tml = value
-      else raise ArgumentError, "Expected TML to be a String, Hpricot::Doc or Hpricot::Elem"
-    end
-
-    parse_tml
-  end
-
-  def find_screen(id)
-    rt = screens.select { |scr| scr['id'] == id.to_s }
-    raise Rtml::Errors::ScreenNotFound, "Could not find screen with ID '#{id}'" if rt.empty?
-    scr = rt.shift
-    raise Rtml::Errors::ScreenNotFound, "Multiple ambiguous screens found with ID '#{id}'" unless rt.empty?
-    scr
-  end
-
-  private
-  # Returns all interactions that the simulator is allowed to perform in the form of an array.
-  def interactions
-    if @interaction.kind_of?(Symbol)
-      case @interaction
-        when :all then [:all, :key, :timeout, :href]
-        when :none then []
-        when :key, :timeout, :href then [@interaction]
-      end
-    else
-      @interaction
-    end
-  end
-
-
-  def trace(screen)
-    route << screen['id']
-    take_snapshot(screen)
-    unless @ignore_pathlist
-      @pathlist.shift if screen['id'] == @pathlist.first.to_s
-      throw :completion, :completion if @pathlist.empty?
-    end
-
-    process_variable_assignments(screen)
-
-    candidates = href_candidates(screen)
-    throw :completion, :completion unless candidates.empty? || interactions.include?(:href)
-    
-    candidates.concat next_screen_for(screen)
-    throw :abort, :dead_end if candidates.empty?
-
-    abort_with = nil
-    anchors_for(candidates).each do |next_screen|
-      if next_screen.kind_of?(String)# == :external
-        throw :abort, next_screen    #    :external
-      elsif next_screen['id'] == 'assert'
-        throw :abort, :assertion
-      else
-        push_stack
-        abort_with = catch(:abort) do
-          trace(next_screen)
-          nil
-        end
-        throw :abort, abort_with if @ignore_pathlist
-        pop_stack if abort_with
-      end
-    end
-    throw :abort, abort_with if abort_with
-  end
-
-  # Finds the various +setvar+ elements in the specified screen and updates the simulator's variable states to match.
-  def process_variable_assignments(screen)
-    setvars = screen / "setvar"
-    setvars.each do |setvar|
-      variables[setvar['name']] = Rtml::ReverseEngineering::Simulator::VariableValue.new(setvar, variables, vardecs).value
-    end
-  end
-
-  # Finds all hyperlinks within the given screen and returns them.
-  #
-  def href_candidates(screen)
-    (screen / "a").select { |elem| elem['href'] }.collect { |elem| elem['href'] }
-  end
-
-  # Takes a "snapshot" of the state of the simulator, with the given screen as the index.
-  # This is used to track visited screens; it is a safe assumption that if all variables are identical
-  # to a given snapshot with the given screen, then this will result in a circular TML path.
-  # This method will throw :abort, :circular if this condition is true.
-  def take_snapshot(screen)
-    snapshot = Rtml::ReverseEngineering::Simulator::Snapshot.new(screen, variables)
-    if snapshots.length > @recursion_limit
-      raise Rtml::Errors::ProcessingError, "Recursion error: Probable infinite loop (or :recursion_limit is too low)"
-    end
-    if snapshots.include?(snapshot)
-      throw :abort, :circular
-    end
-    snapshots << snapshot
-  end
-
-  # returns the list of possible screenflow branches following the specified screen.
-  def next_screen_for(screen)
-    candidates = screen['next'] ? [screen['next']] : []
-    next_element = (screen / "next").shift
-    if next_element
-      candidates = find_adequate_variants(next_element) + [next_element['uri']]
-    end
-
-    candidates
-  end
-
-  # Returns array containing the screen element for each string in the array, or the original string if it is not found.
-  def anchors_for(candidates)
-    candidates.collect do |screen_id|
-      if screen_id =~ /^#/
-        find_screen(screen_id[1..-1]) # to drop the '#'
-      else
-        screen_id
-        #:external
-      end
-    end
-  end
-
-  # Returns the first variant in the Hpricot::Elem which matches the current variable values, or nil if none match.
-  def find_adequate_variants(elem)
-    variants = elem / "variant"
-
-    candidates = []
-    variants.each do |variant|
-      uri, lo, op, ro, key, timeout =
-              variant['uri'], variant['lo'], variant['op'] || "equal", variant['ro'], variant['key'], variant['timeout']
-      %w(uri lo op ro key timeout).each { |lv| eval("#{lv} = resolve(#{lv}, variables, vardecs)") }
-      if (interactions.include?(:key) && key) || (interactions.include?(:timeout) && timeout)
-        candidates << uri
-      elsif key || timeout # if we're not interacting with them, pause to allow user interaction
-        throw :completion, :completion
-      else
-        # only follow if it's a match
-        ro = lo.kind_of?(Fixnum) ? ro.to_i : ro.to_s
-        
-        match = case 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.to_s[ro.to_s]
-          else raise Rtml::InvalidOperation, "Invalid operation: #{op}"
-        end
-        candidates << uri and break if match
-      end
-    end
-
-    candidates #candidates.empty? ? nil : candidates
-  end
-
-  def first_screen
-    (tml / "screen").first
-  end
-  
-  # resets the various tracking variables
-  def reset!
-    @stack = [ ]
-    #@stack.clear
-    push_stack
-  end
-
-  def push_stack
-    @stack.push [ screens.dup, snapshots.dup, variables.dup, vardecs.dup, route.dup ]
-  end
-
-  def pop_stack
-    @stack.pop
-  end
-
-  def screens
-    @stack.last ? @stack.last[0] : []
-  end
-
-  def snapshots
-    @stack.last ? @stack.last[1] : []
-  end
-
-  def variables
-    @stack.last ? @stack.last[2] : {}
-  end
-
-  def vardecs
-    @stack.last ? @stack.last[3] : {}
-  end
-
-  # Validates the given TML, and then finds the +screen+ elements and tracks them. 
-  def parse_tml
-    validate_tml(@tml)
-    (@tml / "vardcl").each do |elem|
-      vardecs[elem['name']] = elem['type'].to_sym
-    end
-    
-    (@tml / "screen").each do |elem|
-      screens << elem
-    end
-  end
-end

data/lib/rtml/reverse_engineering/simulator/casting.rb

@@ -1,9 +0,0 @@
-module Rtml::ReverseEngineering::Simulator::Casting
-  # Returns an instance of +Rtml::ReverseEngineering::Simulator+ with self as the initialization argument.
-  def to_tml_simulator
-    Rtml::ReverseEngineering::Simulator.new(self)
-  end
-
-  alias to_rtml_simulator to_tml_simulator
-  alias to_simulator to_tml_simulator
-end

data/lib/rtml/reverse_engineering/simulator/snapshot.rb

@@ -1,18 +0,0 @@
-# This class is used to contain a single +screen+ element (an instance of Hpricot::Elem) as well as any variable
-# assignments that have been made. Basically, it is simply used by +Rtml::ReverseEngineering::Simulator+ to check
-# for circular pathways. If two identical snapshots would be created, then it stands to reason that the resultant
-# pathways for those two snapshots will also be identical. If you're following a path and creating snapshots at every
-# step of the way, and two snapshots match, then using that logic, those two snapshots would indicate a circular
-# pathway. (It comes down to either that, or waiting to catch a stack overflow error, which is less than optimal.)
-#
-class Rtml::ReverseEngineering::Simulator::Snapshot
-  attr_reader :screen, :variables
-
-  def initialize(screen, variables)
-    @screen, @variables = screen, variables.dup
-  end
-
-  def ==(other_snapshot)
-    @screen == other_snapshot.screen && variables == other_snapshot.variables
-  end
-end

data/lib/rtml/reverse_engineering/simulator/variable_lookup.rb

@@ -1,32 +0,0 @@
-module Rtml::ReverseEngineering::Simulator::VariableLookup
-  # Checks a value to see if it references a TML variable; if so, it resolves that variable into its value;
-  # otherwise, the original value is returned.
-  def resolve(value, all_variables, known_variable_types)
-    if value =~ /^tmlvar:(.*)$/
-      lookup_variable_value($~[1], all_variables, known_variable_types)
-    else
-      value
-    end
-  end
-
-  # Finds the variable in the all_variables hash whose name matches the specified name (string or symbol), and then
-  # returns its value. If that value is an instance of +Rtml::ReverseEngineering::Simulator::VariableValue+, calls
-  # the #value method on that object instead.
-  #
-  # If the variable is not found, then a default value will be returned depending on its type.
-  def lookup_variable_value(name, all_variables, known_variable_types)
-    all_variables.each do |var_name, varval|
-      if var_name.to_s == name
-        return(varval.kind_of?(Rtml::ReverseEngineering::Simulator::VariableValue) ? varval.value : varval)
-      end
-    end
-    default_value_for_type(known_variable_types[name])
-  end
-
-  def default_value_for_type(type)
-    case type
-      when :integer then 1
-      else "generic"
-    end
-  end
-end

data/lib/rtml/reverse_engineering/simulator/variable_value.rb

@@ -1,105 +0,0 @@
-# Used by +Rtml::ReverseEngineering::Simulator+ to track the value of a variable. Attempts
-# to build a logical value by processing the setvar's :lo, :op and :ro attributes. References to
-# other variables are automatically resolved. References to nonexistent values assume built-in variables
-# and assign generic values to them.
-#
-# Implements a #== method to see if one variable's value is equal to another's, though this may not always be accurate.
-#
-class Rtml::ReverseEngineering::Simulator::VariableValue
-  include Rtml::ReverseEngineering::Simulator::VariableLookup
-  attr_reader :value
-
-  def initialize(setvar, all_variables, known_variable_types)
-    @setvar, @all_variables, @known_variable_types = setvar, all_variables, known_variable_types
-    @value = setvar.to_s
-
-    %w(lo op ro).each { |i| instance_variable_set("@#{i}", resolve(self.send(i), all_variables, known_variable_types)) }
-    catch(:done) do
-      check_for_assignment
-      check_for_operation
-    end
-
-    do_casting
-    check_boundaries
-  end
-
-  def ==(other)
-    self.value == other.value
-  end
-
-  private
-  attr_reader :setvar, :all_variables, :known_variable_types
-
-  def type
-    @type ||= known_variable_types[setvar['name']]
-  end
-
-  def check_boundaries
-    case type
-      when :integer
-        unless (-999999999..999999999).include? @value
-          raise RulesViolationError, "TML numbers must be no more than 9 digits in length: #{@value}"
-        end
-    end
-  end
-
-  def do_casting
-    @value = case type
-      when :integer then value.to_i
-      else value.to_s
-    end
-  end
-
-  def check_for_operation
-    unless setvar['op'].blank?
-      method_name = "perform_operation_#{setvar['op']}"
-      @value = self.send(method_name)
-      throw :done
-    end
-  rescue NoMethodError
-    raise Rtml::Error::InvalidOperation
-  end
-
-  def check_for_assignment
-    if setvar['op'].blank? && !setvar['lo'].blank?
-      @value = setvar['lo']
-      throw :done
-    end
-  end
-
-  def lo; @lo ||= setvar['lo']; end
-  def op; @op ||= setvar['op']; end
-  def ro; @ro ||= setvar['ro']; end
-
-  def perform_operation_plus
-    case type
-      when :integer then lo.to_i + ro.to_i
-      when :string  then lo.to_s + ro.to_s
-      when :date then "#{lo.to_s} + #{ro.to_s}"
-      else raise Rtml::Errors::InvalidOperation
-    end
-  end
-
-  def perform_operation_minus
-    case type
-      when :integer then lo.to_i - ro.to_i
-      when :string  then lo.to_s[0..-(ro.to_i+1)]
-      when :date then "#{lo.to_s} - #{ro.to_s}"
-      else raise Rtml::Errors::InvalidOperation
-    end
-  end
-
-  def perform_operation_number
-    case type
-      when :integer then lo.split(/;/).length
-      else raise Rtml::Errors::InvalidOperation
-    end
-  end
-
-  def perform_operation_item
-    case type
-      when :string then lo.split(/;/)[ro.to_i]
-      else raise Rtml::Errors::InvalidOperation
-    end
-  end
-end