nudge 0.0.2 → 0.1.0

data/lib/interpreter/nudge_program.rb

@@ -0,0 +1,253 @@
+#encoding: utf-8
+require 'treetop'
+Treetop.load(File.join(File.dirname(__FILE__),'grammars', "nudge_codeblock.treetop"))
+
+
+module Nudge
+  class NudgeProgram
+
+    attr_accessor :linked_code,:footnotes
+    attr_accessor :raw_code
+    attr_accessor :code_section, :footnote_section
+    attr_reader :parser
+    attr_reader :points
+    
+    
+    def initialize(sourcecode)
+      raise(ArgumentError, "NudgeProgram.new should be passed a string") unless sourcecode.kind_of?(String)
+      @raw_code = sourcecode
+      program_split!
+      @parser = NudgeCodeblockParser.new
+      relink_code!
+      @points = self.points
+    end
+    
+    
+    
+    def program_split!
+      split_at_first_guillemet=@raw_code.partition( /^(?=«)/ )
+      @code_section = split_at_first_guillemet[0].strip
+      @footnote_section = split_at_first_guillemet[2].strip
+      @footnotes = tokenized_footnote_section
+    end
+    
+    
+    
+    def tokenized_footnote_section
+      shattered = @footnote_section.split( /^(?=«)/ )
+      breaker = /^«([a-zA-Z][a-zA-Z0-9_]*)»\s*(.*)\s*/m
+      pairs = shattered.collect {|fn| fn.match(breaker)[1..2]}
+      fn = Hash.new {|hash, key| hash[key] = [] }
+      @footnote_order = []
+      pairs.each do |key,value|
+        fn[key.to_sym] << value.strip
+      end
+      return fn
+    end
+    
+    
+    
+    def relink_code!
+      if parses?
+        @linked_code = @parser.parse(@code_section).to_point
+        depth_first_association!
+      else
+        @linked_code = NilPoint.new
+      end
+    end
+    
+    
+    
+    def depth_first_association!(program_point=@linked_code)
+      if program_point.kind_of?(ValuePoint)
+        program_point.raw = @footnotes[program_point.type].shift
+        if program_point.raw != nil
+          if program_point.type == :code
+            program_point.raw << pursue_more_footnotes(program_point.raw)
+          end
+        end
+      elsif program_point.kind_of?(CodeblockPoint)
+        program_point.contents.each {|branch| depth_first_association!(branch)}
+      end
+    end
+    
+    
+    
+    def pursue_more_footnotes(codepoint_as_string, collected_footnotes = "")
+      local_footnotes = ""
+      if self.contains_valuepoints?(codepoint_as_string)
+        local_parsetree = @parser.parse(codepoint_as_string)
+        if local_parsetree != nil
+          local_subtree = local_parsetree.to_point
+          if local_subtree.kind_of?(CodeblockPoint)
+            local_subtree.contents.each do |branch|
+              local_footnotes << pursue_more_footnotes(branch.tidy)
+            end
+          elsif local_subtree.kind_of?(ValuePoint)
+            local_subtree.raw = @footnotes[local_subtree.type].shift
+            if local_subtree.raw != nil
+              local_footnotes = "\n«#{local_subtree.type}» #{local_subtree.raw}"
+              if local_subtree.type == :code
+                local_footnotes << pursue_more_footnotes(local_subtree.raw,collected_footnotes)
+              end
+            end
+          end
+        end
+      end
+      return collected_footnotes + local_footnotes
+    end
+    
+    
+    
+    def unused_footnotes
+      leftovers = []
+      @footnotes.each do |key,val|
+        val.each {|fn| leftovers << "«#{key.to_s}» #{fn.strip}"}
+      end
+      return leftovers
+    end
+    
+    
+    
+    def [](which)
+      raise ArgumentError,"Cannot retrieve #{which}th program point" if which < 1
+      raise ArgumentError,"Cannot retrieve #{which}th program point" if which > self.points
+      if which == 1
+        result = @linked_code
+      else
+        result = @linked_code.each_with_index do |node,index|
+          break(node) if index == which-1
+        end
+      end
+      return result
+    end
+    
+    
+    
+    def deep_copy
+      NudgeProgram.new(self.blueprint)
+    end
+    
+    
+    
+    def replace_point(which,new_junk)
+      raise ArgumentError,"Cannot replace #{which}th program point" if which < 1
+      raise ArgumentError,"Cannot replace #{which}th program point" if which > self.points
+      raise ArgumentError,"Cannot insert #{new_junk.class}" unless new_junk.kind_of?(ProgramPoint)
+      
+      result = self.deep_copy
+      
+      if which == 1
+        result.linked_code = new_junk
+      else
+        to_replace = result[which]
+        parent = result.linked_code.detect do |wrapper|
+          wrapper.contents.include?(to_replace) if wrapper.respond_to?(:contents)
+        end
+        parent_index = parent.contents.find_index(to_replace)
+        parent.contents[parent_index] = new_junk
+      end
+      
+      result.cleanup_strings_from_linked_code!
+      return result
+    end
+    
+    
+    
+    def insert_point_before(which, new_junk)
+      raise ArgumentError,"Cannot insert at #{which}th position" if which < 1
+      raise ArgumentError,"Cannot insert before #{which}th program point" if which > (self.points+1)
+      raise ArgumentError,"Cannot insert #{new_junk.class}" unless new_junk.kind_of?(ProgramPoint)
+      
+      copy = self.deep_copy
+      
+      case which
+      when 1
+        copy.linked_code = CodeblockPoint.new([new_junk, copy.linked_code])
+      when copy.points+1
+        copy.linked_code = CodeblockPoint.new([copy.linked_code, new_junk])
+      else
+        stick_before_this = copy[which]
+        parent_node = copy.linked_code.detect do |wrapper|
+          wrapper.contents.include?(stick_before_this) if wrapper.respond_to?(:contents)
+        end
+        parent_index = parent_node.contents.find_index(stick_before_this)
+        parent_node.contents.insert(parent_index, new_junk)
+      end
+      copy.cleanup_strings_from_linked_code!
+      return copy
+    end
+    
+    
+    
+    def delete_point(which)
+      raise ArgumentError,"Cannot delete #{which}th program point" if which < 1
+      raise ArgumentError,"Cannot delete #{which}th program point" if which > self.points
+      
+      if which == 1
+        result = NudgeProgram.new("block {}")
+        result.footnotes = self.footnotes
+      else
+        result = self.deep_copy
+        to_delete = result[which]
+        parent = result.linked_code.detect do |wrapper|
+          wrapper.contents.include?(to_delete) if wrapper.respond_to?(:contents)
+        end
+        parent_index = parent.contents.find_index(to_delete)
+        parent.contents.delete_at(parent_index)
+      end
+      
+      result.cleanup_strings_from_linked_code!
+      return result
+    end
+    
+    
+    
+    def cleanup_strings_from_linked_code!
+      @raw_code = self.blueprint
+      split_at_first_guillemet=@raw_code.partition( /^(?=«)/ )
+      @code_section = split_at_first_guillemet[0].strip
+      @footnote_section = split_at_first_guillemet[2].strip
+    end
+    
+    
+    
+    def parses?(program_blueprint = @code_section)
+      (@parser.parse(program_blueprint) != nil)
+    end
+    
+    
+    
+    def tidy
+      framework = NudgeCodeblockParser.new.parse(@code_section)
+      framework ? framework.tidy : ""
+    end
+    
+    
+    
+    def blueprint
+      if @linked_code.kind_of? NilPoint
+        return ""
+      else
+        code_section, footnote_section = @linked_code.blueprint_parts
+        unused_footnotes.each {|fn| footnote_section += "\n#{fn}"}
+        return (code_section.strip + " \n" + footnote_section.strip).strip
+      end
+    end
+    
+    
+    def contains_codevalues?(program_blueprint = @raw_code)
+      (program_blueprint =~ /value\s*«code»/) != nil
+    end
+    
+    def contains_valuepoints?(program_blueprint = @raw_code)
+      (program_blueprint =~ /value\s*«[\p{Alpha}][_\p{Alnum}]*»/) != nil
+    end
+    
+    
+    
+    def points
+      return @linked_code ? @linked_code.points : 0
+    end
+  end
+end

