js2 0.0.1

data/lib/js2/ast/nodes.rb

@@ -0,0 +1,123 @@
+
+# ------------------------------------------------------------------------------
+# AKA Tokens
+# Hooks into Ragel
+# this system could be more elegant, but we choose iteration over OO for
+# efficiency
+# HOOKS:
+#   << # to simulate <<
+# ------------------------------------------------------------------------------
+class JS2::AST::Nodes < Array
+  CLOSE_CLASS_LEVEL  = 0
+  CLOSE_METHOD_LEVEL = 1
+
+  STATE_IDX   = 0
+  STRING_IDX  = 1
+  METHODS_IDX = 2
+
+  attr_accessor :stack, :filename, :line_number
+
+  def initialize (filename, str)
+    @cleanser    = JS2::Decorator::Cleanser.new
+    @str         = str
+    @filename    = filename
+    @line_number = 0
+    @mems        = []
+    @static_mems = []
+    @includes    = []
+    @foreach     = []
+    @comments    = []
+    @curries     = []
+    @in_class    = false
+
+    @static = false
+  end
+
+
+  def do_next (type, begin_index, end_index, line)
+    val = @str[begin_index..end_index]
+
+    if type == :FOREACH
+      @foreach.push([begin_index, end_index, val]) 
+
+    elsif type == :CURRY
+      @curries.push([begin_index, end_index, val]) 
+
+    elsif type != :COMMENT
+      offset = 0
+      @foreach.reverse.each do |f|
+        s = f[0] - begin_index
+        e = f[1] - begin_index
+        before = val[s..e]
+        after  = @cleanser.do_foreach(val[s..e])
+        offset += after.length - before.length
+
+        val[s..e] = after
+      end
+
+      @curries.reverse.each do |f|
+        s = f[0] - begin_index + offset
+        e = f[1] - begin_index + offset
+        val[s..e] = @cleanser.do_curry(val[s..e])
+      end
+
+      @foreach = []
+      @curries = []
+    end
+
+    if type == :METHOD
+      mems << JS2::AST::MethodNode.new(@filename, line, val)
+      reset_static
+
+    elsif type == :MEMBER
+      mems << JS2::AST::MemberNode.new(@filename, line, val)
+      reset_static
+
+    elsif type == :PROPERTY
+      @mems += JS2::AST::MethodNode.properties(@filename, line, val)
+      reset_static
+
+    elsif type == :CLASS
+      self << JS2::AST::ClassNode.new(@filename, line, val, @mems, @includes, @static_mems)
+
+      @static_mems = []
+      @mems        = []
+      @includes    = []
+
+    elsif type == :STUFF
+      self << JS2::AST::StuffNode.new(@filename, line, val)
+      @mems = []
+
+    elsif type == :COMMENT
+      mems << JS2::AST::CommentNode.new(@filename, line, val)
+
+    elsif type == :INCLUDE
+      @includes << JS2::AST::IncludeNode.new(@filename, line, val)
+
+    elsif type == :MODULE
+      self << JS2::AST::ModuleNode.new(@filename, line, val, @mems, [], @static_mems)
+
+      @static_mems = []
+      @mems        = []
+      @includes    = []
+    end
+
+  end
+
+  def mems
+    if @static
+      return @static_mems
+    else
+      return @mems
+    end
+  end
+
+  def set_static
+    @static = true
+  end
+
+  def reset_static
+    @static = false
+  end
+
+end

data/lib/js2/ast/stuff_node.rb

@@ -0,0 +1,6 @@
+class JS2::AST::StuffNode < JS2::AST::Node
+
+  def type
+    return :STUFF
+  end
+end

data/lib/js2/config.rb

@@ -0,0 +1,34 @@
+require 'yaml'
+
+class JS2::Config
+  DEFAULTS = {
+    :framework         => 'jquery',
+    :highlight         => true,
+    :js2_dir           => './js2',
+    :haml_engine_class => false,
+    :reference_dir     => nil,
+    :write_dir         => './public/javascripts',
+    :test_mode         => false,
+    :js2_haml_dir      => './js2',
+    :haml_dir          => './app/views',
+    :selenium          => { }
+  }
+
+  attr_accessor *DEFAULTS.keys
+
+  def initialize (hash = nil)
+    DEFAULTS.each_pair do |k,v|
+      self.send(k.to_s + '=', v)
+    end
+
+    load_hash(hash) if hash
+  end
+
+  def load_hash(hash)
+    DEFAULTS.keys.each do |k|
+      k = k.to_s
+      self.send(k + '=', hash[k]) if hash.has_key?(k)
+    end
+  end
+end
+

data/lib/js2/daemon.rb

@@ -0,0 +1,35 @@
+class JS2::Daemon
+  attr_accessor :haml_parser, :decorator, :parser, :universe, :haml_engine
+  INTERVAL = 1
+
+  def initialize (processor)
+    @processor = processor
+  end
+
+  def run (n=nil)
+    n ||= -1
+    i = 0
+    while i != n
+      i += 1
+
+      if check_files
+        yield if block_given?
+      else
+        sleep INTERVAL
+      end
+    end
+  end
+
+
+  private
+
+  def check_files
+    unless @processor.fh.need_update!
+      return false
+    end
+    @processor.write_files
+  rescue Exception => e
+    print e.to_s
+    print "Error in processing files"
+  end
+end

