goling 0.1.1 → 0.2.0

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/goling.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{goling}
-  s.version = "0.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = [%q{Patrick Hanevold}]
-  s.date = %q{2011-09-08}
+  s.date = %q{2011-10-07}
   s.description = %q{Goling is a linguistic compiler allowing you to compile and execute plain english.}
   s.email = %q{patrick.hanevold@gmail.com}
   s.extra_rdoc_files = [
@@ -26,6 +26,7 @@ Gem::Specification.new do |s|
     "lib/goling.rb",
     "lib/goling/linguified.rb",
     "lib/goling/reduction.rb",
+    "lib/goling/translators/javascript.rb",
     "test/helper.rb",
     "test/test_goling.rb"
   ]

data/lib/goling.rb

@@ -4,7 +4,13 @@ require 'goling/linguified'
 require 'goling/reduction'
 
 def reduce(regexp,&code)
-  Goling::rules << { :match => regexp.keys[0], :result => regexp.values[0], :proc => code }
+  Goling::rules << {
+    :match  => regexp.keys[0],
+    :result => regexp.values[0].kind_of?(Hash)                                     ? regexp.values[0][:to]     : regexp.values[0],
+    :lang   => regexp.values[0].kind_of?(Hash)                                     ? regexp.values[0][:lang]   : :ruby, 
+    :inline => regexp.values[0].kind_of?(Hash)&&regexp.values[0].has_key?(:inline) ? regexp.values[0][:inline] : false,
+    :proc => code
+  }
 end
 
 module Goling

data/lib/goling/linguified.rb

@@ -1,6 +1,7 @@
 # encoding: utf-8
 
 require 'sourcify'
+require 'goling/translators/javascript'
 
 module Goling
 
@@ -10,26 +11,22 @@ module Goling
 
     def initialize str,bind
 
+      #
+      # reduction loop
+      #
       @sentence = str.dup
       @bind = bind
       loop do
-        found = Goling.rules.select do |rule|
-          if rule[:match] =~ str
-            true
-          else
-            false
-          end
-        end
-        raise "no step definition for #{str}" if found.size == 0
-
-        rule = found[0]
-        match = rule[:match].match(str)
+        rule = find_rule(str)
+        
         reduced = Reduction.new(
           :returns  => rule[:result],
+          :lang     => rule[:lang],
+          :inline   => rule[:inline],
           :location => rule[:proc].source_location[0],
           :line     => rule[:proc].source_location[1],
           :regexp   => rule[:match].inspect,
-          :args     => match.to_a[1..-1],
+          :args     => rule[:match].match(str).to_a[1..-1],
           :sexp     => rule[:proc].to_sexp,
         )
         str.gsub!(rule[:match],reduced.to_rexp)
@@ -40,8 +37,10 @@ module Goling
 
       @merged_code = []
       if /^{(?<code>.*)}$/ =~ @encoded
+        # successfully reduced entire string, compile it
         code = Reduction::parse(code).compile_with_return_to_var(nil)
 
+        # and wrap it up
         @sexy = Sexp.new(:block,
           Sexp.new(:lasgn,:code, Sexp.new(:iter,
             Sexp.new(:call, nil, :lambda, Sexp.new(:arglist)), nil,
@@ -50,23 +49,40 @@ module Goling
               )
             )
           ),
-          Sexp.new(:call, Sexp.new(:colon2, Sexp.new(:const, :Goling), :Linguified), :trampoline, Sexp.new(:arglist, Sexp.new(:lvar, :code)))
         )
 
         @@me = self
-        eval to_ruby,bind
+        eval to_ruby(
+            Sexp.new(:call,
+              Sexp.new(:colon2, Sexp.new(:const, :Goling), :Linguified), :trampoline, Sexp.new(:arglist, Sexp.new(:lvar, :code))
+            )
+          ),bind
         raise "hell" unless @proc      
       else
         raise "hell"
       end
     end
-  
+    
+    def find_rule str
+      found = Goling.rules.select do |rule|
+        if rule[:match] =~ str
+          true
+        else
+          false
+        end
+      end
+      raise "no step definition for #{str}" if found.size == 0
+
+      found[0]
+    end
+
     def to_sexp
       @sexy
     end
 