data/lib/interpreter/parse.tab.rb

@@ -0,0 +1,264 @@
+# encoding: utf-8
+
+# DO NOT MODIFY!!!!
+# This file is automatically generated by racc 1.4.5
+# from racc grammer file "parse.y".
+#
+
+require 'racc/parser'
+require 'strscan'
+
+
+class NudgeTree < Racc::Parser
+
+module_eval <<'..end parse.y modeval..ida1760a43d7', 'parse.y', 22
+  def self.from(string)
+    nt = NudgeTree.new(string)
+    result = nt.send(:do_parse)
+    {tree:result, unused:nt.footnotes}
+  end
+  
+  attr_accessor :footnotes
+  
+  def initialize(string)
+    @tokens = []
+    @string = string.strip
+    @footnotes = Hash.new { |hash, category| hash[category] = [] }
+    
+    self.make_footnotes!
+    self.tokenize!
+  end
+  
+  def make_footnotes!
+    return unless split_point = @string.index(/^«/)
+    raise ParseError, "No program string" if split_point == 0
+    
+    ss = StringScanner.new(@string.slice!((split_point - 1)..-1))
+    
+    while ss.scan(/\n/)
+      @footnotes[ss.scan(/«[\p{Alpha}][_\p{Alnum}]*»/u)[1..-2]] << ss.scan(/[^\n]*/).strip # <-- /\n«/
+    end
+  end
+  
+  def pop_footnote(category)
+    value = @footnotes[category].shift
+    
+    if category == "code"
+      embedded_footnotes = [""]
+      self.collect_embedded_footnotes!(value, embedded_footnotes)
+      value += embedded_footnotes.join("\n")
+    end
+    
+    return value
+  end
+  
+  def collect_embedded_footnotes!(code_text, embedded_footnotes)
+    ss = StringScanner.new(code_text)
+    
+    while ss.skip_until(/«[\p{Alpha}][\p{Alnum}_]*»/)
+      category = ss.matched[1...-1]
+      footnote = @footnotes[category].shift
+      
+      embedded_footnotes << "«#{category}»#{footnote}"
+      
+      if category == "code"
+        self.collect_embedded_footnotes!(footnote, embedded_footnotes)
+      end
+    end
+  end
+  
+  def next_token
+    return @tokens.shift
+  end
+  
+  def tokenize!
+    ss = StringScanner.new(@string)
+    
+    until ss.eos?
+      @tokens << case c = ss.getch
+        when /\s/
+          nil
+        when /[{}«»]/
+          [c, 0]
+        when /[\p{Alpha}]/
+          ss.pointer -= 1
+          ss.scan(/[\p{Alpha}][\p{Alnum}_]*/)  # <- \p{Alpha}
+          
+          case m = ss.matched
+            when "block", "ref", "do", "value"
+              [m, 0]
+            else
+              [:ID, m]
+          end
+        else
+          raise ParseError, "Couldn't tokenize program string"
+      end
+    end
+    
+    @tokens.compact!
+    @tokens << [false, false]
+  end
+  
+  def on_error(error_token_id, error_value, value_stack)
+    raise ParseError, "Couldn't parse program string"
+  end
+
+..end parse.y modeval..ida1760a43d7
+
+##### racc 1.4.5 generates ###
+
+racc_reduce_table = [
+ 0, 0, :racc_error,
+ 4, 12, :_reduce_1,
+ 2, 12, :_reduce_2,
+ 2, 12, :_reduce_3,
+ 4, 12, :_reduce_4,
+ 1, 13, :_reduce_5,
+ 2, 13, :_reduce_6,
+ 0, 13, :_reduce_7 ]
+
+racc_reduce_n = 8
+
+racc_shift_n = 18
+
+racc_action_table = [
+     2,    10,     9,     3,     8,     4,     5,     2,    11,    16,
+     3,     2,     4,     5,     3,     7,     4,     5,    14,     6,
+    17 ]
+
+racc_action_check = [
+     0,     5,     4,     0,     3,     0,     0,    13,     6,    13,
+    13,     7,    13,    13,     7,     2,     7,     7,    10,     1,
+    14 ]
+
+racc_action_pointer = [
+    -2,    19,    12,    -2,    -4,    -8,     8,     9,   nil,   nil,
+    12,   nil,   nil,     5,    10,   nil,   nil,   nil ]
+
+racc_action_default = [
+    -8,    -8,    -8,    -8,    -8,    -8,    -8,    -7,    -2,    -3,
+    -8,    18,    -5,    -8,    -8,    -6,    -1,    -4 ]
+
+racc_goto_table = [
+     1,    13,   nil,   nil,   nil,   nil,   nil,    12,   nil,   nil,
+   nil,   nil,   nil,    15 ]
+
+racc_goto_check = [
+     1,     2,   nil,   nil,   nil,   nil,   nil,     1,   nil,   nil,
+   nil,   nil,   nil,     1 ]
+
+racc_goto_pointer = [
+   nil,     0,    -6 ]
+
+racc_goto_default = [
+   nil,   nil,   nil ]
+
+racc_token_table = {
+ false => 0,
+ Object.new => 1,
+ "block" => 2,
+ "{" => 3,
+ "}" => 4,
+ "ref" => 5,
+ :ID => 6,
+ "do" => 7,
+ "value" => 8,
+ "«" => 9,
+ "»" => 10 }
+
+racc_use_result_var = true
+
+racc_nt_base = 11
+
+Racc_arg = [
+ racc_action_table,
+ racc_action_check,
+ racc_action_default,
+ racc_action_pointer,
+ racc_goto_table,
+ racc_goto_check,
+ racc_goto_default,
+ racc_goto_pointer,
+ racc_nt_base,
+ racc_reduce_table,
+ racc_token_table,
+ racc_shift_n,
+ racc_reduce_n,
+ racc_use_result_var ]
+
+Racc_token_to_s_table = [
+'$end',
+'error',
+'"block"',
+'"{"',
+'"}"',
+'"ref"',
+'ID',
+'"do"',
+'"value"',
+'"«"',
+'"»"',
+'$start',
+'statement',
+'statements']
+
+Racc_debug_parser = false
+
+##### racc system variables end #####
+
+ # reduce 0 omitted
+
+module_eval <<'.,.,', 'parse.y', 5
+  def _reduce_1( val, _values, result )
+ result = CodeblockPoint.new(val[2])
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'parse.y', 6
+  def _reduce_2( val, _values, result )
+ result = ReferencePoint.new(val[1])
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'parse.y', 7
+  def _reduce_3( val, _values, result )
+ result = InstructionPoint.new(val[1])
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'parse.y', 8
+  def _reduce_4( val, _values, result )
+ result = ValuePoint.new(val[2], self.pop_footnote(val[2]))
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'parse.y', 11
+  def _reduce_5( val, _values, result )
+ result = [val[0]]
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'parse.y', 12
+  def _reduce_6( val, _values, result )
+ result = val[0] << val[1]
+   result
+  end
+.,.,
+
+module_eval <<'.,.,', 'parse.y', 13
+  def _reduce_7( val, _values, result )
+ result = []
+   result
+  end
+.,.,
+
+ def _reduce_none( val, _values, result )
+  result
+ end
+
+end   # class NudgeTree