js2 0.0.8 → 0.0.9

data/lib/js2/ast/class_node.rb

@@ -1,105 +0,0 @@
-class JS2::AST::ClassNode < JS2::AST::Node
-  attr_accessor :name, :members, :extends, :filename, :parent, :mem_hash, :haml, :includes, :included_mods, :statics
-
-  def initialize (filename, n, text, mems, includes, statics)
-    @filename = filename
-    @line_number = n
-    @members = mems
-    @text    = text
-    @mem_hash = Hash.new
-    @child_filenames = Array.new
-    @super_hash = Hash.new
-    @includes = includes
-    @included_mods = []
-    @statics = statics
-
-    self.close!
-
-    @finalized = false
-  end
-
-  def is_module?
-    return false
-  end
-
-  def members
-    if self.haml
-      return @members + [ self.haml ]
-    else
-      return @members
-    end
-  end
-
-  def close!
-    parse_text!()
-    @members.each do |m|
-      next if m.is_a? JS2::AST::CommentNode
-      @mem_hash[m.name] = m
-    end
-  end
-
-  def finalize!
-    # already done dude
-    return if @finalized
-    @finalized = true
-
-    # make the connection
-    if parent
-      parent.finalize!
-    end
-
-    haml.finalize!(parent) if haml
-
-
-    @super_hash = Hash.new
-
-    if parent
-      # if parent has haml but not child
-      if parent.haml && ! haml 
-        inherited = JS2::AST::InheritedNode.new
-        inherited.name = 'htmlCache'
-        inherited.extends = self.extends
-        @mem_hash['htmlCache'] = inherited
-        @members.push(inherited)
-      end
-
-      parent.mem_hash.each_pair do |name, m|
-        if @mem_hash[m.name]
-          @super_hash[m.name] = parent.name
-        end
-      end
-    end
-
-    included_mods.reverse.each do |c|
-      merge(c)
-    end
-
-    merge(parent) if parent
-  end
-
-  def merge (c)
-    c.mem_hash.each_pair do |name, m|
-      unless @mem_hash[name]
-        inherited = JS2::AST::InheritedNode.new
-        inherited.name    = m.name
-        inherited.extends = c.name
-        @mem_hash[m.name] = inherited
-        @members.push(inherited)
-      end
-    end
-  end
-
-  def super_hash
-    return @super_hash
-  end
-
-
-  def parse_text!
-    m = @text.match(/\s+([\w\.]+)\s+(extends ([\w\.]+))?/)
-    @name    = m[1]
-    @extends = m[3]
-  end
-
-end
-
-

data/lib/js2/ast/comment_node.rb

@@ -1,2 +0,0 @@
-class JS2::AST::CommentNode < JS2::AST::Node
-end

data/lib/js2/ast/haml_node.rb

@@ -1,22 +0,0 @@
-class JS2::AST::HamlNode < Hash
-  attr_accessor :attrs
-
-  def initialize 
-    @attrs = []
-  end
-
-  def finalize! (parent)
-    @attrs = []
-
-    if parent && parent.haml
-      parent.haml.keys.each do |k|
-        next if self[k]
-        @attrs << [ k, "#{parent.name}.prototype.htmlCache.#{k}" ]
-      end
-    end
-
-    self.keys.each do |k|
-      @attrs << [ k, self[k] ]
-    end
-  end
-end

data/lib/js2/ast/include_node.rb

@@ -1,11 +0,0 @@
-class JS2::AST::IncludeNode < JS2::AST::Node
-  attr_accessor :name
-
-  def close!
-    if m = @text.match(/^(\s*)include\s*([\.\w]+)\s*;/)
-      @padding = m[1]
-      @name    = m[2]
-    end
-  end
-
-end

data/lib/js2/ast/inherited_node.rb

@@ -1,7 +0,0 @@
-class JS2::AST::InheritedNode 
-  attr_accessor :name, :extends
-
-  def to_js
-    return "  #{name}: #{extends}.prototype.#{name}"
-  end
-end

data/lib/js2/ast/member_node.rb

@@ -1,18 +0,0 @@
-class JS2::AST::MemberNode < JS2::AST::Node
-  attr_accessor :name, :klass
-
-  def close!
-    if m = @text.match(/^(\s*)var\s*([\w\$]+)\s*=(.*);/)
-      @padding = m[1]
-      @name    = m[2]
-      @text    = m[3].sub(/;\s*$/m, '')
-    elsif m = @text.match(/^(\s*)accessor\s*([\w\$]+)\s*;/)
-      @padding = m[1]
-      @name    = m[2]
-      @text    = "function (val) { if (arguments.length>0) this._#{@name}=val; return this._#{@name}; }"
-    else
-      raise 'Invalid member'
-    end
-  end
-
-end

data/lib/js2/ast/method_node.rb

@@ -1,29 +0,0 @@
-class JS2::AST::MethodNode < JS2::AST::Node
-  attr_accessor :name
-
-  def self.properties (filename, line, str)
-    ret = []
-
-    str.sub!(/property/, '')
-    str.split(/,/).collect { |s| s.strip.sub(/;$/, '') }.each do |prop|
-      name = String.new(prop)
-      name[0,1] = name[0,1].upcase
-      setter = "function set#{name} (val) { this.#{prop} = val; }"
-      getter = "function get#{name} () { return this.#{prop}; }"
-
-      ret << self.new(filename, line, setter)
-      ret << self.new(filename, line, getter)
-    end
-
-    return ret
-  end
-
-
-  def close!
-    m = @text.match(/^(\s*)function\s*(\w+)\s*(.*)\s*/m)
-    @padding = m[1]
-    @name    = m[2]
-    @text    = m[3].sub(/\s*$/m, '')
-    @annotations = []
-  end
-end

data/lib/js2/ast/module_node.rb

@@ -1,6 +0,0 @@
-class JS2::AST::ModuleNode < JS2::AST::ClassNode
-
-  def is_module?
-    return true
-  end
-end

data/lib/js2/ast/node.rb

@@ -1,14 +0,0 @@
-class JS2::AST::Node
-  attr_accessor :text, :filename, :line_number
-
-  def initialize (filename, n, text)
-    @line_number = n
-    @filename    = filename
-    @text = text
-
-    self.close!
-  end
-
-  def close!
-  end
-end

data/lib/js2/ast/nodes.rb

@@ -1,123 +0,0 @@
-
-# ------------------------------------------------------------------------------
-# 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

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

data/lib/js2/decorator/app.rb

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

data/lib/js2/decorator/cleanser.rb

@@ -1,54 +0,0 @@
-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

@@ -1,103 +0,0 @@
-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
-
-  private
-
-  def draw_method (node)
-    return %{ 
-  #{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.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
-
-JS2.createClass("#{node.name}");
-#{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