cauldron 0.1.2 → 0.1.3

data/lib/core/structure/FixnumAdditionStructure.rb

@@ -1,56 +0,0 @@
-# Example
-#   e.g. var_a = var_b + var_c
-#
-class FixnumAdditionStructure < StatementStructure
-  
-  def initialize()
-    super([Unknown,Equal,FixnumVariable,Addition,FixnumVariable])
-  end
-  
-  # Returns an array of statements using the available variables that
-  # follow the structure var = 8 + 6
-  #
-  # @param  available     An array of runtime variables that can be used in the statements
-  #                       construction.
-  #
-  def statements(available=[])
-    
-    # If there aren't any fixnum variables there is nothing to return
-    return [] unless available.any? {|x| x.pass_as?(FixnumVariable)}    
-    
-    # First find just varaibles that can pass as FixnumVariables
-    # NOTE: Currently I am not allowing method calls to be used
-    fixnum_variables = available.find_all {|x| x.pass_as?(FixnumVariable) and !x.kind_of?(DefCall)}
-    
-    # Using the variables constuct statements
-    possible_statements = []
-    fixnum_variables.length.times do |x|
-      fixnum_variables.length.times do |y|
-        new_statement = Statement.new(Unknown.new,Equal.new,fixnum_variables[x].copy,Addition.new,fixnum_variables[y].copy)
-        #new_statement.statement_type = DECLARATION_STATEMENT       
-        possible_statements.push(new_statement)
-      end
-    end
-    
-    # Remove mirror statements - these are additions that are essentially the 
-    # same statement written backwards.
-    # e.g.  var_c = var_a+var_b
-    #       var_d = var_b+var_a
-    possible_statements.copy.each do |x|
-      possible_statements.copy.each do |y|
-        next if x.statement_id == y.statement_id
-        if y.same_not_declared_variables?(x)
-          
-          # If the first variable id is lower than the secound remove it.    
-          if y[2].variable_id < y[4].variable_id
-             possible_statements.delete_if {|z| z.statement_id == y.statement_id}
-          end
-        end
-      end
-    end
-    
-    return possible_statements
-        
-  end
-  
-end

data/lib/core/structure/InstanceCallContainerStructure.rb

@@ -1,50 +0,0 @@
-# Example
-#   e.g. 'test'.chop
-#   e.g. 'test'.chop!
-#
-class InstanceCallContainerStructure < StatementStructure
-
-  def initialize()
-    super()
-  end
-  
-  # Returns an array of possible statements that make an instance 
-  # call.  They don't declare a new variables so to be in any way 
-  # relevant they must be destructive e.g.
-  # 
-  # 'test'.chop   # essential does nothing
-  # 'test'.chop!  # Changes the value  ('test' represents a variable with that value)
-  #
-  def statements(available=[])
-
-    # Exclude method calls for now - avoiding too complex statements
-    available.delete_if {|x| x.kind_of?(DefCall)}
-
-    # Go through each method call available to each of the variables
-    results = []
-    available.copy.each do |subject_var|
-
-      # Duplicate the available variables and exclude the current one
-      # to avoid less predicatable statements.
-      current_available = available.copy.delete_if do |x| 
-        unless(x.kind_of?(Variable) and subject_var.kind_of?(Variable))
-          next false
-        end
-        x.variable_id == subject_var.variable_id
-      end
-
-      # Create statements that use the specified instance calls
-      subject_var.destructive_instance_calls(current_available).each do |inst_call|
-        new_statement = Statement.new(inst_call)
-
-        # TODO  I'm not sure if all the instance calls are modifying - I should may have a StatementTemplate
-        #       class that foces the {:review} to be false.
-        #new_statement.statement_type = MODIFYING_STATEMENT
-        results.push(new_statement)
-      end
-    end
-
-    return results
-  end
-  
-end

data/lib/core/structure/InstanceCallStructure.rb

