red 3.0.0

data/lib/red.rb

@@ -0,0 +1,161 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'parse_tree'
+require 'lib/red/assignment_nodes'
+require 'lib/red/call_nodes'
+require 'lib/red/conditional_nodes'
+require 'lib/red/conjunction_nodes'
+require 'lib/red/constant_nodes'
+require 'lib/red/control_nodes'
+require 'lib/red/data_nodes'
+require 'lib/red/definition_nodes'
+require 'lib/red/errors'
+require 'lib/red/illegal_nodes'
+require 'lib/red/literal_nodes'
+require 'lib/red/variable_nodes'
+require 'lib/red/wrap_nodes'
+
+module Red
+  @@red_library = nil
+  @@red_module  = nil
+  @@red_class   = nil
+  @@rescue_is_safe = false
+  @@exception_index = 0
+  
+  ARRAY_NODES = {
+    :and          => ConjunctionNode::AndNode,
+    :argscat      => IllegalNode::MultipleAssignmentNode,
+    :argspush     => IllegalNode::MultipleAssignmentNode,
+    :array        => LiteralNode::ArrayNode,
+    :attrasgn     => AssignmentNode::AttributeNode,
+    :begin        => ControlNode::BeginNode,
+    :block        => LiteralNode::MultilineNode,
+    :block_arg    => IllegalNode::BlockArgument,
+    :block_pass   => IllegalNode::BlockArgument,
+    :break        => ConstantNode::BreakNode,
+    :call         => CallNode::MethodNode::ExplicitNode,
+    :case         => ConditionalNode::CaseNode,
+    :class        => DefinitionNode::ClassNode,
+    :cdecl        => AssignmentNode::GlobalVariableNode,
+    :colon2       => LiteralNode::NamespaceNode,
+    :colon3       => ControlNode::LibraryNode,
+    :const        => VariableNode::OtherVariableNode,
+    :cvar         => VariableNode::ClassVariableNode,
+    :cvasgn       => AssignmentNode::ClassVariableNode,
+    :cvdecl       => AssignmentNode::ClassVariableNode,
+    :dasgn        => AssignmentNode::LocalVariableNode,
+    :dasgn_curr   => AssignmentNode::LocalVariableNode,
+    :defined      => WrapNode::DefinedNode,
+    :defn         => DefinitionNode::InstanceMethodNode,
+    :defs         => DefinitionNode::ClassMethodNode,
+    :dot2         => LiteralNode::RangeNode,
+    :dot3         => LiteralNode::RangeNode::ExclusiveNode,
+    :dregx        => IllegalNode::RegexEvaluationNode,
+    :dregx_once   => IllegalNode::RegexEvaluationNode,
+    :dstr         => LiteralNode::StringNode,
+    :dsym         => IllegalNode::SymbolEvaluationNode,
+    :dvar         => VariableNode::OtherVariableNode,
+    :dxstr        => LiteralNode::StringNode,
+    :ensure       => ControlNode::EnsureNode,
+    :evstr        => LiteralNode::StringNode,
+    :false        => ConstantNode::FalseNode,
+    :fcall        => CallNode::MethodNode::ImplicitNode,
+    :flip2        => IllegalNode::FlipflopNode,
+    :flip3        => IllegalNode::FlipflopNode,
+    :for          => ControlNode::ForNode,
+    :gasgn        => AssignmentNode::GlobalVariableNode,
+    :gvar         => VariableNode::GlobalVariableNode,
+    :hash         => LiteralNode::HashNode,
+    :iasgn        => AssignmentNode::InstanceVariableNode,
+    :if           => ConditionalNode::IfNode,
+    :iter         => CallNode::BlockNode,
+    :ivar         => VariableNode::InstanceVariableNode,
+    :lasgn        => AssignmentNode::LocalVariableNode,
+    :lvar         => VariableNode::OtherVariableNode,
+    :lit          => LiteralNode::OtherNode,
+    :match        => IllegalNode::MatchNode,
+    :match2       => CallNode::MatchNode,
+    :match3       => CallNode::MatchNode::ReverseNode,
+    :masgn        => IllegalNode::MultipleAssignmentNode,
+    :module       => DefinitionNode::ModuleNode,
+    :next         => ConstantNode::NextNode,
+    :nil          => ConstantNode::NilNode,
+    :not          => WrapNode::NotNode,
+    :op_asgn1     => AssignmentNode::OperatorNode::BracketNode,
+    :op_asgn2     => AssignmentNode::OperatorNode::DotNode,
+    :op_asgn_and  => AssignmentNode::OperatorNode::AndNode,
+    :op_asgn_or   => AssignmentNode::OperatorNode::OrNode,
+    :or           => ConjunctionNode::OrNode,
+    :postexe      => IllegalNode::PostexeNode,
+    :redo         => IllegalNode::RedoNode,
+    :rescue       => ControlNode::RescueNode,
+    :retry        => IllegalNode::RetryNode,
+    :return       => WrapNode::ReturnNode,
+    :sclass       => DefinitionNode::ObjectLiteralNode,
+    :scope        => LiteralNode::OtherNode,
+    :self         => ConstantNode::SelfNode,
+    :splat        => LiteralNode::SplatNode,
+    :super        => WrapNode::SuperNode,
+    :svalue       => LiteralNode::OtherNode,
+    :str          => LiteralNode::StringNode,
+    :true         => ConstantNode::TrueNode,
+    :undef        => IllegalNode::UndefNode,
+    :until        => ControlNode::UntilNode,
+    :vcall        => VariableNode::OtherVariableNode,
+    :when         => ConditionalNode::WhenNode,
+    :while        => ControlNode::WhileNode,
+    :xstr         => LiteralNode::StringNode,
+    :yield        => WrapNode::YieldNode,
+    :zarray       => LiteralNode::ArrayNode,
+    :zsuper       => WrapNode::SuperNode
+  }
+  
+  DATA_NODES = {
+    Bignum        => DataNode::OtherNode,
+    Fixnum        => DataNode::OtherNode,
+    Float         => DataNode::OtherNode,
+    Range         => DataNode::RangeNode,
+    Regexp        => DataNode::OtherNode,
+    Symbol        => DataNode::SymbolNode,
+    String        => DataNode::StringNode,
+    NilClass      => DataNode::NilNode
+  }
+  
+  def build_node # :nodoc:
+    case self
+    when Array
+      raise(BuildError::UnknownNode, "Don't know how to handle sexp type :#{self.first}") unless ARRAY_NODES[self.first]
+      return ARRAY_NODES[self.first].new(*self[1..-1])
+    else
+      return DATA_NODES[self.class].new(self)
+    end
+  rescue => e
+    self.handle_red_error(e)
+  end
+  
+  def build_nodes  # :nodoc:
+    self.map {|node| node.build_node}
+  end
+  
+  def compile_nodes(options = {}) # :nodoc:
+    self.map {|node| node.compile_node(options)}
+  end
+  
+  def string_to_node # :nodoc:
+    self.translate_to_sexp_array.build_node
+  rescue SyntaxError => e
+    self.handle_red_error(e)
+  end
+  
+  def translate_to_sexp_array # :nodoc:
+    raise TypeError, "Can only translate Strings" unless self.is_a?(String)
+    ParseTree.translate("::Standard\n" + self)
+  end
+  
+  def handle_red_error(error) # :nodoc:
+    @@red_errors ||= "\nErrors"
+    @@red_errors << "\n%s: %s" % [@@exception_index += 1, error]
+    return DataNode::ErrorNode.new(@@exception_index)
+  end
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the console
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/red.rb'}"
+puts "Loading red gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/txt2html

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+GEM_NAME = 'red' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'red'
+
+require 'rubygems'
+begin
+  require 'newgem'
+  require 'rubyforge'
+rescue LoadError
+  puts "\n\nGenerating the website requires the newgem RubyGem"
+  puts "Install: gem install newgem\n\n"
+  exit(1)
+end
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + "/../lib/#{GEM_NAME}/version.rb"
+
+version  = Red::VERSION::STRING
+download = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+def rubyforge_project_id
+  RubyForge.new.autoconfig["group_ids"][RUBYFORGE_PROJECT]
+end
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.html.erb')
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.html.erb] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text_template = fsrc.read
+  body_text = ERB.new(body_text_template).result(binding)
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)