cauldron 0.1.3 → 0.1.5

data/lib/theory/TheoryDependent.rb

@@ -1,135 +0,0 @@
-# A theory dependent is the "if" part of a theory.  It states what needs to be
-# true for a theory to be valid.  For example "if varA == 7", would be 
-# a theory dependent.
-# 
-class TheoryDependent
-  include TheoryComponent
-  
-  attr_reader :statement
-  # 
-  # @param  statement         A theory statement 
-  #                           e.g. StringToTheory.run("if(var1.pass?(var2))\nreturn true\nend")
-  #
-  def initialize(statement,theory_component_id=nil)
-    raise StandardError.new('Expecting open statement but was '+statement.class.to_s) unless statement.kind_of?(OpenStatement)
-    @statement = statement
-    @theory_component_id = theory_component_id unless theory_component_id.nil?
-    generate_theory_component_id
-  end
-  
-  # Returns an abstract description of the dependent
-  def describe(tab=0)
-    return @statement.describe(tab)
-  end
-  
-  def write(tab=0)
-    return @statement.write(tab)
-  end
-  
-  # Returns a deep copy of the theory dependent but with a unique object_ids, all the
-  # data should be identical.
-  #
-  def copy
-    return TheoryDependent.new(@statement.copy,@theory_component_id)
-  end
-  
-  # Returns all the theory vairables in this theory
-  # dependent. 
-  #
-  def theory_variables
-    return @statement.select_all {|x| x.kind_of?(TheoryVariable)}
-  end
-  
-  # TODO  The same code is used for both TheoryDependent and TheoryResult
-  # Returns true if supplied statement has the same structure as this theory 
-  # dependent's, it has the same structure if everything about the statement is
-  # the same except for the variables.  This means that the map_to method
-  # could be used to make it write identically.
-  #
-  def same_structure?(structure)
-      return false unless structure.tokens.length == @statement.tokens.length
-      return false unless structure.write_structure == @statement.write_structure
-      return true
-  end  
-  
-  # Returns a new theory dependent with the theory variables replaced with
-  # the values in the mapping hash. 
-  # 
-  def map_to(mapping)
-
-    # Duplicate the current statement before it is rewritten
-    rewritten_statement = @statement.copy
-
-    # Find all the containers that contain TheoryVariables
-    # NOTE  The statement is put in an array because select all doesn't include the array itself
-    containers = [rewritten_statement].select_all {|x| x.respond_to?(:has?)}
-    theory_variable_containers = containers.select {|x| x.has? {|y| y.kind_of?(TheoryVariable)}}
-    
-    # Rewrite the statement replacing the values
-    theory_variable_containers.each do |z|
-      z.replace_theory_variables!(mapping)
-    end     
-    
-    return TheoryDependent.new(rewritten_statement,@theory_component_id)
-  end
-  
-  # Returns a duplicate theory dependent but with the theory 
-  # variables replaced with those supplied. 
-  #
-  def rewrite_with(replacement_variables)
-    raise StandardError.new("This theory dependent has #{theory_variables.length} not #{replacement_variables.length}") if replacement_variables.length != theory_variables.length
-    rewritten_statement = @statement.copy
-
-    # TODO  I think as well as copy I should have a rewrite_where(['var1'=>replacement_variables[0])
-    
-    # Find all the containers that contain TheoryVariables
-    containers = [rewritten_statement].select_all {|x| x.respond_to?(:has?)}
-    theory_variable_containers = containers.select {|x| x.has? {|y| y.kind_of?(TheoryVariable)}}
-
-    # Collect all uniq variables
-    # TODO  Check that only uniq variables are caught
-    uniq_variables = theory_variable_containers.inject([]) {|results,x| results + x.variables }
-    
-    # Check that all the variables in the theory dependent can be replaced
-    unless replacement_variables.length == uniq_variables.length 
-      raise StandardError.new('Mismatch in the number of variables to be replaced and the number supplied')
-    end
-    
-    # Create a mapping from the existing variable to the replacement ones
-    # TODo  I really should use the varible id or something as the key
-    mapping = []
-    replacement_variables.zip(uniq_variables) do |x,y|
-      mapping.push({:before=>y,:after=>x})
-    end
-    theory_variable_containers.each do |z|
-      replacements = mapping.select {|x| x[:before].theory_variable_id == z.subject.theory_variable_id}
-      z.subject = replacements.first[:after]
-    end   
-    return rewritten_statement 
-
-  end
-  
-  # Returns an array of theory statements that realise this dependency
-  # using the passed variables.
-  #
-  # http://en.wikipedia.org/wiki/Combination
-  # http://chriscontinanza.com/2010/10/29/Array.html  
-  # 5! FACTORIAL
-  #
-  def rewrite_permutations(realisable_variables)
-    # TODO  Need to include a combination size check here - incase it is going to get insane
-    raise StandardError.new('Currently requires at least one theory variable') if theory_variables.length == 0
-    
-    # Create an array of all the possible permutations that could replace this depenents' theory variables
-    arrangements = realisable_variables.permutation(theory_variables.length).to_a
-
-    # Construct a new theory dependent that use realisable variables inplace of 
-    # the theory variables
-    realisable_theory_dependents = []
-    arrangements.each do |x|
-        realisable_theory_dependents.push(self.copy.rewrite_with(x))
-    end
-    return realisable_theory_dependents
-  end
-    
-end

