cauldron 0.1.0

data/lib/ruby_code/Fixnum.rb

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

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

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

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

@@ -0,0 +1,86 @@
+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
+  
+  # TODO  Write tests
+  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
+  
+  # TODO  This might have been superceeded by "to_declaration"
+  def creation
+    return self.write
+  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 
+  
+  # TODO  Write tests
+  # Returns a requirement instance declaring this as a literal.
+  #
+  # Example 'test'.to_requirement -> Requirement.new(This.new,Equivalent.new,'test'.to_literal)
+  #
+  def to_requirement
+    return Requirement.new(This.new,Equivalent.new,self.to_literal)
+  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
+    # TODO   I don't properly follow this
+    return self.gsub(/[']/, '\\\\\'')    
+  end
+  
+  def cauldron_method_calls
+    return ['.length']
+  end  
+
+protected
+  
+  def identify(x)
+    # Check if it is a assignment
+    
+  end
+  
+end
+

data/lib/ruby_code/Symbol.rb

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

data/lib/standard_library/Tasks.rb

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

data/lib/theories.rb

@@ -0,0 +1,143 @@
+
+# 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.load_theory(3)    
+  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

data/lib/theory/ActionImplementation.rb

@@ -0,0 +1,17 @@
+class ActionImplementation < TheoryAction
+  
+  attr_reader :target_id
+  
+  def initialize(statement,target_id,theory_component_id=nil)
+    super(statement,target_id,theory_component_id)
+  end
+  
+  def copy
+    return ActionImplementation.new(@action.copy,@target_id.copy,@theory_component_id)
+  end
+  
+  def write(tab=0)
+    return ("\t"*tab)+"runtime_method.add_statement_at(#{@action.write},#{@target_id.write})"
+  end    
+  
+end

data/lib/theory/TheoryAction.rb

@@ -0,0 +1,70 @@
+# The theory action represents the what theory inserts into the 
+# main runtime method.
+#
+class TheoryAction
+  include TheoryComponent
+  
+  attr_reader :target_id, :action
+  # 
+  # @param  action          A statement to insert into the main runtime method.
+  #                         e.g. action.write => "return var8"
+  # @param  target_id       The id of the nested statement or method to add the generated statement to.
+  # 
+  def initialize(action,target_id,theory_component_id=nil)
+    raise StandardError.new('Expecting theory statement but was '+action.class.to_s) unless action.kind_of?(TheoryStatement)
+    @action = action
+    @target_id = target_id
+    @theory_component_id = theory_component_id unless theory_component_id.nil?    
+    generate_theory_component_id
+  end
+   
+  # Provide a general description of the action, explaining the statement
+  # it will add to the runtime method and where.  This is pseudo code
+  # and shouldn't be interpretted at runtime.  Use "write" for runtime
+  # actions.
+  #
+  # @param  tab     
+  #    
+  def describe(tab=0)
+    # TODO  That is nicer way to do tabs - I should make the other methods consistent with it
+    return ("\t"*tab)+"<runtime_method>.add_statement_at(#{@action.describe},#{@target_id.describe})"
+  end
+  
+  def write(tab=0)
+    return ("\t"*tab)+"<runtime_method>.add_statement_at(#{@action.write},#{@target_id.write})"
+  end
+  
+  # Returns all the theory vairables in this theory action 
+  #
+  def theory_variables
+    return @action.select_all {|x| x.kind_of?(TheoryVariable)}
+  end
+  
+  # Returns a action implementation with the theory variable declarations replaced with
+  # the values in the mapping hash. 
+  # 
+  def map_to(mapping)
+    
+    # Duplicate the current statement before it is rewritten
+    rewritten_statement = @action.copy
+    target_id = @target_id.copy
+    
+    # Find all containers of VariableDeclarations that declare a TheoryVariable
+    containers = [rewritten_statement,target_id].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 ActionImplementation.new(rewritten_statement,target_id,@theory_component_id)
+    
+  end  
+  
+  def copy
+    return TheoryAction.new(@action.copy,@target_id,@theory_component_id)
+  end
+  
+  
+end