-    def to_ruby
+    def to_ruby additional=nil
       clone = Marshal.load(Marshal.dump(@sexy)) # sexy is not cleanly duplicated
+      clone << additional if additional
       Ruby2Ruby.new.process(clone)
     end
     

data/lib/goling/reduction.rb

@@ -1,15 +1,30 @@
 # encoding: utf-8
 
 module Goling
+  
+  class Replacement
+    attr_reader :sexp
+
+    def initialize args
+      @sexp   = args[:sexp]
+      @inline = args[:inline] || false
+    end
+    
+    def inline?
+      @inline
+    end
+  end
 
   class Reduction
 
-    attr_accessor :returns, :location, :line, :regexp, :args, :sexp, :rule_args, :from, :reduction_id
+    attr_accessor :returns, :location, :line, :regexp, :args, :sexp, :rule_args, :from, :reduction_id, :lang, :inline, :named_args
 
     @@reductions = []
 
     def initialize params
       @returns  = params[:returns]
+      @lang     = params[:lang]
+      @inline   = params[:inline]
       @location = params[:location]
       @line     = params[:line]
       @regexp   = params[:regexp]
@@ -17,133 +32,172 @@ module Goling
       @args     = params[:args]
       @sexp     = params[:sexp]
       @reduction_id = @@reductions.size
+      determine_arguments
       @@reductions << self
     end
 
+    def determine_arguments
+      s = Marshal.load(Marshal.dump(self)) # sexp handling is not clean cut
+      raise "what is this?" unless s.sexp[0] == :iter && s.sexp[1][0] == :call && s.sexp[1][1] == nil && s.sexp[1][2] == :proc && s.sexp[1][3][0] == :arglist
+
+      block_args = s.sexp[2]
+      if block_args
+        if block_args[0]==:lasgn
+          # single argument
+          args = [block_args[1]]
+        elsif block_args[0]==:masgn
+          # multiple arguments
+          args = block_args[1]
+          raise "unsupported argument type #{args}" unless args[0]==:array
+          args = args[1..-1].map{ |arg|
+            raise "unsupported argument type #{arg}" unless arg[0]==:lasgn
+            arg[1]
+          }
+        else
+          raise "unsupported argument type #{args}"
+        end
+      end
+      # args[] now has the symbolized argument names of the code block
+      @named_args = Hash[*args.zip(@args).flatten] if args
+      @named_args ||= {}
+    end
+
     def self.parse str
       if /^{(?<return>[^:]*):(?<rid>[0-9]+)}$/ =~ str
         @@reductions[rid.to_i]
       elsif /^(?<return>[^:]*):(?<rid>[0-9]+)$/ =~ str
         @@reductions[rid.to_i]
       else
-  ap str
-  raise "hell"
+        raise "hell #{str}"
       end
     end
 
+    # Compile self
+    #
+    # * +return_variable+ - The return variable. Can either be a symbol representing the variable name or nil to skip variable assigning.
+    # * +replace+         - A list of variables in need of a new unique name or replacement with inlined code
+    #
     def compile_with_return_to_var(return_variable, replace = {})
       s = Marshal.load(Marshal.dump(self)) # sexp handling is not clean cut
-      raise "what is this?" unless s.sexp[0] == :iter && s.sexp[1][0] == :call && s.sexp[1][1] == nil && s.sexp[1][2] == :proc && s.sexp[1][3][0] == :arglist
+      args = @named_args.keys
+      # args[] now has the symbolized argument names of the code block
 
