cauldron 0.1.3 → 0.1.5

data/lib/ruby_code/Array.rb

@@ -1,95 +0,0 @@
-class Array
-  
-  def cauldron_method_calls
-    # TODO  Need to follow sexp more for ArrayAccess - I shouldn't need a class to contain the array and value
-    #result = self.length.times.collect {|x| '['+x.to_s+']'}
-    #result = self.length.times.collect {|x| ArrayAccess.new(self.copy,x)}
-    result = ['.length','.any?','[]']
-    return result
-  end
-  
-  def to_var(id=nil,unique_id=nil)
-    raise StandardError.new('No to_var method has been created for '+self.class.to_s) unless self.class.to_s == 'Array'
-    # TODO I'm not sure whether it's best to save the literal value or variable value
-    result = []
-    self.each {|x| result.push(x.copy)}    
-    replicate = ArrayVariable.new(*result) {{:variable_id => id,:uniq_id=>unique_id}}
-    return replicate
-  end  
-  
-  # Returns the array as a declaration string
-  # e.g.  ['lions','tigers','bears'] becomes "['lion','tigers','bears']"
-  #
-  def to_declaration
-    raise StandardError.new('No to_declaration method has been created for '+self.class.to_s) unless self.class.to_s == 'Array'
-    return LiteralDeclaration.new(self.clone)
-  end
-
-  def write
-    raise StandardError.new('No "write" method has been created for '+self.class.to_s) unless self.class.to_s == 'Array'
-    line = '['    
-    self.each do |x|
-      line += x.write
-      unless x.object_id == self.last.object_id then line += ', ' end
-    end
-    line += ']'
-    return line    
-  end
-
-  def copy
-    raise StandardError.new('No "copy" method has been created for '+self.class.to_s) unless self.class.to_s == 'Array'    
-    result = []
-    self.each {|x| result.push(x.copy) }
-    return result
-  end
-  
-  def to_literal
-    return Literal.new(self.copy.collect {|x| x.to_literal})  
-  end
-  
-  # This is a variation on the 'any?' except if the array contains an array
-  # it continue the search into that array.
-  # 
-  # @param  &block    The block that evaluates if something exists in the array
-  #
-  # TODO  This method could probably be cleaned up a bit
-  #
-  def contains?(&block)
-    self.each do |x|
-      if x.respond_to?(:contains?) 
-        if x.contains?(&block)
-          return true
-        end
-      end
-      return true if block.call(x)
-    end
-    return false
-  end
-  
-  # Returns all the elements that match the selection criteria just 
-  # like the select method.  However if it contains an array it
-  # will seach the array as well.
-  # 
-  # @param  results       An array of current results that match the requirement
-  #                       of the block.
-  # @param  block         .
-  #
-  def select_all(results=[],&block)
-    self.each do |x|
-      if block.call(x)
-        results.push(x)
-      end
-      if x.respond_to?(:select_all) 
-        x.select_all(results,&block)  
-      end
-    end
-    return results
-  end  
-  
-  def to_intrinsic
-    # TODO  SHould be all? not any?
-    return IntrinsicTestCases.new if self.any? {|x| x.kind_of?(CTestCase)}  
-    raise StandardError.new('Can not be converted to intrinsic instance '+self.class.to_s)
-  end
-  
-end

data/lib/ruby_code/Fixnum.rb

@@ -1,39 +0,0 @@
-class Fixnum
-  
-  def to_var(id=nil,uniq_id=nil)
-    return FixnumVariable.new(self,id) {{:variable_id => id,:uniq_id=>uniq_id}}
-  end  
-  
-  def copy
-    return self
-  end
-  
-  def to_declaration
-    return LiteralDeclaration.new(self)    
-  end
-  
-  def write
-    return self.to_s
-  end  
-  
-  def describe
-    write
-  end
-  
-  def to_literal
-    return Literal.new(self)
-  end
-  
-  def to_literal_string
-    return write
-  end
-  
-  def cauldron_method_calls
-    return ['.kind_of?']
-  end
-  
-  def to_intrinsic
-    return IntrinsicLiteral.new(self)  
-  end
-    
-end

data/lib/ruby_code/Hash.rb

@@ -1,25 +0,0 @@
-class Hash
-  
-  def write
-    #raise StandardError.new('No "write" method has been created for '+self.class.to_s) unless self.class.to_s == 'Hash'
-    line = '{' 
-    count = 0
-    self.each do |x,y|
-      line += x.write+'=>'+y.write
-      count += 1 
-      next if count == self.length
-      line += ','
-    end
-    line += '}'
-    return line    
-  end
-  
-  def copy
-    raise StandardError.new('No "copy" method has been created for '+self.class.to_s) unless self.class.to_s == 'Hash'    
-    return self.inject({}) do |x,(key,value)|
-      x[key] = value
-      x
-    end
-  end
-  
-end

