nudge 0.0.2 → 0.1.0

data/lib/interpreter/programPoints.rb

@@ -1,52 +1,52 @@
+#encoding: utf-8
 module Nudge
+  include Enumerable
   
   class ProgramPoint
     def points
       1
     end
+    
+    def each
+      yield self
+    end
   end
   
   
-  class CodeBlock < ProgramPoint
-    @@parser = NudgeLanguageParser.new
-    
-    def initialize(code = "block {}")
-      @listing = code
+  class NilPoint < ProgramPoint
+    def blueprint_parts
+      ["",""]
     end
     
-    def listing=(rawCode)
-      @listing = rawCode
+    def blueprint
+      ""
     end
     
-    def listing
-      @listing ||= "block {}"
+    def tidy
+      ""
     end
     
-    def value
-      @listing
+    def go(context = nil)
     end
     
-    def contents=(newArray)
-      @contents = newArray
-    end
-    
-    def contents
-      @contents ||= self.reparse
+    def points
+      0
     end
+  end
+  
+  
+  
+  
+  class CodeblockPoint < ProgramPoint
+    attr_accessor :contents
     
-    def reparse
-      clone = @@parser.parse(@listing).to_points
-      @listing = clone.listing
-      return clone.contents
+    def initialize(contents = [])
+      raise(ArgumentError,"CodeblockPoint must be passed an Array") unless contents.kind_of?(Array)
+      @contents = contents
     end
     
     def points
-      if @contents
-        @listing.split(/\n/).length
-      else
-        self.reparse
-        @listing.split(/\n/).length
-      end
+      @contents.inject(1) {|count, daughter| count + daughter.points}
     end
     
     def go(context)
@@ -60,101 +60,107 @@ module Nudge
       tt += "}"
       return tt
     end
+    
+    def blueprint_parts
+      fn = self.contents.inject("\n") do |fn_accumulator, branch|
+        rhs = branch.blueprint_parts[1].empty? ? "" :  "\n#{branch.blueprint_parts[1]}"
+        fn_accumulator + rhs
+      end
+      return [self.tidy, fn.strip]
+    end
+    
+    def blueprint
+      t,b = blueprint_parts
+      return "#{t} \n#{b}".strip
+    end
+    
+    def each
+      yield self
+      @contents.each do |child|
+        child.each {|c| yield c}
+      end
+    end
   end
   
   
-  class LiteralPoint < ProgramPoint
-    attr_accessor :type, :value
+  
+  
+  class ValuePoint < ProgramPoint
+    attr_accessor :type, :raw
+    attr_reader :value
     
-    def initialize(type,value)
+    def initialize(type,representation=nil)
+      raise(ArgumentError, "Type must be a symbol or string") unless [Symbol,String].include?(type.class)
       @type = type.to_sym
-      @value = value
+      if representation != nil
+        representation = representation.to_s
+      end
+      @raw = representation
     end
     
     def go(context)
+      raise(UnassignedValuePointError, "#{self.type} point has no value string") if self.value == nil
       context.stacks[self.type].push(self)
+      rescue UnassignedValuePointError => exc
+        msg = ValuePoint.new("error", exc.message)
+        context.stacks[:error].push msg
     end
     
-    def tidy(level=1)
-      "literal " + @type.to_s + " (" + @value.to_s + ")"
-    end
     
-    def randomize(context)
-      raise(ArgumentError,"Random code cannot be created") if context.types == [CodeType]
-      newType = context.types.sample
-      @type = newType.to_nudgecode
-      if newType != CodeType
-        @value = newType.any_value
-      else
-        @value = newType.any_value(context)
-      end
+    class UnassignedValuePointError < RuntimeError
     end
     
-    def self.any(context)
-      tmp = LiteralPoint.new("int", 1)
-      tmp.randomize(context)
-      return tmp
+    
+    def clone
+      ValuePoint.new(@type, @raw.dup)
     end
     
-    def listing
-      self.tidy
+    
+    def points
+      1
     end
-  end
-  
-  
-  class Erc < ProgramPoint
-    attr_accessor :type, :value
-    def initialize(type, value)
-      @type = type.to_sym
-      @value = value
+    
+    def nudgetype(typename=@type)
+      "#{typename.to_s.camelize}Type"
     end
     
-    def to_literal()
-      LiteralPoint.new(@type,@value)
+    def nudgetype_defined?(typename=@type)
+      Nudge.const_defined?(nudgetype(typename).to_sym)
     end
     