-      block_args = s.sexp[2]
-      #ap "block args: #{block_args}"
-        if block_args
-          if block_args[0]==:lasgn
-            # single argument
-            args = [block_args[1]]
-          elsif block_args[0]==:masgn
-            # multiple arguments
-            args = block_args[1]
-            raise "unsupported argument type #{args}" unless args[0]==:array
-            args = args[1..-1].map{ |arg|
-              raise "unsupported argument type #{arg}" unless arg[0]==:lasgn
-              arg[1]
-            }
-          else
-            raise "unsupported argument type #{args}"
-          end
-          unless s.rule_args.size == args.size
-            raise "number of arguments in reduction rule (#{s.rule_args}) do not match the number of block arguments (#{args.size}) at #{s.location}:#{s.line}"
-          end
-          # args[] now has the symbolized argument names of the code block
-
-          args_code = []
-          s.args.each_with_index do |arg,i|
-            if /^{(?<ret>[^:]*):(?<n>[0-9]+)}$/ =~ arg
-              args_code += Reduction::parse(arg).compile_with_return_to_var("#{ret}_#{n}".to_sym,replace)
-            elsif /^[0-9]+$/ =~ arg
-              args_code << Sexp.new(:lasgn, args[i], Sexp.new(:lit, arg.to_i))
-            else
-              raise "hell"
-            end
-          end
-          s.args.each_with_index do |arg,i|
-            if /^{(?<ret>[^:]*):(?<n>[0-9]+)}$/ =~ arg
-              replace[args[i]] = "#{ret}_#{n}".to_sym
-            end
-          end
-
-          if s.sexp[3][0] == :block
-            if return_variable
-              code = Sexp.new(:lasgn, return_variable, Sexp.new(:block,
-                  *(s.sexp[3][1..-1].map{ |s| s.dup })
-                  )
+      args_code = []
+      s.args.each_with_index do |arg,i|
+        if /^{(?<ret>[^:]*):(?<n>[0-9]+)}$/ =~ arg
+          # got a argument that referes to a reduction
+          # pseudo allocate a return variable name and compile the reduction
+          red = Reduction::parse(arg)
+          if red.lang != lang && red.lang == :js && lang == :ruby
+            # paste javascript code into a ruby variable
+            code = red.compile_with_return_to_var(nil,replace)
+            clone = Marshal.load(Marshal.dump(code)) # code is not cleanly duplicated
+            code = Sexp.new(:iter,Sexp.new(:call, nil, :lambda, Sexp.new(:arglist)), nil,
+              Sexp.new(:block,
+                *clone
               )
-            else
-              code = s.sexp[3].dup
-            end
-            replace.each do |k,v|
-              replace_variable_references(code,v,k)
-            end
-            return *args_code + [code]
+            )
+            code = Ruby2Js.new.process(code)
+            code = [Sexp.new(:lasgn, args[i], Sexp.new(:lit, code))]
+            args_code += code
           else
-            if return_variable
-              code = Sexp.new(:lasgn, return_variable, s.sexp[3].dup)
+            raise "trying to reference #{red.lang} code in #{lang} code" if red.lang != lang
+            if red.inline
+              code = red.compile_with_return_to_var(nil,replace)
+              replace[args[i]] = Replacement.new(:sexp => Sexp.new(:block,*code), :inline => true, :rule => rule)
             else
-              code = s.sexp[3].dup
-            end
-            replace.each do |k,v|
-              replace_variable_references(code,v,k)
+              code = red.compile_with_return_to_var("#{ret}_#{n}".to_sym,replace)
+              args_code += code
+              replace[args[i]] = Replacement.new(:sexp => "#{ret}_#{n}".to_sym)
             end
-            return *args_code + [code]
           end
+        elsif /^[0-9]+$/ =~ arg
+          # got a number argument, stuff it in a integer variable
+          args_code << Sexp.new(:lasgn, args[i], Sexp.new(:lit, arg.to_i))
         else
-          raise "number of arguments in reduction rule do not match the number of block arguments" unless s.rule_args.size == 0
-          # code block without arguments
-          if s.sexp[3][0] == :block
-            if return_variable
-              code = Sexp.new(:lasgn, return_variable, Sexp.new(:block,
-                *(s.sexp[3][1..-1].map{ |s| s.dup })
-                )
-              )
-            else
-              code = s.sexp[3].dup
-            end
-            replace.each do |k,v|
-              replace_variable_references(code,v,k)
-            end
-            [code]
-          else
-            if return_variable
-              code = Sexp.new(:lasgn, return_variable, s.sexp[3].dup)
-            else
-              code = s.sexp[3].dup
-            end
-            replace.each do |k,v|
-              replace_variable_references(code,v,k)
-            end
-            [code]
-          end
+          raise "hell"
         end
+      end
+
+      if return_variable
+        if s.sexp[3][0] == :block
+          code = Sexp.new(:lasgn, return_variable,
+            Sexp.new(:block,
+              *(s.sexp[3][1..-1].map{ |s| s.dup })
+            )
+          )
+        else
+          code = Sexp.new(:lasgn, return_variable, s.sexp[3].dup)
+        end
+      else
+        code = s.sexp[3].dup
+      end
+
+      replace.each do |k,v|
+        replace_variable_references(code,v,k)
+      end
+
+      return *args_code + [code]
     end
 
+    # Recurcively replace all references in a code section
+    #
+    # * +code+        - The code haystack to search and replace in
+    # * +replacement+ - The replacement code. Either a Sexp (containing code to inline) or a symbol
+    # * +needle+      - The search needle
+    #
     def replace_variable_references(code,replacement,needle)
+
+      #inline = replacement.kind_of?(Sexp)
+
       case code[0]
       when :lasgn
-        code[1]=replacement if code[1] == needle
+        code[1]=replacement.sexp if code[1] == needle
       when :lvar
-        code[1]=replacement if code[1] == needle
+        if code[1] == needle
+          unless replacement.inline?
+            code[1]=replacement.sexp
+          end
+        end
       when :call
-        code[2]=replacement if code[2] == needle
+        code[2]=replacement.sexp if code[2] == needle
       when :lvar
-        code[1]=replacement if code[1] == needle
+        code[1]=replacement.sexp if code[1] == needle
       end
-      code[1..-1].each do |h|
-        replace_variable_references(h,replacement,needle) if h && h.kind_of?(Sexp)
+      # inlining requires complex code:
+      if replacement.inline? && [:iter, :block].include?(code[0])
+        # we have a inline and a block, replace any references with the sexp
+        code[1..-1].each_with_index do |h,i|
+          if h && h.kind_of?(Sexp) && h == Sexp.new(:lvar, needle)
+            # inline references like s(:lvar, :needle)
+            # indicates a call to the needle, thus code wants to inline
+            h[0] = replacement.sexp[0]
+            h[1] = replacement.sexp[1]
+          elsif h && h.kind_of?(Sexp) && @named_args.has_key?(needle) &&
+              Reduction.parse(@named_args[needle]).named_args.select{ |k,v|
+                h == Sexp.new(:call, Sexp.new(:lvar, needle), :[], Sexp.new(:arglist, Sexp.new(:lit, k)))
+              }.size == 1
+            # code is asking for a injection of one of the argument's with:
+            #  s(:call, s(:lvar, :needle), :[], s(:arglist, s(:lit, :argumen)))
+            # which in ruby looks like:
+            #  needle[:argument]
+            # which again is the way we support calling arguments of the neede
+            arg = h[3][1][1]
+            sexy = Marshal.load(Marshal.dump(Reduction.parse(Reduction.parse(@named_args[needle]).named_args[arg]).sexp)) # sexp handling is not clean cut
+            code[i+1] = sexy[3]
+          else
+            replace_variable_references(h,replacement,needle) if h && h.kind_of?(Sexp)
+          end
+        end
+      else
+        code[1..-1].each do |h|
+          replace_variable_references(h,replacement,needle) if h && h.kind_of?(Sexp)
+        end
       end
     end
 
     def to_rexp
+      raise "hell" if returns.kind_of?(Array)
       "{#{returns}:#{reduction_id}}"
     end
   end

data/lib/goling/translators/javascript.rb

@@ -0,0 +1,503 @@
+
+require 'sexp_processor'
+
+class Ruby2Js < SexpProcessor
+  VERSION = '1.3.1'
+  LINE_LENGTH = 78
+
+  BINARY = [:<=>, :==, :<, :>, :<=, :>=, :-, :+, :*, :/, :%, :<<, :>>, :**]
+
+  ##
+  # Nodes that represent assignment and probably need () around them.
+  #
+  # TODO: this should be replaced with full precedence support :/
+
+  ASSIGN_NODES = [
+                  :dasgn,
+                  :flip2,
+                  :flip3,
+                  :lasgn,
+                  :masgn,
+                  :attrasgn,
+                  :op_asgn1,
+                  :op_asgn2,
+                  :op_asgn_and,
+                  :op_asgn_or,
+                  :return,
+                  :if, # HACK
+                 ]
+
+  def initialize
+    super
+    @indent = "  "
+    self.auto_shift_type = true
+    self.strict = true
+    self.expected = String
+
+    @calls = []
+
+    # self.debug[:defn] = /zsuper/
+  end
+
+  def parenthesize exp
+    case self.context[1]
+    when nil, :scope, :if, :iter, :resbody, :when, :while, :until then
+      exp
+    else
+      "(#{exp})"
+    end
+  end
+
+  def indent(s)
+    s.to_s.split(/\n/).map{|line| @indent + line}.join("\n")
+  end
+
+  def cond_loop(exp, name)
+    cond = process(exp.shift)
+    body = process(exp.shift)
+    head_controlled = exp.shift
+
+    body = indent(body).chomp if body
+
+    code = []
+    if head_controlled then
+      code << "#{name}(#{cond}){"
+      code << body if body
+      code << "}"
+    else
+      code << "begin"
+      code << body if body
+      code << "end #{name} #{cond}"
+    end
+    code.join("\n")
+  end
+
+  def process_and(exp)
+    parenthesize "#{process exp.shift} and #{process exp.shift}"
+  end
+
+  def process_arglist(exp) # custom made node
+    code = []
+    until exp.empty? do
+      code << process(exp.shift)
+    end
+    code.join ', '
+  end
+
+  def process_args(exp)
+    args = []
+
+    until exp.empty? do
+      arg = exp.shift
+      case arg
+      when Symbol then
+        args << 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_array(exp)
+    "[#{process_arglist(exp)}]"
+  end
+  
+  def process_attrasgn(exp)
+    receiver = process exp.shift
+    name = exp.shift
+    args = exp.empty? ? nil : exp.shift
+
+    case name
+    when :[]= then
+      rhs = process args.pop
+      "#{receiver}[#{process(args)}] = #{rhs}"
+    else
+      name = name.to_s.sub(/=$/, '')
+      if args && args != s(:arglist) then
+        "#{receiver}.#{name} = #{process(args)}"
+      end
+    end
+  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\n"
+      else
+        result << process(code)
+      end
+    end
+
+    result = parenthesize result.join ";\n"
+    result += ";\n" unless result.start_with? "("
+
+    return result
+  end
+
+  def process_break(exp)
+    val = exp.empty? ? nil : process(exp.shift)
+    # HACK "break" + (val ? " #{val}" : "")
+    if val then
+      "break #{val}"
+    else
+      "break"
+    end
+  end
+
+  def process_call(exp)
+str = exp.inspect
+    receiver_node_type = exp.first.nil? ? nil : exp.first.first
+    receiver = process exp.shift
+    receiver = "(#{receiver})" if ASSIGN_NODES.include? receiver_node_type
+
+    name = exp.shift
+    args = []
+    raw = []
+
+    # this allows us to do both old and new sexp forms:
+    exp.push(*exp.pop[1..-1]) if exp.size == 1 && exp.first.first == :arglist
+
+    @calls.push name
+
+    in_context :arglist do
+      until exp.empty? do
+        arg_type = exp.first.sexp_type
+        e = exp.shift
+        raw << e.dup
+        arg = process e
+
+        next if arg.empty?
+
+        strip_hash = (arg_type == :hash and
+                      not BINARY.include? name and
+                      (exp.empty? or exp.first.sexp_type == :splat))
+        wrap_arg = Ruby2Ruby::ASSIGN_NODES.include? arg_type
+
+        arg = arg[2..-3] if strip_hash
+        arg = "(#{arg})" if wrap_arg
+
+        args << arg
+      end
+    end
+#str+
+    case name
+    when *BINARY then
+      "(#{receiver} #{name} #{args.join(', ')})"
+    when :[] then
+      receiver ||= "self"
+      if raw.size == 1 && raw.first.sexp_type == :lit && raw.first.to_a[1].kind_of?(Symbol)
+        "#{receiver}.#{args.first[1..-1]}"
+      else
+        "#{receiver}[#{args.join(', ')}]"
+      end
+    when :[]= then
+      receiver ||= "self"
+      rhs = args.pop
+      "#{receiver}[#{args.join(', ')}] = #{rhs}"
+    when :"-@" then
+      "-#{receiver}"
+    when :"+@" then
+      "+#{receiver}"
+    when :new
+      args     = nil                   if args.empty?
+      args     = "(#{args.join(',')})" if args
+      receiver = "#{receiver}"         if receiver
+
+      "#{name} #{receiver}#{args}"
+    when :lambda
+      receiver = "#{receiver}."        if receiver
+
+      "#{receiver}function"
+    else
+      args     = nil                 if args.empty?
+      args     = "#{args.join(',')}" if args
+      receiver = "#{receiver}."      if receiver
+
+      "#{receiver}#{name}(#{args})"
+    end
+  ensure
+    @calls.pop
+  end
+  
+  def process_const(exp)
+    exp.shift.to_s
+  end
+
+  def process_defn(exp)
+    type1 = exp[1].first
+    type2 = exp[2].first rescue nil
+
+    if type1 == :args and [:ivar, :attrset].include? type2 then
+      name = exp.shift
+      case type2
+      when :ivar then
+        exp.clear
+        return "attr_reader #{name.inspect}"
+      when :attrset then
+        exp.clear
+        return "attr_writer :#{name.to_s[0..-2]}"
+      else
+        raise "Unknown defn type: #{exp.inspect}"
+      end
+    end
+
+    case type1
+    when :scope, :args then
+      name = exp.shift
+      args = process(exp.shift)
+      args = "" if args == "()"
+      body = []
+      until exp.empty? do
+        body << indent(process(exp.shift))
+      end
+      body = body.join("\n")
+      return "#{exp.comments}#{name}#{args}{\n#{body}\n}".gsub(/\n\s*\n+/, "\n")
+    else
+      raise "Unknown defn type: #{type1} for #{exp.inspect}"
+    end
+  end
+
+  def process_hash(exp)
+    result = []
+
+    until exp.empty?
+      e = exp.shift
+      if e.sexp_type == :lit
+        lhs = process(e)
+        rhs = exp.shift
+        t = rhs.first
+        rhs = process rhs
+        rhs = "(#{rhs})" unless [:lit, :str, :array, :iter].include? t # TODO: verify better!
+
+        result << "\n#{lhs[1..-1]}: #{rhs}"
+      else
+        lhs = process(e)
+        rhs = exp.shift
+        t = rhs.first
+        rhs = process rhs
+        rhs = "(#{rhs})" unless [:lit, :str].include? t # TODO: verify better!
+
+        result << "\n#{lhs}: #{rhs}"
+      end
+    end
+
+    return "{ #{indent(result.join(', '))} }"
+  end
+
+  def process_iasgn(exp)
+    lhs = exp.shift
+    if exp.empty? then # part of an masgn
+      lhs.to_s
+    else
+      if lhs.to_s[0] == '@'
+        "self.#{lhs.to_s[1..-1]} = #{process exp.shift}"
+      else
+        "#{lhs} = #{process exp.shift}"
+      end
+    end
+  end
+
+  def process_if(exp)
+    expand = Ruby2Ruby::ASSIGN_NODES.include? exp.first.first
+    c = process exp.shift
+    t_type = exp.first.sexp_type
+    t = process exp.shift
+    f_type = exp.first.sexp_type if exp.first
+    f = process exp.shift
+
+    c = "(#{c.chomp})" #if c =~ /\n/
+
+    if t then
+      #unless expand then
+      #  if f then
+      #    r = "#{c} ? (#{t}) : (#{f})"
+      #    r = nil if r =~ /return/ # HACK - need contextual awareness or something
+      #  else
+      #    r = "#{t} if #{c}"
+      #  end
+      #  return r if r and (@indent+r).size < LINE_LENGTH and r !~ /\n/
+      #end
+
+      r = "if#{c}{\n#{indent(t)}#{[:block, :while, :if].include?(t_type) ? '':';'}\n"
+      r << "}else{\n#{indent(f)}#{[:block, :while, :if].include?(f_type) ? '':';'}\n" if f
+      r << "}"
+
+      r
+    elsif f
+      unless expand then
+        r = "#{f} unless #{c}"
+        return r if (@indent+r).size < LINE_LENGTH and r !~ /\n/
+      end
+      "unless #{c} then\n#{indent(f)}\nend"
+    else
+      # empty if statement, just do it in case of side effects from condition
+      "if #{c} then\n#{indent '# do nothing'}\nend"
+    end
+  end
+
+  def process_iter(exp)
+    iter = process exp.shift
+    args = exp.shift
+    args = (args == 0) ? '' : process(args)
+    body = exp.empty? ? nil : process(exp.shift)
+
+    b, e = #if iter == "END" then
+             [ "{", "}" ]
+           #else
+          #   [ "do", "end" ]
+          # end
+
+    iter.sub!(/\(\)$/, '')
+
+    result = []
+    result << "#{iter}(#{args})"
+    result << "#{b}"
+    result << "\n"
+    if body then
+      result << indent(body.strip)
+      result << "\n"
+    end
+    result << e
+    result.join
+  end
+
+  def process_ivar(exp)
+    "this.#{exp.shift.to_s[1..-1]}"
+  end
+
+  def process_lasgn(exp)
+    s = "#{exp.shift}"
+    s += " = #{process exp.shift}" unless exp.empty?
+    s
+  end
+
+  def process_lit(exp)
+    obj = exp.shift
+    case obj
+    when Range then
+      "(#{obj.inspect})"
+    else
+      obj.inspect
+    end
+  end
+
+  def process_lvar(exp)
+    exp.shift.to_s
+  end
+
+  def process_masgn(exp)
+    lhs = exp.shift
+    rhs = exp.empty? ? nil : exp.shift
+
+    case lhs.first
+    when :array then
+      lhs.shift
+      lhs = lhs.map do |l|
+        case l.first
+        when :masgn then
+          "(#{process(l)})"
+        else
+          process(l)
+        end
+      end
+    when :lasgn then
+      lhs = [ splat(lhs.last) ]
+    when :splat then
+      lhs = [ :"*" ]
+    else
+      raise "no clue: #{lhs.inspect}"
+    end
+
+    if context[1] == :iter and rhs then
+      lhs << splat(rhs[1])
+      rhs = nil
+    end
+
+    unless rhs.nil? then
+      t = rhs.first
+      rhs = process rhs
+      rhs = rhs[1..-2] if t == :array # FIX: bad? I dunno
+      return "#{lhs.join(", ")} = #{rhs}"
+    else
+      return lhs.join(", ")
+    end
+  end
+
+  def process_nil(exp)
+    "null"
+  end
+
+  def process_return(exp)
+    if exp.empty? then
+      return "return"
+    else
+      return "return #{process exp.shift}"
+    end
+  end
+
+  def process_scope(exp)
+    exp.empty? ? "" : process(exp.shift)
+  end
+
+  def process_true(exp)
+    "true"
+  end
+
+  def process_until(exp)
+    cond_loop(exp, 'until')
+  end
+
+  def process_while(exp)
+    cond_loop(exp, 'while')
+  end
+  
+end
+
+module Goling
+  class Linguified
+    
+    def indent
+      @indenture ||= ''
+      @indenture += '  '
+    end
+    def indenture
+      @indenture ||= ''
+      @indenture
+    end
+    def indenture= str
+      @indenture = str
+    end
+    def new_line
+      "\n" + indenture
+    end
+    def dent
+      @indenture ||= ''
+      @indenture = @indenture[2..-1]
+    end
+
+    def to_js sexy = @sexy
+      Ruby2Js.new.process(sexy)
+    end
+
+  end
+end

data/test/test_goling.rb

@@ -34,4 +34,127 @@ class TestGoling < Test::Unit::TestCase
 
     "view all files inside all directories recursively".linguify.to_ruby.size > 0
   end
+
+  should "generate mixed ruby & javascript" do
+
+    reduce /single day plunge/ => {:to => 'move', :lang => :js, :inline => true} do
+      @traffic.forEach(lambda{ |day|
+          histogram.add(day.page_views,item);
+        }
+      )
+    end
+
+    reduce /largest ({move:[^}]*}) last month traffic records/ => {:to => 'histogram_rule', :lang => :js, :inline => true} do |move|
+      if k>=@list[lst][:k]
+        @list.push(n)
+      else
+        while true
+          if k<@list[mid][:k]
+            lst=mid
+          else
+            beg=mid
+          end
+          mid = (beg+lst)>>1
+          break if mid==beg
+        end
+
+        if k<@list[mid][:k]
+          if @list.length >= @max && mid==0
+            # lowest k in max days
+            #print(tojson(this.list[mid].v));
+            emit(@list[mid][:v][:date],@list[mid][:v])
+          end
+          @list.splice(mid,0,n)
+        elsif k<@list[lst][:k]
+          @list.splice(lst,0,n)
+        else
+          #print("!!!");
+          #print(k);
+          #print(this.list[mid].k);
+          #print(this.list[end].k);
+          while true
+          end
+        end
+      end
+    end
+
+    reduce /({histogram_rule:[^}]*}) on all pages on the whole site/ => {:to => 'traffic_map', :lang => :js} do |rule|
+      def Node k,v
+        @next = nil
+        @prev = nil
+        @k    = nil
+        @v    = nil
+      end
+      
+      histogram = {
+        max:  30,
+        list: [],
+        find: lambda{
+          beg = 0
+          lst = @list.length-1
+          mid = (beg+lst)>>1
+          while true
+            if k<@list[mid][:k]
+              lst=mid
+            else
+              beg=mid
+            end
+            mid = (beg+lst)>>1
+            break if mid==beg
+          end
+          
+          # may not be exact match (multiple of same key value), searh in both directions for a exact match
+          start = mid
+          dir = 1
+          while v != @list[mid][:v]
+            mid += dir
+            if mid == @list.length
+              mid = start
+              dir =- 1
+            end
+          end
+          return mid
+        },
+      
+        add: lambda{ |k,v|
+          if @list.length
+
+            beg = 0
+            lst = @list.length-1
+            mid = (beg+lst)>>1
+
+            n = Node.new(k,v)
+            @last.next = n
+            n.prev = @last
+            @last = n
+
+            rule
+
+            if @list.length > @max
+              # remove first
+              @list.splice(this.find(@first[:k],@first[:v]),1)
+              @first[:next].prev = nil
+              @first = @first[:next]
+            end
+          else
+            @last = Node.new(k,v)
+            @first = @last
+            @list.push(@last)
+          end
+        }
+      }
+
+      rule[:move]
+    end
+    
+    reduce /view ({traffic_map:[^}]*})/ => '' do |map|
+      reduce = "function(k,vals){ return 1; }"
+      testing = Site.collection.map_reduce(map, reduce, :out => "testing", :query => { :page => page })      
+      # I dont like how the id in mongodb doesnt match the id from the map_reduce!
+      traffic.any_in(_id: testing.find.map{ |h| h['_id'].to_s.downcase.gsub(/:/,' colon ').gsub(/ /,'-') }).all.map{ |m| m }
+    end
+
+    "view largest single day plunge last month traffic records on all pages on the whole site".linguify.to_ruby.size > 0
+  end
+
 end

metadata

@@ -2,7 +2,7 @@
 name: goling
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - Patrick Hanevold
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-08 00:00:00 Z
+date: 2011-10-07 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: sourcify
@@ -86,6 +86,7 @@ files:
 - lib/goling.rb
 - lib/goling/linguified.rb
 - lib/goling/reduction.rb
+- lib/goling/translators/javascript.rb
 - test/helper.rb
 - test/test_goling.rb
 homepage: http://github.com/patrickhno/goling
@@ -101,7 +102,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 4126556151488913212
+      hash: -3022085012113281803
       segments: 
       - 0
       version: "0"