data/lib/ruby_code/NilClass.rb

@@ -1,19 +0,0 @@
-class NilClass
-  
-  def to_var(id=nil)
-    return NilVariable.new(id) {{:variable_id => id,:uniq_id=>nil}}
-  end
-  
-  def to_declaration
-    return LiteralDeclaration.new(nil)
-  end
-  
-  def write
-    return 'nil'
-  end
-  
-  def copy
-    return self
-  end
-  
-end

data/lib/ruby_code/Object.rb

@@ -1,24 +0,0 @@
-class Object
-  
-  # This is a more useful 'public_methods' since it excludes 
-  # the standard methods inheritated from the Object super
-  # class.
-  #
-  #def uniq_public_methods
-  #  obj = Object.new
-  #  return self.public_methods - obj.public_methods
-  #end
-  
-  # Use p406
-  # Example.private_instance_methods(false)
-  # Example.public_instance_methods(false)
-  
-  def instance_call_structures
-    return []
-  end
-  
-  def cauldron_method_calls
-    return []
-  end    
-  
-end

data/lib/ruby_code/String.rb

@@ -1,63 +0,0 @@
-class String
-  
-  def copy
-    return self.clone
-  end
-  
-  def declaration_statement
-    return Statement.new(self.to_s)
-  end
-  
-  def write
-    x = self.escape_single_quotes
-    return '\''+x+'\''
-  end
-  
-  def instance_call_structures
-    return [
-      InstanceCallContainerStructure.new(StringVariable,Chop.new),
-      InstanceCallContainerStructure.new(StringVariable,StringLength.new)
-      ]
-  end
-  
-  #
-  # @param  id    You can specify the id of the newly created variable
-  #
-  def to_var(var_id=nil,unique_id=nil)
-    return StringVariable.new(self,var_id){{:variable_id => var_id,:uniq_id=>unique_id}}
-  end
-  
-  def to_declaration
-    return LiteralDeclaration.new(self.clone)
-  end
-
-  def to_literal_string
-    return write
-  end
-  
-  def to_literal
-    return Literal.new(self.clone)
-  end 
-  
-  # Returns a statement declaring a variable with the value of
-  # this string e.g. 
-  #
-  # 'Sparky'.to_declaration_statement -> var_x = 'Sparky'
-  #
-  def to_declared_variable_statement
-    return Statement.new(StringVariable.new(self),Equal.new,self.to_declaration)
-  end
-    
-  # http://snippets.dzone.com/posts/show/880
-  # TODO  There is a BASH command `quote` and `quote_readline` that
-  # might be more useful here.
-  def escape_single_quotes
-    return self.gsub(/[']/, '\\\\\'')    
-  end
-  
-  def cauldron_method_calls
-    return ['.length']
-  end
-  
-end
-

data/lib/ruby_code/Symbol.rb

@@ -1,7 +0,0 @@
-class Symbol
-  
-  def write
-    return ':'+self.to_s
-  end
-  
-end

data/lib/standard_library/Tasks.rb

@@ -1,12 +0,0 @@
-class Tasks
-  include TSort  
-  
-  def initialize
-    @dependencies = []
-  end
-  
-  def add_dependency(task,*relies_on)
-    
-  end
-  
-end

data/lib/theories.rb

@@ -1,166 +0,0 @@
-
-# TODO  Not so keen on loading each theory in super - rather do it in the methods
-#        it is needed.
-
-# TODO Allot of this functionalty should be moved to the rake tasks  
-
-module ContainsTheories
-
-  def setup
-    @theory_1 = Theory.load_theory(1)
-    @theory_2 = Theory.load_theory(2)
-    @theory_3 = theory_3    
-  end
-  
-  def theory_3
-    
-    dependent_one = TheoryDependent.new(
-      StringToTheory.run(
-        "if(var1.realise2(var2[var3][:params]).params[0].value.length == var2[var3][:output])\nreturn true\nend"
-      )
-    )
-    action_one = TheoryAction.new(
-      TheoryStatement.new(
-        StringToTheory.run(
-          'Statement.new(Return.new,InstanceCallContainer.new(var1.params[0],StringLength.new))'
-        )             
-      ),
-      StringToTheory.run("var1.statement_id") 
-    )
-    result_one = TheoryResult.new(
-      StringToTheory.run("if(var1.all_pass?(var2))\nreturn true\nend"),true
-    )      
-    Theory.new([dependent_one],action_one,[result_one]) 
-        
-    
-  end
-  
-  def load_theory_implementation(implementation_id)
-    directory_path = $LOC+File.join('test','fixtures','theory_implementations',implementation_id.to_s)
-    raise StandardError.new("Theory fixture #{implementation_id} does not exist") unless(File.exists?(directory_path))
-    dump_file = File.open(File.join(directory_path,'dump'),'r')
-    return Marshal.load(dump_file.read)
-  end
-  
-  def create_theory_implementation
-    
-    theory = Theory.load_theory(6)
-    potential_values = [
-        Parser.run('test_cases[0][:params][0]'),
-        Parser.run('test_cases[0][:params]'),
-        Parser.run('test_cases[0][:output]'),
-        Parser.run('test_cases[0]'),
-        Parser.run('test_cases'),
-        Parser.run('runtime_method')
-    ]
-    results = theory.rewrite_permutations(potential_values)
-    # NOTE: Rember use grep -A and -B to match particular cases
-    implemented_theory = results[332]
-    return implemented_theory
-    
-  end
-  
-  def save_theory_implementation(implementation_id,theory_id,implementation=nil)
-    StandardLogger.instance.warning("Caution: Creating new theory implementation #{implementation_id}")
-    directory_path = $LOC+File.join('test','fixtures','theory_implementations',implementation_id.to_s)
-    if(File.exists?(directory_path))
-      StandardLogger.instance.warning("Theory Implementation ficture already exists #{theory_id} -cancelling")
-      return
-    else
-      FileUtils.mkdir_p(directory_path)
-    end 
-    
-    if implementation.nil? then implementation = create_theory_implementation end
-    
-    desc_file = File.open(File.join(directory_path,'desc.txt'),'w')
-    desc_file << implementation.describe
-    desc_file.close    
-    
-    dump_file = File.open(File.join(directory_path,'dump'),'w')
-    data = Marshal.dump(implementation)
-    dump_file << data
-    dump_file.close
-    
-    dump_file = File.open(File.join(directory_path,'theory_id'),'w')
-    dump_file << theory_id.to_s
-    dump_file.close    
-    
-  end
-  
-  def load_implementation_result(result_id)
-    directory_path = $LOC+File.join('test','fixtures','implementation_results',result_id.to_s)
-    raise StandardError.new("ImplementationResult fixture #{result_id} does not exist") unless(File.exists?(directory_path))
-    dump_file = File.open(File.join(directory_path,'dump'),'r')
-    return Marshal.load(dump_file)    
-  end
-  
-  # This method is used on to create a theory fixture for use in the test
-  def create_theory
-    
-    theory_id = "16"
- 
-    StandardLogger.instance.warning("NOTE: Creating new theory fixture #{theory_id.to_s}")
-    # Does a directory for this theory fixture already exist.
-    directory_path = $LOC+File.join('test','fixtures','theories',theory_id.to_s)
-    if(File.exists?(directory_path))
-      StandardLogger.instance.warning("Theory ficture already exists #{theory_id.to_s} -cancelling")
-      return
-    else
-      
-      # Create the directory
-      FileUtils.mkdir_p(directory_path)
-      
-    end
-    
-    # This is just updated here - nothing fancy
-    declaration = %q!
-    dependent_one = TheoryDependent.new(
-      StringToTheory.run(
-        "if(var1.kind_of?(RuntimeMethod))\nreturn true\nend"
-      )
-    )     
-    dependent_two = TheoryDependent.new(
-      StringToTheory.run(
-        "if(var3[var4].kind_of?(CTestCase))\nreturn true\nend"
-      )
-    )     
-    action = TheoryAction.new(
-      TheoryStatement.new(
-        StringToTheory.run(
-          'BlockStatement.new(Statement.new(InstanceCallContainer.new(Container.new(InstanceCallContainer.new(var1.params[var2],StringLength.new),Subtract.new,1),Times.new)))'
-        )
-      ),
-      StringToTheory.run('var1.statement_id')
-    )
-    result_one = TheoryResult.new(
-      StringToTheory.run(
-        "if(var1.history2(var3[var4]).select {|x| x['statement_id'] == var3.last.statement_id} == var3[var4][:params][var2].length-1)\nreturn true\nend"
-      )
-    )
-      Theory.new(
-        [dependent_one,dependent_two],
-        action,
-        [result_one]
-      )    
-    !
-    
-    # Save the declaration (incase the theory needs modified
-    declaration_file = File.open(File.join(directory_path,'declaration.txt'),'w+')
-    declaration_file << declaration
-    declaration_file.close    
-    
-    theory = eval declaration
-    data = Marshal.dump(theory)
-
-    # TODO  Shouldn't include colours for this description
-    desc_file = File.open(File.join(directory_path,'desc'),'w+')
-    desc_file << theory.describe
-    desc_file.close
-    
-    dump_file = File.open(File.join(directory_path,'dump'),'w+')
-    dump_file << data
-    dump_file.close
-
-  end  
-
-end