-    def go(context)
-      self.to_literal.go(context)
+    def value
+      if @raw && nudgetype_defined?
+        @value ||= nudgetype.constantize.from_s(@raw)
+      else
+        @raw
+      end
     end
     
     def tidy(level=1)
-      "sample " + @type.to_s + " (" + @value.to_s + ")"
+      "value «" + @type.to_s + "»"
     end
     
     def randomize(context)
       newType = context.types.sample
       @type = newType.to_nudgecode
-      if newType != CodeType
-        @value = newType.any_value
-      else
-        @value = newType.any_value(context)
-      end
+      @raw = newType.any_value
     end
     
-    def resample
-      @value = "#{@type.to_s.capitalize}Type".constantize.any_value
+    def blueprint_parts
+      fn = @raw ? "«#{self.type}» #{self.raw}" : ""
+      return [self.tidy, fn]
     end
     
-    def self.any(context)
-      tmp = Erc.new(context.types[0].to_s.slice(0..-5).downcase,0)
-      tmp.randomize(context)
-      return tmp
-    end
-    
-    def listing
-      self.tidy
+    def blueprint
+      pts = self.blueprint_parts
+      return "value «#{self.type}» \n«#{self.type}» #{self.raw.strip}".strip
     end
   end
   
   
-  class ChannelPoint < ProgramPoint
-    
-    def self.any(context)
-      tmp = ChannelPoint.new("e")
-      tmp.randomize(context)
-      return tmp
-    end
-    
+  
+  
+  class ReferencePoint < ProgramPoint    
     attr_accessor :name
     alias value name
     
@@ -163,15 +169,19 @@ module Nudge
     end
     
     def go(context)
-      lookedUp = context.lookup(@name) if context.evaluate_channels
+      lookedUp = context.lookup(@name) if context.evaluate_references
       if lookedUp
         context.stacks[:exec].push(lookedUp)
       else
         context.stacks[:name].push(self)
-        context.evaluate_channels = true
+        context.evaluate_references = true
       end
     end
     
+    def points
+      1
+    end
+    
     def tidy(level=1)
       "ref " + @name
     end
@@ -181,12 +191,19 @@ module Nudge
       @name = which
     end
     
-    def listing
-      self.tidy
+    def blueprint_parts
+      [self.tidy,""]
+    end
+    
+    def blueprint
+      return self.tidy
     end
+    
   end
   
   
+  
+  
   class InstructionPoint < ProgramPoint
     attr_accessor :name, :requirements, :effects
     def initialize(name)
@@ -200,21 +217,26 @@ module Nudge
     def classLookup
       self.className.constantize
     rescue NameError
-      raise InstructionNotFoundError, "#{self.className} not found"
+      raise InstructionNotFoundError, "#{self.className} is not an active instruction in this context"
     end
     
     def tidy(level=1)
       "do " + @name
     end
     
+    def points
+      1
+    end
+    
     class InstructionNotFoundError < NameError
     end
     
     def go(context)
       className = self.classLookup
       context.instructions_library[className].go
-    rescue InstructionNotFoundError
-      return
+    rescue InstructionNotFoundError => exc
+      msg = ValuePoint.new("error", exc.message)
+      context.stacks[:error].push msg
     end
     
     def randomize(context)
@@ -222,15 +244,14 @@ module Nudge
       @name = instructionName.slice(0..-12).underscore
     end
     
-    def self.any(context)
-      tmp = InstructionPoint.new("int_add")
-      tmp.randomize(context)
-      return tmp
+    def blueprint_parts
+      [self.tidy,""]
     end
     
-    def listing
-      self.tidy
+    def blueprint
+      return self.tidy
     end
+    
   end
   
 end

data/lib/interpreter/types/codeType.rb

@@ -2,110 +2,135 @@
 module NudgeType
   
   class CodeType
-    include TypeBehaviors
+    extend TypeBehaviors
     @@defaultPoints = 20
-  
-    def self.random_skeleton(points=@@defaultPoints, blocks=points/10)
-      blocks = [0,[points,blocks].min].max
-    
-      if points > 1
-        skel = ["block {"]
-        (points-2).times {skel << "*"}
-        skel << "*}"
-        front = 0
-        (blocks-1).times do
-          until skel[front].include?("*") do
-            a,b = rand(points), rand(points)
-            front,back = [a,b].min, [a,b].max
-          end
-          skel[front] = skel[front].sub(/\*/," block {")
-          skel[back] = skel[back] + "}"
-        end
-        skel = skel.join
-      else
-        if blocks>0
-          skel = "block {}"
-        else
-          skel = "*"
-        end
-      end
-      return skel
+    
+    def self.recognizes?(thing)
+      return thing.kind_of?(String)
     end