@@ -1,53 +0,0 @@
-# TODO  I think this class might have been replaced with InstanceCallContainerStructure
-class InstanceCallStructure < Array
-  attr_reader :instance_class, :method_call
-  
-  #
-  #  @param   instance_class  The class of the instance that should be called e.g. StringVariable
-  #  @param   method_call     An instance of the method_call
-  #  @param   parameters      The parameters that the instance method call excepts 
-  # 
-  def initialize(instance_class,method_call,*parameters)
-    # TODO  What are the two parameters an array expects
-    super()
-    
-    # Declare the elements that make up the instance call
-    @instance_class = instance_class
-    @method_call = method_call
-    
-    # Add the parameters to the array 
-    parameters.each do |code|
-      self.push(code)
-    end    
-  end
-  
-  #
-  def instance_calls(available=[])
-    
-    # Create an array of potential instance calls
-    potential_instance_calls = []
-    
-    # Find a variable thats class is @instance_class
-    available.each do |avail|
-      
-      if avail.class == @instance_class
-        
-        # We have a possible instance class
-        # TODO  Try with class and method call mismatch
-        if self.length == 0
-          potential_instance_calls.push(InstanceCallContainer.new(avail.copy,@method_call.copy))
-          next
-        end
-        
-        # Retrieve appropriate values for each of the intance calls parameters
-        
-        
-      end
-      
-    end
-    
-    return potential_instance_calls
-        
-  end
-  
-end

data/lib/core/structure/InstanceMethodCallStructure.rb

@@ -1,21 +0,0 @@
-# This a generic structure that can be used to create any number of 
-# instance method calls.  For example if it was meant to represent 
-# an array instance it might be able to produce the statement:
-# 
-# array.push(some_value)
-# 
-# TODO  This might duplicate the functionality of the InstanceCallContainerStructure 
-#       although I can't remember what I created that for.
-# 
-class InstanceMethodCallStructure < StatementStructure
-  
-  # 
-  # @param  instance_class    The class of the instance that has a method call
-  # @param  method_call       A method call instance that can be called from 
-  #                           instances of the supplied instance_class.
-  # 
-  def initialize(instance_class,method_call)
-
-  end
-  
-end

data/lib/core/structure/ReturnStructure.rb

@@ -1,20 +0,0 @@
-# Returns statements that return values 
-#
-# Example:
-#   return 7
-#   return var
-#
-class ReturnStructure < StatementStructure
-  
-  def initialize()
-    super()
-  end
-  
-  def statements(available=[])
-    
-    # Create return statements using the passed variables
-    return available.collect {|x| Statement.new(Return.new,x.copy)}      
-      
-  end 
-  
-end

data/lib/core/structure/StatementStructure.rb

@@ -1,11 +0,0 @@
-class StatementStructure < Array
-  
-  DECLARATION_STATEMENT = 'declaration_statement'
-  MODIFYING_STATEMENT = 'modifying_statement'
-  RETURN_STATEMENT = 'return_statement'
-  USAGE_STATEMENT = 'usage_statement'  
-  MISC_STATEMENT = 'misc_statement'
-  BLANK_STATEMENT = 'blank_statement'
-  IF_STATEMENT = 'if_statement'  
-  
-end

data/test/unit/core/statement/tc_statement_dependencies.rb