data/lib/theory/TheoryImplementation.rb

@@ -1,75 +0,0 @@
-# Instances of this class are realised theorys.  The theory variables
-# have been replaced with values that generate valid ruby code.
-
-class TheoryImplementation < Theory
-  attr_reader :mapping, :accessor_values
-  
-  #  
-  # @param  mapping     The literal mapping indicating what variable should be converted
-  #                     to what literal value. {1=><#IntrinsicRuntimeMethod,2=><#IntrinsicLiteral val=9>,...}
-  # @param  values      
-  #
-  def initialize(dependents,action,results,mapping,accessor_values={})
-    super(dependents,action,results)
-    @mapping, @accessor_values = mapping, accessor_values
-  end
-  
-  def copy
-    #return TheoryImplementation.new(@dependents.copy, @action.copy, @results.copy,@mapping.copy)
-     return Marshal.load(Marshal.dump(self))
-  end
-  
-  # Returns true if the result descript matches any of the results
-  # for this theory.
-  #
-  # @param  result_description      A OpenStatement with an if statement inside e.g.
-  #                                 if(runtime_method.all_pass?(test_cases))
-  #                                 end
-  #
-  def leads_to?(result_description)
-    @results.any? {|x| x.statement.write == result_description.write}
-  end  
-  
-  # Returns true if the implemeted theories pass given the
-  # given runtime method and test cases.
-  # 
-  # TODO  There might be a bit of crossover between the TheoryResult validates?
-  #       method.
-  #
-  def meets_dependencies?(runtime_method,test_cases)
-    
-    self.dependents.collect {|y| y.copy}.each do |x|
-      # TODO  I'm not sure there is much benefit in the ParametersContainer class
-      begin
-        unless evaluate_dependent(x,runtime_method.copy,test_cases)
-          return false
-        end
-      rescue NoMethodError => e
-        return false
-      rescue StandardError => e
-        return false
-      end      
-      
-    end
-    return true    
-
-  end
-  
-  # TODO  If I remove the code from this method then tc_theory_implementation.rb still
-  #       passes all the tests!
-  def evaluate_dependent(dependent,runtime_method,test_cases)
-    #dependent.statement.push(Parser.run('return true'))
-    last_runtime_method = runtime_method.copy
-    eval dependent.statement.write 
-    return false
-  end
-
-  def hash
-    @theory_id
-  end
-  
-  def eql?(value)
-    @theory_id == value.theory_id
-  end
-  
-end

data/lib/theory/TheoryResult.rb

