ruby2lolz 0.0.1

data/README.rdoc

@@ -0,0 +1,38 @@
+Ruby2Lolz translates Ruby code into LOLCODE (http://www.lolcode.com)
+- http://www.igvita.com/2008/12/11/ruby-ast-for-fun-and-profit/
+
+== Translating Ruby Hash & Array:
+  require 'ruby2lolz'
+  # adds Hash.to_lolz, and Array.to_lolz
+
+  puts {:nickname => [:ig, :igrigorik]}.to_lolz
+
+  OH HAI
+    I CAN HAS Nickname
+       I CAN MANY HAZ
+          AWSUM VAR
+             ig
+          KTHNX.
+          AWSUM VAR
+             igrigorik
+          KTHNX.
+      KTHNXBYE.
+    KTHNX.
+  KTHNXBYE.
+
+Put some Lolz into your API
+- http://pastie.org/327494
+
+== Translating a class:
+
+  class Simple
+    def add(n1, n2)
+      return n1 + n2
+    end
+  end
+
+  Ruby2Lolz.translate(Simple, :add)
+
+  HOW DUZ I HAZ add [YR n1, YR n2]
+    (n1 + n2)
+  IF U SAY SO

data/Rakefile

@@ -0,0 +1,19 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "ruby2lolz"
+    gemspec.summary = "Ruby to Lolcode translator, kthnxbai."
+    gemspec.description = gemspec.summary
+    gemspec.email = "ilya@igvita.com"
+    gemspec.homepage = "http://github.com/igrigorik/ruby2lolz"
+    gemspec.authors = ["Ilya Grigorik"]
+    gemspec.add_dependency('ParseTree')
+    gemspec.rubyforge_project = "ruby2lolz"
+  end
+
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/ruby2lolz.rb

@@ -0,0 +1,195 @@
+#!/usr/local/bin/ruby
+# Author: Ilya Grigorik (www.igvita.com)
+
+require "rubygems"
+require "parse_tree"
+require "parse_tree_extensions"
+require "unified_ruby"
+
+class Hash
+  def to_lolz; Ruby2Lolz.translate(self.inspect); end
+end
+
+class Array
+  def to_lolz; Ruby2Lolz.translate(self.inspect); end
+end
+
+class Ruby2Lolz < SexpProcessor
+
+  def self.translate(klass_or_str, method = nil)
+    sexp = ParseTree.translate(klass_or_str, method)
+
+    # unified_ruby is a rewriter plugin that rewires
+    # the parse tree to make it easier to work with
+    #  - defn arg above scope / making it arglist / ...
+    unifier = Unifier.new
+    unifier.processors.each do |p|
+      p.unsupported.delete :cfunc # HACK
+    end
+    sexp = unifier.process(sexp)
+
+    self.new.process(sexp)
+  end
+
+  def initialize
+    super
+    @indent = "  "
+    
+    self.auto_shift_type = true
+    self.strict = true
+    self.expected = String
+  end
+
+  ############################################################
+  # Processors
+
+  def process_lit(exp);   exp.shift.to_s;     end
+  def process_str(exp);   exp.shift.to_s;     end
+  def process_scope(exp); process(exp.shift); end
+  def process_lvar(exp);  exp.shift.to_s;     end
+
+
+  def process_arglist(exp, verbose = false)
+    code = []
+    until exp.empty? do
+      if verbose
+        code.push indent("AWSUM VAR\n #{indent(process(exp.shift))}\nKTHNX.")
+      else
+        code.push process(exp.shift)
+      end
+    end
+    code.join("\n")
+  end
+
+  def process_array(exp)
+    str = "I CAN MANY HAZ\n"
+    str << indent(process_arglist(exp, true))
+    str << "\nKTHNXBYE."
+  end
+
+  def process_hash(exp)
+    result = []
+
+    until exp.empty?
+      lhs = process(exp.shift)
+      rhs = exp.shift
+      t = rhs.first
+      rhs = process rhs
+      rhs = "#{rhs}" unless [:lit, :str].include? t # TODO: verify better!
+
+      result.push indent("I CAN HAS #{lhs.to_s.capitalize}\n #{indent(rhs)}\nKTHNX.")
+    end
+
+    case self.context[1]
+    when :arglist, :argscat then
+      return "#{result.join(', ')}"
+    else
+      return "OH HAI\n#{result.join("\n")}\nKTHNXBYE."
+    end
+  end
+
+  def process_defn(exp)
+    type1 = exp[1].first
+    type2 = exp[2].first rescue nil
+
+    case type1
+    when :scope, :args then
+      name = exp.shift
+      args = process(exp.shift)
+      args = "" if args == "[]"
+      body = indent(process(exp.shift))
+      return "HOW DUZ I HAZ #{name} [#{args}]\n#{body}\nIF U SAY SO"
+    else
+      raise "Unknown defn type: #{type1} for #{exp.inspect}"
+    end   
+  end
+
+  def process_call(exp)
+    receiver_node_type = exp.first.nil? ? nil : exp.first.first
+    receiver = process exp.shift
+
+    name = exp.shift
+    args_exp = exp.shift rescue nil
+    if args_exp && args_exp.first == :array # FIX
+      args = "#{process(args_exp)[1..-2]}"
+    else
+      args = process args_exp
+      args = nil if args.empty?
+    end
+
+    case name
+    when :<=>, :==, :<, :>, :<=, :>=, :-, :+, :*, :/, :%, :<<, :>>, :** then
+      "(#{receiver} #{name} #{args})"
+    when :[] then
+      "#{receiver}[#{args}]"
+    when :"-@" then
+      "-#{receiver}"
+    when :"+@" then
+      "+#{receiver}"
+    else
+      unless receiver.nil? then
+        "#{receiver}.#{name}#{args ? "#{args})" : args}"
+      else
+        "#{name}#{args ? " #{args}" : args}"
+      end
+    end
+  end
+
+  def process_args(exp)
+    args = []
+
+    until exp.empty? do
+      arg = exp.shift
+      case arg
+      when Symbol then
+        args << "YR #{arg}"
+      when Array then
+        case arg.first
+        when :block then
+          asgns = {}
+          arg[1..-1].each do |lasgn|
+            asgns[lasgn[1]] = process(lasgn)
+          end
+
+          args.each_with_index do |name, index|
+            args[index] = asgns[name] if asgns.has_key? name
+          end
+        else
+          raise "unknown arg type #{arg.first.inspect}"
+        end
+      else
+        raise "unknown arg type #{arg.inspect}"
+      end
+    end
+
+    return "#{args.join ', '}"
+  end
+
+  def process_block(exp)
+    result = []
+    exp << nil if exp.empty?
+    until exp.empty? do
+      code = exp.shift
+
+      if code.nil? or code.first == :nil then
+        result << "# do nothing"
+      else
+        result << process(code)
+      end
+    end
+
+    result = result.join "\n"
+    result = case self.context[1]
+    when nil, :scope, :if, :iter, :resbody, :when, :while then
+      result + "\n"
+    else
+      "(#{result})"
+    end
+
+    return result
+  end
+
+  def indent(s)
+    s.to_s.split(/\n/).map{|line| @indent + line}.join("\n")
+  end
+end

data/spec/lolz_spec.rb

@@ -0,0 +1,59 @@
+# LOLZ SPECS v1.2, KTHNXBAI.
+#
+# - http://lolcode.com/specs/1.2
+#
+
+require "rubygems"
+require "parse_tree"
+require "parse_tree_extensions"
+require "spec"
+require "ruby2lolz"
+
+def read_spec(name); File.open("spec/specs/#{name}.txt", "r").read.gsub("\r", ""); end
+
+describe Ruby2Lolz do
+
+  it "should translate Ruby hash to lolz, kthnx" do
+    h = {:user => "Ilya"}.inspect
+    Ruby2Lolz.translate(h).should == read_spec("hash")
+  end
+  
+  it "should translate Ruby hash to lolz, kthnx" do
+    {:user => "Ilya"}.to_lolz.should == read_spec("hash")
+  end
+
+  it "should translate Ruby array to lolz, kthnx" do
+    a = ["igrigorik", "ig"].inspect
+    Ruby2Lolz.translate(a).should == read_spec("array")
+  end
+  
+  it "should translate Ruby array to lolz, kthnx" do
+    ["igrigorik", "ig"].to_lolz.should == read_spec("array")
+  end
+
+  it "should translate mixed Ruby array/hash to lolz, kthnx" do
+    h = {:nickname => ["igrigorik", "ig"]}.inspect
+    Ruby2Lolz.translate(h).should == read_spec("hash_array")
+  end
+  
+  it "should translate mixed Ruby array/hash to lolz, kthnx" do
+    {:nickname => ["igrigorik", "ig"]}.to_lolz.should == read_spec("hash_array")
+  end
+  
+  it "should translate Ruby method to lolz, kthnx" do
+    # [:defn,
+    #  :hello,
+    #  [:scope, [:block, [:args, :str], [:fcall, :puts, [:array, [:lvar, :str]]]]]]
+    class Simple
+      def hello(str); puts str; end;
+    end
+
+    Ruby2Lolz.translate(Simple, :hello).should == read_spec("method")
+  end
+
+  #  it "should translate Ruby block to lolz, kthnx" do
+  #    b = Proc.new {|var| puts var }.to_ruby
+  #    puts Ruby2Lolz.translate(b)
+  #    Ruby2Lolz.translate(b).should == read_spec("block")
+  #  end
+end

data/spec/specs/array.txt

@@ -0,0 +1,8 @@
+I CAN MANY HAZ
+    AWSUM VAR
+       igrigorik
+    KTHNX.
+    AWSUM VAR
+       ig
+    KTHNX.
+KTHNXBYE.

data/spec/specs/hash.txt

@@ -0,0 +1,5 @@
+OH HAI
+  I CAN HAS User
+     Ilya
+  KTHNX.
+KTHNXBYE.

data/spec/specs/hash_array.txt

@@ -0,0 +1,12 @@
+OH HAI
+  I CAN HAS Nickname
+     I CAN MANY HAZ
+        AWSUM VAR
+           igrigorik
+        KTHNX.
+        AWSUM VAR
+           ig
+        KTHNX.
+    KTHNXBYE.
+  KTHNX.
+KTHNXBYE.

data/spec/specs/method.txt

@@ -0,0 +1,3 @@
+HOW DUZ I HAZ hello [YR str]
+  puts str
+IF U SAY SO

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification 
+name: ruby2lolz
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Ilya Grigorik
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-12 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: ParseTree
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Ruby to Lolcode translator, kthnxbai.
+email: ilya@igvita.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/ruby2lolz.rb
+- spec/lolz_spec.rb
+- spec/specs/array.txt
+- spec/specs/hash.txt
+- spec/specs/hash_array.txt
+- spec/specs/method.txt
+has_rdoc: true
+homepage: http://github.com/igrigorik/ruby2lolz
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: ruby2lolz
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Ruby to Lolcode translator, kthnxbai.
+test_files: 
+- spec/lolz_spec.rb