-  
-  
-    def self.any_type(types)
-      raise(ArgumentError,"no available NudgeTypes") if types.empty?
-      return types.sample
+    
+    
+    def self.from_s(string_value)
+      return string_value.sub(/\(/,"«").sub(/\)/,"»")
     end
-  
-  
-    def self.any_instruction(instructions)
-      raise(ArgumentError,"no available Instructions") if instructions.empty?
-      return instructions.sample
+    
+    def self.any_value(options = {})
+      StringRewritingGenerator.new(options).generate
     end
+  end
   
   
-    def self.any_reference(references)
-      raise(ArgumentError,"no available references") if references.empty?
-      return references.sample
-    end
   
   
-    def self.roulette_wheel(references, instructions, types)
-      basis = Hash["reference", references.length,
-        "instruction", instructions.length,
-        "sample", types.length]
-      sum = basis.values.inject(:+)
-      spin = rand(sum)
-      basis.each do |result,weight|
-        return result if spin <= weight && weight > 0
-        spin -= weight
+  class StringRewritingGenerator
+    attr_accessor :incoming_options
+    attr_accessor :target_size_in_points
+    attr_accessor :probabilities
+    attr_accessor :reference_names
+    attr_accessor :type_names
+    attr_accessor :instruction_names
+    
+    
+    def initialize(options = {})
+      @incoming_options = options
+      @target_size_in_points = options[:target_size_in_points] || 20
+      @probabilities = options[:probabilities] || {b:1, r:1, v:1, i:1}
+      raise(ArgumentError, "probabilities Hash doesn't have necessary keys") unless
+        @probabilities.keys.sort == [:b,:i,:r,:v]
+      @probabilities.values.each {|v| raise(ArgumentError, "probabilities must be positive") if v < 0}
+      raise(ArgumentError, "probability values must be positive") unless
+        @probabilities.values.inject(:+) > 0
+      
+      
+      @reference_names = options[:reference_names] || []
+      @type_names = options[:type_names] ||
+        NudgeType::all_types.collect {|t| t.to_nudgecode.to_s}
+      @instruction_names = options[:instruction_names] ||
+        Instruction.all_instructions.collect {|i| i.to_nudgecode.to_s}
+    end
+    
+    
+    def choose_weighted(normalized_hash)
+      total = @probabilities.values.inject(:+)
+      rand_sample = rand(total)
+      @probabilities.each do |key,value|
+        return key if rand_sample < value
+        rand_sample -= value
       end
-      raise "A problem occurred when executing CodeType#roulette_wheel"
     end