@@ -1,131 +0,0 @@
-# This instances of this class describe the consequence of a theory, e.g. if the 
-# the theories dependencies are met and the action complete then this will be 
-# true.
-#
-class TheoryResult
-  include TheoryComponent
-  
-  attr_reader :statement
-  
-  # 
-  # @param  statement     A theory statement explaining what will be tested
-  #                       e.g. <runtime_method>.all_pass?(<test_cases>)
-  #
-  def initialize(statement,result=nil,theory_component_id=nil)
-    
-    # TEMPORARY - Deprecaction Change:
-    unless result.nil? then StandardLogger.instance.warning('Result is being phased out - just use if statements') end
-    unless statement.kind_of?(OpenStatement) 
-      StandardLogger.instance.warning('Please use open statements for theory results') 
-    end 
-    unless statement.length > 0 
-      StandardLogger.instance.warning('Please include a return true statement in the theory result')
-    end      
-    
-    @statement = statement
-    @result = result
-    @theory_component_id = theory_component_id unless theory_component_id.nil?
-    generate_theory_component_id
-  end
-  
-  def describe(tab=0)
-    return @statement.describe(tab)
-  end
-
-  def write(tab=0)
-    return @statement.write(tab)
-  end  
-  
-  def copy
-    #return TheoryResult.new(@statement.copy,@result)
-    return Marshal.load(Marshal.dump(self))
-  end
-  
-  # Returns a new theory result with the theory variables replaced with
-  # the values in the mapping hash.
-  #
-  # @param  mapping   { 1=>[],
-  #                     2=>#<IntrinsicTestCases:0xb712d13c>,
-  #                     3=>#<IntrinsicRuntimeMethod:0xb712c980>
-  #                   }
-  # 
-  def map_to(mapping)
-    
-    # Duplicate the current statement before it is rewritten
-    rewritten_statement = @statement.copy
-    
-    # Find all the containers that contain TheoryVariables
-    # NOTE  The statement is put in an array because select all doesn't include the array itself
-    containers = [rewritten_statement].select_all {|x| x.respond_to?(:has?)}
-    theory_variable_containers = containers.select {|x| x.has? {|y| y.kind_of?(TheoryVariable)}}
-    
-    # Rewrite the statement replacing the values
-    theory_variable_containers.each do |z|
-      z.replace_theory_variables!(mapping)
-    end     
-    
-    return TheoryResult.new(rewritten_statement,nil,theory_component_id)
-  end
-  
-  # Returns a mapping hash that will convert this result to the statement 
-  # provided.
-  #
-  def mapping_for(statement)
-    mapping = Mapping.new()
-    @statement.tokens.zip(statement.tokens) do |x,y|
-      mapping[x.theory_variable_id] = y
-    end
-    return mapping
-  end    
-  
-  # Returns true if supplied statement has the same structure as this theory 
-  # result's, it has the same structure if everything about the statement is
-  # the same except for the variables.  This means that the map_to method
-  # could be used to make it write identically.
-  #
-  def same_structure?(structure)
-      return false unless structure.tokens.length == @statement.tokens.length
-      return false unless structure.write_structure == @statement.write_structure
-      return true
-  end
-  
-  # Returns true if theory result is true with the supplied
-  # runtime method and test cases.  The paramter are 'rutime_method'
-  # and 'test_cases' so the eval can use them.
-  #
-  # TODO  Write tests for this
-  def validates?(runtime_method,test_cases)
-    catch :theory_result_failed do 
-      return true if use_statement(runtime_method,test_cases) == true
-    end
-    return false
-  end  
-  
-protected 
-  
-  # This uses the result statement with the supplied values so  
-  # the result can be evaluted.
-  #
-  def use_statement(runtime_method,test_cases)
-    duplicate_statement = @statement.copy
-    # TODO  I'm not certaion with is how last_runtime is being used - see spec
-    last_runtime_method = runtime_method.copy
-    begin
-    rescue StandardError => e
-    end
-#    if((last_runtime_method.history2(test_cases[0]).select{ |x| x['statement_id'] == test_cases.last.statement_id} ) == test_cases[0][:params][0].length - 1)
-#      #return true
-#    end
-    
-    #last_runtime_method.history2(test_cases[0][:params]).each do |x|
-    #end
-    # TODO    For future debugging I really need to generate a runtime method from a string.
-    eval duplicate_statement.write
-    throw :theory_result_failed
-  rescue NoMethodError => e
-    throw :theory_result_failed
-  rescue TypeError => e
-    throw :theory_result_failed
-  end
-  
-end

