js2 0.0.10 → 0.1.1

data/lib/js2/standard/factory.rb

@@ -0,0 +1,289 @@
+# TODO: break this up into multiple files
+class JS2::Standard::PageNode < JS2::Standard::Node
+  attr_accessor :klasses, :file
+
+  def initialize (idx, string, factory)
+    @klasses = []
+    super(idx, string, factory)
+  end
+
+  def stop (idx)
+    JS2::Standard::ForeachNode.reset!
+    super(idx)
+  end
+end
+
+class JS2::Standard::CommentNode < JS2::Standard::Node
+  def clean
+    return to_s.gsub(%r|^\s*\/?\*+\s?\/?|, '')
+  end
+end
+
+class JS2::Standard::ClassNode < JS2::Standard::Node
+  REGEX = /^(\s*class|module)\s+([\w\.]+)\s+(extends\s+([\w\.]+))?\s*\{(.*)/m
+
+  def handle_first_string (str)
+    if m = str.match(REGEX)
+      @name    = m[2]
+      @extends = m[4]
+      @ending  = m[5]
+
+      if @extends
+        @extends = "#{@name}.oo('extends', #{@extends});"
+      end
+
+      return %|JS2.OO.#{create_name}("#{@name}"); #{@extends} (function (K,Package) {var self=K; var _super=JS2.OO['super']; #{@ending}|
+    end
+  end
+
+  def methods
+    ret = []
+
+    @children.each do |c|
+      if c.is_a?(JS2::Standard::MethodNode)
+        ret << c
+      end
+    end
+
+    return ret
+  end
+
+  def name
+    if m = @string[@start_idx .. @stop_idx].match(REGEX)
+      return m[2]
+    else
+      return ''
+    end
+  end
+
+  def create_name
+    return 'createClass'
+  end
+
+  def handle_ending (str)
+    pkg = @name.split(/\./)
+    pkg.pop()
+
+    if pkg.empty?
+      pkg = 'null'
+    else
+      pkg = pkg.join('.')
+    end
+
+    return str.sub(/\s*\z/, ")(#{@name}, #{pkg});")
+  end
+end
+
+class JS2::Standard::ModuleNode < JS2::Standard::ClassNode
+  def createName
+    return 'createModule'
+  end
+end
+
+class JS2::Standard::PrivateNode < JS2::Standard::Node
+  def handle_first_string (str)
+    return str.sub(/private/m, '// private')
+  end
+end
+
+class JS2::Standard::IncludeNode < JS2::Standard::Node
+  def handle_first_string (s)
+    return s.sub(/include\s*/, "K.oo('include', ").sub(/;$/, ');');
+  end
+end
+
+
+class JS2::Standard::MemberNode < JS2::Standard::Node
+  def handle_first_string (s)
+    method = 'member'
+
+    if s.match(/^(\s*)(static)\s*/)
+      method = 'staticMember'
+      s = s.sub(/static\s*/, '')
+    end
+
+    return s.sub(/var\s*([\$\w]+)/) { "K.oo('#{method}', '" + $1 + "'" }.sub(/;(\s*)$/) {  ");#{$1}" }.sub(/\s*=/, ', ');
+  end
+
+end
+
+class JS2::Standard::CurryNode < JS2::Standard::Node
+  REGEX        = %r|^curry\s*([^\{]*)?\{(.*)$|m
+  REGEX_WITH   = %r|with\s+\(([^)]*)\)|
+  REGEX_ARGS   = %r|^\s*\(([^)]*)\)|
+  REGEX_ENDING = %r|\}([^\}]*)\z|
+
+  def handle_first_string (str)
+    m = str.match(REGEX)
+    @decl = m[1].strip
+    @stop = m[2]
+
+    @args      = ''
+    @in_scoped = ''
+    @scoped    = ''
+
+    if m = @decl.match(REGEX_WITH)
+      in_scoped = m[1].split(',').collect { |v| v.strip }
+      scoped    = in_scoped.collect { |v| v == 'this' ? 'self' : v }
+      if in_scoped.length
+        @scoped =  scoped.join(', ')
+        @in_scoped = in_scoped.join(', ')
+      end
+    end
+
+    if m = @decl.match(%r|^\s*\(([^)]*)\)|)
+      @args = m[1].strip
+    end
+
+    return %|(function (#{@scoped}) { return function (#{@args}) {#{@stop}|
+  end
+
+  def handle_ending (str)
+    if m = str.match(REGEX_ENDING)
+      return str.sub(REGEX_ENDING) { |str| "}})(#{@in_scoped})#{m[1]}" }
+    end
+
+    return str
+  end
+end
+
+
+class JS2::Standard::MethodNode < JS2::Standard::Node
+  attr_accessor :name, :args, :static
+
+  REGEX = /^(\s*)(static\s+)?function\s+([\$\w\.]+)\s*\(([^)]*)\)\s*\{(.*)/m
+
+  def handle_first_string (s)
+    m = s.match(REGEX)
+    space  = m[1]
+    @static = m[2]
+    @name   = m[3]
+    @args   = m[4]
+    @start  = m[5]
+
+    m = static ? 'staticMember' : 'method'
+    return %|#{space}K.oo('#{m}', "#{@name}", function (#{@args}) {#{@start}|
+  end
+
+  def handle_ending (str)
+    return str.sub!(/(\s*)\z/) { |m| ");#{m}" }
+  end
+
+end
+
+class JS2::Standard::AccessorNode < JS2::Standard::Node
+  REGEX = /(\s*)accessor(\s+)([\w+,\s]+\w)(\s*);(\s*)/
+
+  def handle_first_string (str)
+    m = str.match(REGEX)
+    space     = m[1]
+    mid_space = m[2]
+    list      = m[3].split(/,/).collect { |i| i.strip }
+    end_space = m[4]
+    trailing  = m[5]
+
+    return %|#{space}K.oo('accessor',#{mid_space}[ #{list.collect { |i| "'#{i}'" }.join(',')} ])#{end_space};#{trailing}|
+  end
+end
+
+class JS2::Standard::ForeachNode < JS2::Standard::Node
+  #                   start     var           iterator           array
+  REGEX = /(\s*)foreach\s*\(\s*var\s*([\$\w]+)(\s*:\s*([\$\w]))?\s*in\s*([^\s]+)\s*\)/
+  attr_accessor :iterator, :item, :array
+  @@inc = 0
+
+  def handle_first_string (s)
+    m = s.match(REGEX)
+    start    = m[1]
+    item     = m[2]
+    iterator = m[4]
+    array    = m[5]
+
+    it = iterator
+
+    unless iterator
+      it = 'it' + @@inc.to_s
+      @@inc += 1
+    end
+
+    len = it + '__len'
+    arr = it + '__arr'
+
+    return %(#{start}for (var #{it}=0,#{item},#{arr}=#{array},#{len}=#{arr}.length; (#{item}=#{arr}[#{it}]) || #{it}<#{len}; #{it}++))
+  end
+
+  def self.reset!
+    @@inc = 0
+  end
+end
+
+class JS2::Standard::PropertyNode < JS2::Standard::Node
+  REGEX = /(\s*)property(\s+)([\w+,\s]+\w)(\s*);(\s*)/
+  def handle_first_string (s)
+    m = s.match(REGEX)
+    space     = m[1]
+    mid_space = m[2]
+    list      = m[3].split(/,/).collect { |i| i.strip }
+    end_space = m[4]
+    trailing  = m[5]
+
+    return %|#{space}K.oo('property',#{mid_space}[ #{list.collect { |i| "'#{i}'" }.join(',')} ])#{end_space};#{trailing}|
+  end
+end
+
+
+class JS2::Standard::StuffNode < JS2::Standard::Node
+end
+
+
+class JS2::Standard::Factory
+  attr_accessor :decorators
+
+  @@supports = [ :CLASS, :MEMBER, :METHOD, :ACCESSOR, :FOREACH, :PROPERTY, :INCLUDE, :CURRY, :PAGE, :COMMENT, :STUFF, :MODULE, :PRIVATE ]
+  @@lookup = Hash.new
+
+  @@supports.each do |v|
+    name = v.to_s.downcase.sub(/(\w)/) { |m| m.upcase }
+    @@lookup[v] = eval "JS2::Standard::#{name}Node"
+  end
+
+  def initialize 
+    @decorators = []
+  end
+
+  def get_class (type)
+    klass = @@lookup[type] || JS2::Standard::Node
+  end
+
+  def page_node (string, file = nil)
+    @page = new_node(:PAGE, 0, string) 
+    @page.file = file
+    @comment = nil
+    return @page
+  end
+
+  def new_node (type, idx, string)
+    klass = get_class(type)
+    node = klass.new(idx, string, self)
+
+    if type == :CLASS || type == :MODULE
+      @page.klasses << node
+    end
+
+    if type == :COMMENT
+      @comment = node
+    elsif @comment
+      node.comment = @comment
+      @comment = nil
+    end
+
+    setup_node(node)
+
+    return node
+  end
+
+  def setup_node (node)
+    # virtual
+  end
+end
+

data/lib/js2/standard/node.rb

@@ -0,0 +1,75 @@
+class JS2::Standard::Node
+  attr_accessor :type, :start_idx, :stop_idx, :children, :starting, :factory, :comment
+
+  def initialize (start_idx, str, factory)
+    @start_idx = start_idx
+    @string    = str
+    @children  = []
+    @factory   = factory
+    @output    = ''
+  end
+
+  def add_child (type, start_idx)
+    child = factory.new_node(type, start_idx, @string)
+    @children.push(child)
+    return child
+  end
+
+  def stop (idx)
+    @stop_idx = idx
+    process!
+  end
+
+  def to_s
+    return @output
+  end
+
+  def process! ()
+    last_idx = @start_idx
+    str = ''
+
+    first = true
+    @children.each do |c|
+      if c.start_idx > last_idx
+        str << handle_string(@string[last_idx .. c.start_idx-1], first)
+        first = false
+      end
+
+      result = c.to_s()
+
+      @factory.decorators.each do |d|
+        d.decorate(result, c) 
+      end
+
+      str << result
+      last_idx = c.stop_idx + 1
+    end
+
+    if last_idx < @stop_idx
+      str << handle_string(@string[last_idx .. @stop_idx], first)
+    end
+
+    str = handle_ending(str)
+
+    @output = str 
+  end
+
+  private
+
+  def handle_string (str, first) 
+    if first
+      return handle_first_string(str)
+    else
+      return str 
+    end
+  end
+
+  def handle_ending (str)
+    return str
+  end
+
+  def handle_first_string (str)
+    return str
+  end
+
+end

data/lib/js2/util/compilation.rb

@@ -0,0 +1,77 @@
+class JS2::Util::Compilation
+  attr_accessor :klass_name, :require, :include, :template, :file
+  @@already = Hash.new
+
+  def initialize (klass_name, config, yml_file, file_handler)
+    @require      = config['require'] || []
+    @include      = config['include'] || []
+    @template     = config['template'] || []
+    @klass_name   = klass_name
+    @file         = yml_file
+    @file_handler = file_handler
+
+    @make_compilation = config['make_compilation']
+  end
+
+  def self.parse (yml_file, file_handler)
+    klasses = YAML.load_file(yml_file)
+
+    comps = []
+    klasses.each_pair do |k, config|
+      comps << self.new(k, config, yml_file, file_handler)
+    end
+
+    return comps
+  end
+
+  def self.reset!
+    @@already = Hash.new
+  end
+
+  def compile (klasses, errors = [])
+    return unless @make_compilation
+
+    main_file = nil
+    if files = klasses[@klass_name]
+      main_file = @file_handler.outfile(files.first)
+    else
+      return
+    end
+
+    before = []
+    @require.each do |file|
+      before += get_files(file, klasses)
+    end
+
+    after = []
+    @include.each do |file|
+      after += get_files(file, klasses)
+    end
+
+    @template.each do |item|
+      after += get_files(item['class'], klasses)
+    end
+
+    file = main_file.sub(/\.js$/, '.comp.js')
+    str = ''
+    (before + [ main_file ] + after).uniq.each do |f|
+      if File.exist?(f)
+        str << File.read(f)
+      else
+        errors << [ "#{file} references #{f}, but js2 can't find it" ]
+      end
+    end
+
+    str << "#{@klass_name}.oo('method', 'getTemplate', function () { return #{@template.to_json}; });"
+    File.open(file, 'w') { |f| f << str }
+  end
+
+  def get_files (klass_name_or_file, klasses)
+    ret = nil 
+    if files = klasses[klass_name_or_file]
+      ret = files.collect { |f| @file_handler.outfile(f) }
+    else
+      ret = @file_handler.outfile(klass_name_or_file)
+    end
+  end
+end

data/lib/js2/util/config.rb

@@ -0,0 +1,84 @@
+class JS2::Util::Config
+  attr_accessor :node_factory, :lexer, :file_handler, :lexer, :haml_engine, :haml_vars, :asset_dir, :decorators
+
+  def initialize
+    @lexer        = JS2::Parser::Lexer.new
+    @node_factory = JS2::Standard::Factory.new
+    @file_handler = JS2::Util::FileHandler.new
+    @haml_engine  = JS2::Parser::HamlEngine.new
+    @haml_vars    = {}
+  end
+
+  def add_decorator (decorator)
+    @node_factory.decorators << decorator
+  end
+
+  def self.from_yml(yml, env = nil)
+    hash = YAML.load(yml)
+    hash = hash[env] if env
+    return self.from_hash(hash)
+  end
+
+  def load_hash (hash)
+    self.file_handler.js2_dir = hash['js2_dir'] if hash['js2_dir']
+    self.haml_engine = eval('::' + hash['haml_engine_class'] + '.new') if hash['haml_engine_class']
+
+    write_dir = hash['write_dir'] || hash['out_dir']
+    self.file_handler.out_dir  = write_dir if write_dir
+    self.file_handler.haml_dir = hash['haml_dir'] || self.file_handler.js2_dir
+  end
+
+  def load_yml (yml, env = nil)
+    hash = YAML.load_file(yml)  
+    hash = hash[env] if env
+    self.load_hash(hash)
+  end
+
+  def rails! (env = nil)
+    self.out_dir  = './public/javascripts'
+    self.js2_dir  = './app/js2'
+    self.haml_dir = './app/js2'
+  end
+  
+
+  def out_dir= (dir)
+    @file_handler.out_dir = dir
+  end
+
+  def js2_dir= (dir)
+    @file_handler.js2_dir = dir
+  end
+
+  def haml_dir= (dir)
+    @file_handler.haml_dir = dir
+  end
+
+  def to_s
+    return <<-END
+js2_dir: #{@file_handler.js2_dir}
+out_dir: #{@file_handler.out_dir}
+haml_dir: #{@file_handler.haml_dir}
+    END
+  end
+
+  def from_yml (yml, env = nil)
+    hash = YAML.load(yml)
+    hash = hash[env] if env
+    return self.from_hash(hash)
+  end
+
+  def self.from_hash(hash)
+    config = self.new
+    config.load_hash(hash)
+
+    return config
+  end
+
+  def example_yml
+    return <<-END
+js2_dir:  './app/js2'      
+haml_dir: './app/js2'
+out_dir:  './public/javascripts'
+    END
+  end
+end

data/lib/js2/util/exec.rb

@@ -0,0 +1,34 @@
+class JS2::Util::Exec
+  def initialize (config, options)
+    @config = config 
+  end
+
+  def rails!
+    @config.out_dir   = './public/javascripts'
+    @config.js2_dir   = './app/js2'
+    @config.asset_dir = './app/js2'
+  end
+
+  def normal!
+    @config.out_dir = '.' 
+    @config.js2_dir = '.' 
+  end
+
+  def daemonize (timeout = 1)
+    get_processor!
+    while 1
+      @processor.process!
+      sleep timeout
+    end
+  end
+
+  def process
+    get_processor!
+    @processor.process!
+  end
+
+  def get_processor!
+    @processor = JS2::Util::Processor.new(@config)
+  end
+
+end

data/lib/js2/util/file_handler.rb

@@ -0,0 +1,73 @@
+class JS2::Util::FileHandler
+  attr_accessor :js2_dir, :out_dir, :haml_dir, :doc_dir
+
+  def initialize 
+    @js2_dir  = '.'
+    @out_dir  = '.'
+    @haml_dir = '.'
+    @doc_dir  = '.'
+
+    @lookup = {
+      :js2  => :js2_dir,
+      :haml => :haml_dir,
+      :yml  => :js2_dir 
+    }
+
+    @mtimes = Hash.new
+  end
+
+  def docfile (file)
+    return file.sub(/^#{@js2_dir}/, @doc_dir).sub(/\.js2$/, '.js')
+  end
+
+  def needs_update
+    @found = Hash.new
+
+    files = []
+    files += get_changed_files(:js2)
+    files += get_changed_files(:haml)
+    files += get_changed_files(:yml)
+
+    missing = false
+    @mtimes.keys.each do |f|
+      unless @found[f]
+        @mtimes.delete(f)
+        missing = true
+      end
+    end
+
+    return files
+  end
+
+  def outfile (file)
+    return file.sub(/^#{@js2_dir}/, @out_dir).sub(/\.js2$/, '.js')
+  end
+
+  def get_files (ext)
+    ext = ext.to_sym
+
+    my_ext = :js2 == ext ? 'js2' : "js2.#{ext}"
+    my_dir = self.send(@lookup[ext])
+    return Dir.glob(my_dir + "/**/*/*.#{my_ext}") + Dir.glob(my_dir + "/*.#{my_ext}")
+  end
+
+  def reset!
+    @mtimes  = Hash.new
+  end
+
+  def get_changed_files (ext)
+    ret = []
+    get_files(ext).each do |f|
+      @found[f] = true
+      mtime = File.mtime(f)
+      if ! @mtimes[f] || @mtimes[f] < mtime
+        @mtimes[f] = mtime
+        ret << f
+      end
+    end
+
+    return ret
+  end
+
+
+end