data/lib/js2/decorator/app.rb

@@ -0,0 +1,7 @@
+class JS2::Decorator::App
+  def initialize (yaml_file)
+    @yaml = YAML.load_file(yaml_file)
+  end
+  
+end
+

data/lib/js2/decorator/cleanser.rb

@@ -0,0 +1,54 @@
+class JS2::Decorator::Cleanser
+  @@enum = 0
+
+  def cleanse (str)
+    do_foreach(str)
+  end
+
+  def do_foreach (str)
+    # TODO support types 
+    # TODO foreach:pair (var key,item in itemHash)
+    # TODO foreach:time (var i in 25)
+    # TODO foreach:key  (var key in hash)
+    #
+    # SUPPORTED foreach (var item:i in items)
+    if m = str.match(%r|foreach\s*(:([^\s]))?\s*\(\s*var\s+([^\s\:]+)\s*(:?([^\s]))?\s+in\s+([^\s]+)\s*\)|)
+      type = m[2]
+      decl = m[3]
+      it   = m[5] || ('it_' + (@@enum += 1).to_s) 
+      arr  = m[6]
+      len  = it + '_len'
+
+      return "for (var #{decl},#{it}=0,#{len}=#{arr}.length; (#{decl}=#{arr}[#{it}]) || #{it}<#{len}; #{it}++)"
+    else
+      return str
+    end
+  end
+
+  def do_curry (str) 
+
+    #                            decl     code
+    if m = str.match(%r|^curry\s*([^\{]*)?(\{.*)$|m)
+      decl = m[1].strip
+      code = m[2]
+
+      scoped_vars = ''
+      args        = ''
+
+      if m = decl.match(%r|with\s+\(([^)]*)\)|)
+        vars = m[1].split(',').collect { |v| v.strip }
+        scoped_vars = vars.collect { |v| v == 'this' ? 'self' : v }.join(', ')
+        in_scoped_vars = vars.join(', ')
+      end
+
+      if m = decl.match(%r|^\s*\(([^)]*)\)|)
+        args = m[1].strip
+      end
+
+
+      return %{(function (#{scoped_vars}) { return function (#{args}) #{code} })(#{in_scoped_vars})}
+    else
+      return str
+    end
+  end
+end

data/lib/js2/decorator/standard.rb

@@ -0,0 +1,127 @@
+require 'rubygems'
+require 'json'
+
+class JS2::Decorator::Standard
+  def draw_nodes (nodes)
+    str = ''
+    nodes.each do  |node|
+      if node.is_a? JS2::AST::StuffNode
+        str << draw_stuff(node)
+      elsif node.is_a? JS2::AST::ClassNode
+        str << draw_class(node)
+      end
+    end
+    return str
+  end
+
+  def draw_classes (nodes)
+    ret = []
+    visited = Hash.new
+    funct = "function () { if (this.initialize) this.initialize.apply(this, arguments); }"
+    nodes.select { |n| n.is_a? JS2::AST::ClassNode }.sort { |a,b| a.name <=> b.name }.each do |n|
+      splitted = n.name.split(/\./)
+      running_name = []
+
+      splitted.each_with_index do |sub_name, i|
+        running_name << sub_name
+        name = running_name.join('.')
+        next if visited[name]
+        visited[name] = true
+
+        if i == 0
+          ret << "var #{name}=#{funct};"
+        else
+          ret << "  #{name}=#{funct};"
+        end
+
+      end
+    end
+    return ret.join("\n")
+  end
+
+  private
+
+  def draw_method (node)
+    return %{  // #{node.filename}:#{node.line_number} 
+  #{node.name}:function #{node.text}}
+  end
+
+  def draw_inherited (node)
+    return "  #{node.name}: #{node.extends}.prototype.#{node.name}"
+  end
+
+  def draw_haml (node)
+    text = node.attrs.collect do |attr|
+      %{#{attr[0]}:#{attr[1]}}
+    end.join(',')
+    return %{  htmlCache: {#{text}}}
+  end
+
+  def draw_comment (node) 
+    return '  ' + node.text
+  end
+
+  def draw_member (node)
+    if node.is_a? JS2::AST::MethodNode
+      return draw_method(node)
+    elsif node.is_a? JS2::AST::InheritedNode
+      return draw_inherited(node)
+    elsif node.is_a? JS2::AST::HamlNode
+      return draw_haml(node)
+    elsif node.is_a? JS2::AST::CommentNode
+      return draw_comment(node)
+    end
+
+    return %{  // #{node.filename}:#{node.line_number}
+  #{node.name}:#{node.text}}
+  end
+
+  def draw_class (node)
+    meta = ''
+    if node.extends
+      meta << "_parent:#{node.extends},"
+    end
+
+    members = node.members
+
+    meta << "_klass:'#{node.name}'"
+    meta << ',' unless members.empty?
+
+    handle_super = ''
+    node.super_hash.each_pair do |k,v| 
+      handle_super << "#{node.name}.prototype.#{k}._super=#{v}.prototype.#{k};\n" 
+    end
+
+    handle_static = 
+      node.statics.collect do |s|
+        handle_static = "#{node.name}.#{s.name}=function #{s.text};"
+      end.join("\n")
+
+    member_js  = [ ]
+    member_str = ''
+    members.each do |m|
+      member_str << draw_member(m)
+      if m.is_a? JS2::AST::CommentNode
+        member_str << "\n"
+      else
+        member_js.push(member_str)
+        member_str = ''
+      end
+    end
+
+    return <<-END
+// #{node.filename}:#{node.line_number}
+#{node.name}.prototype={#{meta}
+#{member_js.join(",\n") }
+};
+// adding super
+#{handle_super}
+#{handle_static}
+#{node.name}.prototype['class']=#{node.name};
+    END
+  end
+
+  def draw_stuff (node)
+    return node.text
+  end
+end

data/lib/js2/decorator/test.rb

@@ -0,0 +1,148 @@
+require 'json'
+
+class JS2::Decorator::Test < JS2::Decorator::Standard
+
+  def initialize ()
+    super()
+    @references = Hash.new
+    @in_class = false
+  end
+
+
+  def draw_class (node) 
+    str = super(node)
+    @scope = node.name
+    @in_class = true
+    str = process_str(str)
+    @in_class = false
+    return str
+  end
+
+  def draw_stuff (node)
+    str = super(node)
+    @scope = nil
+    return process_str(str)
+  end
+
+  def write_references  (dir)
+    @references.each_pair do |klass, val|
+      File.open(dir + '/' + klass + '.yml', 'w') do |out|
+        YAML.dump(val, out)
+      end
+    end
+  end
+
+  private
+
+  def process_str (str)
+    lines     = str.split(/\r?\n/)
+    processed = []
+
+    lines.each do |line|
+      # release comment and put it back in the queue
+      line.sub!(%r|\s*//@=\s*.*|) do |str|
+        if m = str.match(%r|(\s*)//@=\s*(.*)|) 
+          m[1] + m[2]
+        else
+          str
+        end
+      end
+    end
+
+    while line = lines.shift
+
+      # scope is defined
+      if m = line.match(%r|^\s*//@\s*Scope\(([\w\.]+)\)|)
+        @scope = "Page.#{m[1]}"
+        processed.push(line)
+
+      elsif @scope
+        # if its a marker, reverse the next 2 lines
+        if new_line = process_marker(line, lines.first)
+          processed.push(lines.shift)
+          processed.push(new_line)
+
+        # var button = $('.button'); //@ Button
+        elsif new_lines = process_tailing_marker(line)
+
+          # reorder this and send it back through the loop
+          # but with the marker on top
+          lines.unshift(new_lines[1])
+          lines.unshift(new_lines[0])
+          next
+
+        # proceed as normal
+        else
+          processed.push(line)
+        end
+      else
+        processed.push(line)
+      end
+    end
+
+    return processed.join("\n")
+  end
+
+  def process_marker (line, next_line)
+    return false unless @scope && next_line
+
+    #  //@  Foo // Bar
+    #  //@+ Foo // Bar
+    #                     pad  type        marker     comment
+    if m = line.match(%r|^(\s*)//@(\+)?\s+([^/]+)\s*(//(.*))?$|)
+
+      padding       = m[1]
+      type          = m[2]
+      marker        = m[3].strip
+
+      whole_comment = m[4] 
+      comment       = (m[5] || '').strip 
+
+      # get lval 
+      lval_match = next_line.match(/^\s*(var)?\s*([^\s=;]+)\s*/)
+
+      return false unless lval_match
+      lval = lval_match[2]
+
+      # figure out what the lval should be
+      # Button(<jquery selector>)
+      key, find = parse_marker(marker)
+      finder = find ? find.to_json : "null"
+
+      # method to use for JS2.TEST.<addEle>(...)
+      insert = type == "+" ? 'appendVal' : 'addVal'
+
+      (@references[@scope] ||= {})[key] = comment
+      scope = 
+        if @in_class
+          "this._klass"
+        else
+          @scope.to_json
+        end
+
+      return padding + %{TMP_SEL_MARKER = this.SEL_MARKER || JS2.SEL_MARKER; TMP_SEL_MARKER.#{insert}(#{scope}, #{key.to_json}, #{lval}, #{finder});}
+    else
+      return false
+    end
+  end
+
+  # split a trailing marker into 2 lines
+  def process_tailing_marker (line)
+    if m = line.match(%r|^(\s*)([^\s]+.*)(//@.*)$|)
+      new_line = m[1] + m[2]
+      marker   = m[1] + m[3]
+      return [ marker, new_line ]
+    else
+      return false
+    end
+  end
+
+  def parse_marker (marker)
+    #                     key        find
+    if m = marker.match(/^([^\(]+)\(([^\)]*)\)?/)
+      return [ m[1], m[2] ]
+    else
+      return [ marker, nil ]
+    end
+  end
+end