data/lib/theory/TheoryVariable.rb

@@ -1,63 +0,0 @@
-class TheoryVariable
-  include Variable
-  include Token
-  
-  attr_reader :theory_variable_id
-  # colours http://forums.opensuse.org/archives/sls-archives/archives-suse-linux/archives-desktop-environments/379032-how-can-i-change-font-color-my-terminal.html
-  RED = "\033[31m"
-  GREEN = "\033[32m"
-  YELLOW = "\033[33m"
-  TURQUOISE = "\033[34m"
-  VIOLET = "\033[35m"
-  BLUE = "\033[36m"
-  NORMAL = "\033[m"
-  
-  def initialize(theory_variable_id)
-    @theory_variable_id = theory_variable_id
-  end
-  
-  def write
-    return "var#{@theory_variable_id}"
-  end
-  
-  def describe
-    return TheoryVariable.variable_colour(@theory_variable_id)+"var#{@theory_variable_id}"+NORMAL    
-  end
-  
-  def copy
-    return TheoryVariable.new(@theory_variable_id.copy)    
-  end
-  
-  def to_declaration
-    return VariableDeclaration.new('TheoryVariable',Literal.new(@theory_variable_id).to_declaration)
-  end
-  
-  def eql?(obj)
-    @theory_variable_id == obj.theory_variable_id     
-  end
-  
-  def hash
-    @theory_variable_id
-  end
-
-  # Returns the preset colour for that particular id for easier
-  # tracking. 
-  #
-  def self.variable_colour(theory_variable_id)
-    case theory_variable_id
-      when 0
-        return RED
-      when 1
-        return GREEN
-      when 2
-        return YELLOW
-      when 3
-        return TURQUOISE  
-      when 4
-        return VIOLET
-    else
-        return BLUE
-    end
-  end
-    
-end

data/lib/theory/theory_collection.rb

@@ -1,62 +0,0 @@
-class TheoryCollection
-  
-  attr_reader :theories
-  
-  def initialize(theories)
-    @theories = theories
-  end
-  
-  def each_with_result_structure(structure)
-    @theories.each do |t|
-      t.results.each do |r|
-        if r.same_structure?(structure)
-          yield t, r
-        end
-      end
-    end
-  end
-  
-  def each_with_dependent_structure(structure)
-    @theories.each do |t|
-      t.dependents.each do |d|
-        if d.same_structure?(structure)
-          yield t, d
-        end
-      end
-    end    
-  end
-  
-  # Returns the number of theories that have dependents 
-  # or results that match the structure supplied.
-  # 
-  # @param    approach      Either :dependents or :results
-  #
-  def same_structure_count(structure,approach)
-    @theories.inject(0) do |total,theory|
-      total += theory.send(approach).count {|x| x.same_structure?(structure)}
-    end
-  end
-  
-  # Returns all the dependents within the theories
-  #
-  def dependents
-    @theories.inject([]) {|total,theory| total += theory.dependents }
-  end
-  
-  def results
-    @theories.inject([]) {|total,theory| total += theory.results }
-  end
-  
-  def actions
-    @theories.select {|x| x.action != nil}.inject([]) {|total,theory| total << theory.action }
-  end
-  
-  def components
-    return dependents+results
-  end
-  
-  # Returns an array of all the uniq theory variables used.
-  def theory_variables
-    return @theories.inject([]) {|total,x| total += x.all_theory_variables}.uniq
-  end
-end