@@ -1,147 +0,0 @@
-$LOAD_PATH << File.expand_path('../../../../../lib',__FILE__)
-
-require 'required'
-require 'test/unit'
-
-class TestStatementDependencies < Test::Unit::TestCase
-  
-  def setup
-    
-    # 
-    # var_a = 'Wally'.chop
-    # var_b = var_a.length
-    # var_c = var_a.chop
-    
-    # Create some statements with dependencies
-    @wally = Literal.new('Wally')
-    @chopped_wally = Unknown.new
-    @chop_wally = Statement.new(@chopped_wally,Equal.new,InstanceCallContainer.new(@wally,Chop.new))
-    @chopped_length = Unknown.new
-    @chop_length = Statement.new(@chopped_length,Equal.new,InstanceCallContainer.new(@chopped_wally,StringLength.new))
-    @wall = Unknown.new
-    @statement_c = Statement.new(@wall,Equal.new,InstanceCallContainer.new(@chopped_wally,Chop.new))
-    @hermot = Literal.new('Hermot')
-    @hermot_var = Unknown.new
-    @declared_hermot = Statement.new(@hermot_var,Equal.new,@hermot)
-    @hermo_wall = Unknown.new
-    @hermo_wall_statement = Statement.new(@hermo_wall,Equal.new,InstanceCallContainer.new(@hermot_var,Chop.new),Addition.new,InstanceCallContainer.new(@chopped_wally,Chop.new))
-    
-    # This statement uses variables that haven't been declared in a statement
-    @bad_statement = Statement.new(Unknown.new,Equal.new,InstanceCallContainer.new(StringVariable.new('badboy'),Chop.new))
-    
-    # Chopping wall
-    @wal = Unknown.new
-    @statement_d = Statement.new(@wal,Equal.new,InstanceCallContainer.new(@wall,Chop.new))
-    
-    # Create a simple set of statement dependencies that use params
-    # var_a = MethodUsage.new
-    # var_b = RuntimeMethod.new(var_a)
-    @dependency_set_1 = StatementDependencies.new
-    @var_a = Unknown.new
-    @var_b = Unknown.new
-    @statement_a = Statement.new(@var_a,Equal.new,ClassMethodCallContainer.new(MethodUsageClass.new,New.new))
-    @statement_b = Statement.new(@var_b,Equal.new,ClassMethodCallContainer.new(RuntimeMethodClass.new,New.new,@var_a))
-    @dependency_set_1.push(@statement_a)
-    @dependency_set_1.push(@statement_b)      
-    
-    
-  end
-
-  def teardown
-    System.reset
-  end   
-  
-  def test_push
-    
-    # Check statements can be added 
-    statement_depenencies = StatementDependencies.new(@chop_wally)
-    assert_equal(1,statement_depenencies.length)
-    
-    # Check pushing new statements
-    statement_depenencies.push(@chop_length)
-    assert_equal(2,statement_depenencies.length)
-    
-    # Check that an error is thrown if the statement dependencies can't be found
-    assert_raises(StandardError){statement_depenencies.push(@bad_statement)}    
-    
-    # Here we are check depenceys are found for statements with multiple variables in
-        
-    
-  end
-  
-  def test_dependencies_for
-    
-    statement_depenencies = StatementDependencies.new()  
-    # hermot = 'Hermot'
-    statement_depenencies.push(@declared_hermot)
-    
-    # This statement shouldn't have any depenencies
-    assert_equal(1,statement_depenencies.dependencies_for(@declared_hermot.statement_id).length)  
-    
-    # Add a statement dependent on the first statement
-    # chopped_wally = 'Wally'.chop
-    statement_depenencies.push(@chop_wally)
-    assert_equal(1,statement_depenencies.dependencies_for(@chop_wally.statement_id).length)
-    statement_chop_chop_wally = Statement.new(Unknown.new,Equal.new,InstanceCallContainer.new(@chopped_wally,Chop.new))
-    statement_depenencies.push(statement_chop_chop_wally)
-    assert_equal(2,statement_depenencies.dependencies_for(statement_chop_chop_wally.statement_id).length)
-     
-    # Now add a string+string statement that uses the above statement
-    statement_depenencies.push(@hermo_wall_statement)
-    assert_equal(3,statement_depenencies.dependencies_for(@hermo_wall_statement.statement_id).length)
-    
-    assert_equal(1,@dependency_set_1.dependencies_for(@statement_a.statement_id).length)
-    assert_equal(@statement_a.statement_id,@dependency_set_1.dependencies_for(@statement_a.statement_id).first)    
-    assert_equal(2,@dependency_set_1.dependencies_for(@statement_b.statement_id).length)    
-    
-    # Create the statement with dependencies
-    statement_depenencies = StatementDependencies.new(@chop_wally,@chop_length,@statement_c)
-    
-    # Find the needed variables for the statements
-    assert_equal(1,@chop_length.not_declared_variables.length)
-    
-    # First statement doesn't have any dependecies
-    assert_equal(1,statement_depenencies.dependencies_for(@chop_wally.statement_id).length)        
-    
-    # The secound statement has one dependency
-    assert_equal(2,statement_depenencies.dependencies_for(@chop_length.statement_id).length)        
-    assert_equal(@chop_wally.statement_id,statement_depenencies.dependencies_for(@chop_length.statement_id).first)        
-    
-    # The third statement also only has one dependency
-    assert_equal(@chop_wally.statement_id,statement_depenencies.dependencies_for(@statement_c.statement_id).first)        
-    
-    # Add a fourth statement with 2 dependencies 'Wally' then 'Wall'
-    statement_depenencies.push(@statement_d)
-    assert_equal(3,statement_depenencies.dependencies_for(@statement_d.statement_id).length)            
-
-    # Check that an error is raised when looking for depencies for a variable that doesn't exist
-    assert_raises(StandardError){statement_depenencies.dependencies_for(@bad_statement.statement_id)}    
-    
-  end
-
-  def test_find_dependencies_for
-     assert_equal(0,@dependency_set_1.find_dependencies_for(@statement_a).length)
-     assert_equal(1,@dependency_set_1.find_dependencies_for(@statement_b).length) 
-     
-    #  Check that dependies are found for modified statements
-    #   var_a = 8
-    #   var_b = []
-    #   var_b.push(9)
-    #   var_b.push(10)
-    statement_a_1 = Statement.new(Unknown.new,Equal.new,8.to_literal)
-    statement_a_2 = Statement.new(Unknown.new,Equal.new,[].to_literal)    
-    statement_a_3 = Statement.new(InstanceCallContainer.new(statement_a_2.first.copy,Push.new,9.to_literal))
-    statement_a_4 = Statement.new(InstanceCallContainer.new(statement_a_3.first.subject.copy,Push.new,10.to_literal))
-    runtime_a = RuntimeMethod.new(MethodUsage.new)
-    runtime_a.push(statement_a_1)
-    runtime_a.push(statement_a_2)
-    runtime_a.push(statement_a_3)
-    runtime_a.push(statement_a_4)
-    
-    # Realise the method and add each of statements
-    assert_nothing_raised(){runtime_a.realise2(ParametersContainer.new)}
-    
-     
-  end
-
-end