-  
-  
-    def self.random_value(context, params = {})
-      points = params[:points] || @@defaultPoints
-      blocks = params[:blocks] || points/10
-      skeleton = params[:skeleton] || self.random_skeleton(points, blocks)
-      instructions = params[:instructions] || context.instructions
-      references = params[:references] || context.references
-      types = params[:types] || context.types
-    
-      while skeleton.include?("*") do
-        case self.roulette_wheel(references,instructions,types)
-        when "instruction"
-          newPoint = " do " + self.any_instruction(instructions).to_nudgecode
-        when "reference"
-          newPoint = " ref " + self.any_reference(references)
-        when "sample"
-          theType = any_type(types)
-          if theType == CodeType
-            if types != [CodeType]
-              theType = self.any_type(types - [CodeType])
-            else
-              raise ArgumentError, "Random code cannot be created"
-            end
+    
+    
+    def generate
+      top_and_bottom = self.filled_framework
+      return "#{top_and_bottom[:code_part].strip} \n#{top_and_bottom[:footnote_part].strip}".strip
+    end
+    
+    
+    def backbone
+      return "*" * @target_size_in_points
+    end
+    
+    def open_framework(stars = self.backbone)
+      stars[0]= 'b' if stars.length > 1 # because any long framework bust be in a block
+      asteriskless = stars.gsub(/\*/) {|match| choose_weighted(@probabilities).to_s}
+      return asteriskless
+    end
+    
+    
+    def closed_framework(without_braces = self.open_framework)
+      braceless = /[b]([^{])/
+      if without_braces[0] == 'b'
+        without_braces << "}"
+        without_braces.insert(1,'{')
+      end
+      
+      with_some_braces = without_braces
+      while with_some_braces.match(braceless)
+        where = with_some_braces.index(braceless)
+        with_some_braces.insert(where+1, '{')
+        close_position = [where+rand(10)+1,with_some_braces.length].min
+        while with_some_braces[close_position] == '{'
+          close_position += 1
+        end
+        with_some_braces.insert(close_position,'} ')
+      end
+      return with_some_braces
+    end
+    
+    
+    def filled_framework(recipe = self.closed_framework)
+      top, bottom = '',''
+      recipe.chars do |c|
+        case
+        when c == 'b'
+          top << 'block '
+        when c == 'i'
+          top << "do #{instruction_names.sample} "
+        when c == 'r'
+          ref_name = @reference_names.sample || next_name
+          top << "ref #{ref_name} "
+        when c == 'v'
+          begin
+            type_name = @type_names.sample || 'unknown'
+            type_class = "#{type_name}_type".camelize.constantize
+            reduced_size = rand(@target_size_in_points/4)
+            reduced_option = {target_size_in_points:reduced_size}
+            sampled_value = type_class.any_value(@incoming_options.merge(reduced_option)).to_s
+          rescue NameError
+            sampled_value = ""
           end
-          newPoint = " sample " + theType.to_nudgecode + " (" + theType.any_value.to_s + ")"
+          top << "value «#{type_name}» "
+          bottom << "\n«#{type_name}» #{sampled_value}"
         else
-          raise ArgumentError, "Nothing to make random code from"
+          top << c
         end
-        skeleton = skeleton.sub(/\*/, newPoint)
-        skeleton = skeleton.sub(/\n/,'')
       end
-      skeleton
-    end
-  
-  
-  
-    def self.from_s(string_value)
-      return string_value.sub(/\(/,"«").sub(/\)/,"»")
+      return {:code_part => top.strip, :footnote_part => bottom.strip}
     end
-  
-    def self.any_value(context)
-      self.random_value(context)
+    
+    
+    def next_name
+      @next_name = (@next_name || "aaa000").succ
     end
   end
 end

data/lib/interpreter/types/pushTypes.rb

@@ -7,7 +7,7 @@ module NudgeType
   end
   
   def self.push_types
-    [IntType, BoolType, FloatType]
+    [IntType, BoolType, FloatType, CodeType]
   end
   
   module TypeBehaviors
@@ -22,6 +22,10 @@ module NudgeType
     def from_s(some_string)
       raise "This class must implement #{self.inspect}.from_s"
     end
+    
+    def recognizes?(some_representation)
+      raise "This class should implement #{self.inspect}.recognizes?"
+    end
 
     def any_value
       raise "This class must implement #{self.inspect}.any_value"
@@ -32,13 +36,10 @@ module NudgeType
     end
   end
   
-  class BasicType
-    def self.inherited(subclass)
-      subclass.extend TypeBehaviors
-    end
-  end
   
-  class IntType < Fixnum
+  
+  
+  class IntType
     extend TypeBehaviors
     @defaultLowest = -100
     @defaultHighest = 100
@@ -61,15 +62,19 @@ module NudgeType
     def self.from_s(string_value)
       return string_value.to_i
     end
+    
+    def self.recognizes?(a_thing)
+      !a_thing.kind_of?(String) && !a_thing.nil? && a_thing.respond_to?(:to_i)
+    end
 
-    def self.any_value
-      self.random_value
+    def self.any_value(options ={})
+      self.random_value(options)
     end
   end
-
-
-
-
+  
+  
+  
+  
   class BoolType
     extend TypeBehaviors
 
@@ -81,16 +86,20 @@ module NudgeType
     def self.from_s(string_value)
       string_value.downcase == "true" ? true : false
     end
-
-    def self.any_value
-      self.random_value
+    
+    def self.recognizes?(a_thing)
+      a_thing.kind_of?(TrueClass) || a_thing.kind_of?(FalseClass)
+    end
+    
+    def self.any_value(options ={})
+      self.random_value(options)
     end
   end
 
 
 
 
-  class FloatType < Float
+  class FloatType
     extend TypeBehaviors
 
     @defaultLowest = -1000.0
@@ -107,9 +116,13 @@ module NudgeType
     def self.from_s(string_value)
       return string_value.to_f
     end
-
-    def self.any_value
-      self.random_value
+    
+    def self.recognizes?(a_thing)
+      !a_thing.kind_of?(String) && !a_thing.nil? && a_thing.respond_to?(:to_f)
+    end
+    
+    def self.any_value(options ={})
+      self.random_value(options)
     end
   end
 end