cauldron 0.1.0

data/lib/theory/TheoryDependent.rb

@@ -0,0 +1,135 @@
+# 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

@@ -0,0 +1,74 @@
+# 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    
+
+  # Returns all the theory vairables in this theory
+  # dependent. 
+  #
+  # TODO  What is the point in this - why only the actions?
+  def theory_variables
+    return @action.select_all {|x| x.kind_of?(TheoryVariable)}
+  end
+
+end

data/lib/theory/TheoryResult.rb

@@ -0,0 +1,131 @@
+# 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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,62 @@
+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