data/test/unit/core/structure/tc_declare_new_instance_structure.rb

@@ -1,41 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestDeclareNewInstanceStructure < Test::Unit::TestCase
-  
-  def setup
-    
-    # Create the structure instance that generates the appropriate statement
-    @statement_generator = DeclareNewInstanceStructure.new(MethodUsageClass.new,RuntimeMethodClass.new)
-    
-  end
-  
-  def teardown
-    System.reset
-  end
-  
-  def test_statements
-    
-    # Test that "var = MethodUsage.new" can be created
-    assert_equal(true,@statement_generator.statements().all? {|x| x.kind_of?(Statement)})
-    assert_equal(true,(@statement_generator.statements().select_all {|x| x.kind_of?(MethodUsageClass) }.length > 0))
-    
-    # Test that "var = RuntimeMethod.new(<#method_usage>")
-    method_usage = MethodUsageVariable.new()
-    assert_equal(1,@statement_generator.statements([method_usage]).select_all {|x| x.kind_of?(RuntimeMethodClass)}.length)
-    
-    # Test that a statement that declares a new fixnum as variable can be created
-    new_statement_statement_generator = DeclareNewInstanceStructure.new(StatementClass.new)
-    assert_equal(
-      1,
-      new_statement_statement_generator.statements([5.to_literal]).select_all {|x| x.kind_of?(StatementClass)}.length
-    )
-    assert_equal(
-      'var_6 = Statement.new(Unknown.new, Equal.new, 5.to_declaration)',
-      new_statement_statement_generator.statements([5.to_literal]).first.write
-    )
-    
-    
-  end
-  
-end

data/test/unit/core/structure/tc_declare_variable_as_literal_structure.rb

@@ -1,41 +0,0 @@
-require 'required'
-require 'test/unit'
-
-class TestDeclareVariableAsLiteralStructure < Test::Unit::TestCase
-  
-  def setup
-    
-    # Create the structure instance that generates the appropriate statement
-    @statement_generator = DeclareVariableAsLiteralStructure.new
-    
-    
-  end
-  
-  def teardown
-    CodeHandler.reset_global_id
-    System.reset
-    RuntimeMethod.reset_global_id    
-  end
-  
-  def test_statements
-    
-    # Test that "var = 7" can be created
-    assert_equal(true,@statement_generator.statements([7.to_literal]).all? {|x| x.kind_of?(Statement)})
-    assert_equal(1,@statement_generator.statements([7.to_literal]).length)
-    assert_equal('var_2 = 7',@statement_generator.statements([7.to_literal]).first.write())
-    
-    # Test that "var = 8", "var = 'Grogg'" and 'var = []'
-    assert_equal(true,
-      @statement_generator.statements([
-        8.to_literal,'Grogg'.to_literal,[].to_literal
-        ]).all? {|x| x.kind_of?(Statement)}
-    )
-    assert_equal(true,
-      @statement_generator.statements([
-        8.to_literal,'Grogg'.to_literal,[].to_literal
-      ]).contains? {|x| x.kind_of?(Literal)}
-    )    
-    
-  end
-  
-end