js2 0.0.1

data/lib/js2/parser/haml.rb

@@ -0,0 +1,123 @@
+begin
+  require 'rubygems'
+  require 'haml'
+  require 'json'
+rescue Exception
+  puts "HAML is not supported"
+end
+
+class JS2::Parser::Haml
+
+  def initialize (haml_engine)
+    @haml_engine = haml_engine
+  end
+
+  def parse_out_js (file)
+    padding = nil
+    js = []
+
+    File.read(file).split(/\r?\n/).each do |line|
+      if m = line.match(/^(\s*):js2/)
+        padding = m[1]
+      elsif padding 
+        if m = line.match(/^#{padding}/)
+          js << line
+        elsif ! line.match(/^\s*$/)
+          padding = nil
+        end
+      end
+    end
+
+    return js.join("\n")
+  end
+
+  def parse (file)
+    lines  = File.read(file).split(/\r?\n/)
+    result = Hash.new
+
+    klass = Hash.new
+    key   = nil
+
+    until lines.empty?
+      line = lines.shift()
+
+      if m = line.match(/^\.?([\w\.]+)/)
+        klass = Hash.new
+        result[m[1]] = klass
+      elsif m = line.match(/^  sass/)
+        key = 'sass'
+        klass[key] = [ [ ], '' ]
+      elsif m = line.match(/^  \.?([\w]+)(\(([^)]+)\))?/)
+        key = m[1]
+        klass[key] = [ [], m[3] ] 
+      elsif key
+        if key == 'sass'
+          klass[key][0] << line.sub(/^  /, '')
+        else
+          klass[key][0] << line.sub(/^    /, '')
+        end
+      end
+    end
+
+    result.keys.each do |class_name|
+      klass = result[class_name]
+      klass.each_pair do |key, array|
+        if key == 'sass'
+          array[0].unshift ".#{class_name.sub(/\.\w+$/, '').sub(/\./, '')}"
+          klass[key] = sassify(array[0].join("\n"))
+        else
+          klass[key] = functionize(array[0].join("\n"), array[1])
+        end
+      end
+    end
+
+    return result
+  end
+
+  private
+
+  def sassify (string)
+    begin
+      css = @haml_engine.sassify(string)
+    rescue
+      raise string
+    end
+    return css.gsub(/\n/, '').to_json
+  end
+
+  def functionize (string, params)
+    begin
+      html = @haml_engine.hamlize(string)
+    rescue
+      raise string
+    end
+
+    if params
+      return functionize_with_params(html, params)
+    end
+
+    counter = 0
+    segments = html.split(%r|#\w+#|).collect { |seg| seg.to_json }
+    ret = Array.new
+    segments.each_with_index do |seg, i|
+      ret.push(seg)
+      ret.push(%{arguments[#{i}]}) if (segments.length-1) > i
+    end
+    return %{function(){return #{ret.join('+')}}}
+  end
+
+
+  def functionize_with_params (string, params) 
+    args = []
+    string.gsub!(/#([^#]+)#/) do |m|
+      args << m.gsub(/#/, '')
+      '###'
+    end
+
+    segments = string.split(%r|###|).collect { |seg| seg.to_json }
+    ret = segments.zip(args).flatten.reject { |a| a.nil? }.join('+');
+    return %{function(#{params}){return #{ret}}}
+  end
+
+
+end

data/lib/js2/process/file_handler.rb

@@ -0,0 +1,84 @@
+class JS2::Process::FileHandler
+  def initialize (params = {})
+    @read_dir  = params[:read_dir]
+    @write_dir = params[:write_dir]
+    @haml_dir  = params[:haml_dir]
+    @view_dir  = params[:view_dir]
+
+    @mtimes = Hash.new
+  end
+
+  def class_file 
+    return @write_dir + '/classes.js'
+  end
+
+  def get_view_files
+    return [] unless @view_dir
+    return Dir.glob(@view_dir + '/**/*.haml')
+  end
+
+  def get_haml_files
+    return [] unless @haml_dir
+    return Dir.glob(@haml_dir + '/**/*/*.js2.haml') + Dir.glob(@haml_dir + '/*.js2.haml')
+  end
+
+  def get_files
+    return Dir.glob(@read_dir + '/**/*/*.js2') + Dir.glob(@read_dir + '/*.js2')
+  end
+
+  def write_file (filename, str)
+    to_write = filename.sub(/^#{@read_dir}/, @write_dir).sub(/\.js2$/, '.js')
+    FileUtils.mkpath(File.dirname(to_write))
+    File.open(to_write, 'w') do |f|
+      f << str
+    end
+  end
+
+  def write_class_file (str)
+    FileUtils.mkpath(File.dirname(class_file))
+    File.open(class_file, 'w') do |f|
+      f << str
+    end
+  end
+
+  def need_update!
+    ret = false
+    did = Hash.new
+    self.get_files.each do |file|
+      mtime = File.mtime(file)
+      if @mtimes[file] != mtime
+        @mtimes[file] = mtime
+        ret = true
+      end
+      did[file] = mtime
+    end
+
+    self.get_haml_files.each do |file|
+      mtime = File.mtime(file)
+      if @mtimes[file] != mtime
+        @mtimes[file] = mtime
+        ret = true
+      end
+      did[file] = mtime
+    end
+
+    self.get_view_files.each do |file|
+      mtime = File.mtime(file)
+      if @mtimes[file] != mtime
+        @mtimes[file] = mtime
+        ret = true
+      end
+      did[file] = mtime
+    end
+
+    @mtimes.keys.each do |file|
+      ret = true unless did[file]
+    end
+
+    @mtimes = did
+    return ret
+  rescue
+    return true
+  end
+
+end

data/lib/js2/process/haml_engine.rb

@@ -0,0 +1,19 @@
+begin
+  require 'rubygems'
+  require 'haml'
+  require 'sass'
+  require 'json'
+rescue Exception
+  puts "HAML is not supported"
+end
+
+
+class JS2::Process::HamlEngine
+  def hamlize (string)
+    return Haml::Engine.new(string, { :ugly => true }).render(self).gsub(/\n/, '')
+  end
+
+  def sassify (string)
+    return Sass::Engine.new(string, { :ugly => true }).render
+  end
+end

data/lib/js2/process/universe.rb

@@ -0,0 +1,57 @@
+class JS2::Process::Universe 
+  def initialize 
+    @class_lookup = Hash.new
+    @haml_lookup  = Hash.new
+    @node_containers = Array.new
+    @mod_lookup      = Hash.new
+  end
+
+  def add_nodes (nodes)
+    nodes.select { |n| n.is_a? JS2::AST::ClassNode }.each do |k|
+      @class_lookup[k.name] = k
+    end
+
+    nodes.select { |n| n.is_a? JS2::AST::ModuleNode }.each do |k|
+      @class_lookup[k.name] = k
+    end
+
+    @node_containers << nodes
+  end
+
+  def node_containers 
+    return @node_containers
+  end
+
+  def add_haml_hash (hash)
+    hash.each_pair do |name, haml_hash|
+      @haml_lookup[name] ||= JS2::AST::HamlNode.new
+      haml = @haml_lookup[name]
+
+      haml_hash.each_pair do |k,v|
+        haml[k] = v
+      end
+    end
+  end
+
+  def finalize! ()
+    @class_lookup.values.each do |k|
+      # set parents
+      k.parent = @class_lookup[k.extends] if k.extends
+      included_mods = []
+      k.includes.each do |mod_node|
+        m = @class_lookup[mod_node.name] 
+        included_mods << m if m
+      end
+
+      k.included_mods = included_mods
+
+      # set haml
+      k.haml = @haml_lookup[k.name] if @haml_lookup[k.name]
+    end
+
+    @class_lookup.values.each do |k|
+      k.finalize!
+    end
+  end
+
+end

data/lib/js2/processor.rb

@@ -0,0 +1,150 @@
+require 'yaml'
+
+class JS2::Processor
+  attr_accessor :fh, :haml_engine, :decorator
+
+  # ----------------------------------------------------------------------------
+  # Rails support
+  # ----------------------------------------------------------------------------
+  def self.from_rails 
+    hash = YAML.load_file("#{RAILS_ROOT}/config/js2.yml")[RAILS_ENV]
+    config = JS2::Config.new(hash)
+    return self.get(config)
+  end
+
+  def self.daemon_from_rails 
+    processor = self.from_rails
+    return JS2::Daemon.new(processor)
+  end
+
+  # ----------------------------------------------------------------------------
+  # yaml support
+  # ----------------------------------------------------------------------------
+  def self.from_yaml(file)
+    config = JS2::Config.new(YAML.load_file(file))
+    return self.get(config)
+  end
+
+  def self.daemon_from_yaml(file)
+    p = self.from_yaml(file)
+    return JS2::Daemon.new(p)
+  end
+
+  # ----------------------------------------------------------------------------
+  # legacy
+  # ----------------------------------------------------------------------------
+  def self.from_file (file, env = nil)
+    hash = YAML.load_file(file)
+    hash = hash[env] if env
+    config = JS2::Config.new(hash)
+    return self.get(config)
+  end
+
+  def self.processor_from_file (file, env = nil)
+    return self.from_file(file, env)
+  end
+
+  def self.daemon_from_file (file, env = nil)
+    p = self.from_file(file, env)
+    return JS2::Daemon.new(p)
+  end
+
+  def self.from_hash (hash)
+    config = JS2::Config.new(hash)
+    return self.get(config)
+  end
+
+  def self.daemon_from_hash (hash)
+    p = self.from_hash(hash)
+    return p
+  end
+
+
+  def self.get (config = nil)
+    # get config file
+    config ||= JS2::Config.new
+
+    # haml engine
+    haml_engine_class = config.haml_engine_class ? 
+                        config.haml_engine_class.constantize : 
+                        JS2::Process::HamlEngine
+
+    haml_engine = haml_engine_class.new
+
+    # file handler
+    js2_dir      = config.js2_dir 
+    write_dir    = config.write_dir
+    js2_haml_dir = config.js2_haml_dir
+    haml_dir     = config.haml_dir
+
+    file_handler = JS2::Process::FileHandler.new(
+      :read_dir     => js2_dir,
+      :write_dir    => write_dir,
+      :haml_dir     => js2_haml_dir,
+      :view_dir     => haml_dir
+    )
+
+    decorator_klass = config.test_mode ? 
+                JS2::Decorator::Test :
+                JS2::Decorator::Standard
+
+    return self.new(
+      :test_mode       => config.test_mode,
+      :reference_dir   => config.reference_dir,
+      :haml_engine     => haml_engine,
+      :file_handler    => file_handler,
+      :decorator_klass => decorator_klass
+    )
+  end
+
+  def initialize (params)
+    @haml_engine     = params[:haml_engine] 
+    @fh              = params[:file_handler] 
+    @decorator_klass = params[:decorator_klass]   
+    @reference_dir   = params[:reference_dir]
+    @test_mode       = params[:test_mode]
+  end
+
+  def write_files
+    universe = JS2::Process::Universe.new()
+
+    parser       ||= JS2::Parser::Fast.new()
+    haml_parser  ||= JS2::Parser::Haml.new(@haml_engine)
+    universe       = JS2::Process::Universe.new
+
+    decorator = @decorator_klass.new
+
+    @fh.get_files.each do |filename|
+      nodes = parser.parse(filename)
+      universe.add_nodes(nodes)
+    end
+
+    @fh.get_haml_files.each do |filename|
+      hash = haml_parser.parse(filename)
+      universe.add_haml_hash(hash)
+    end
+
+    universe.finalize!
+
+    universe.node_containers.each do |nc|
+      str = decorator.draw_nodes(nc)
+      @fh.write_file(nc.filename, str)
+    end
+
+    str = decorator.draw_classes(universe.node_containers.flatten)
+    @fh.write_class_file(str)
+
+    if @test_mode
+      decorator.write_references(@reference_dir)
+    end
+
+    @fh.get_view_files.each do |filename|
+      js        = haml_parser.parse_out_js(filename)
+      nodes     = parser.parse_string(js) 
+      decorator = @decorator_klass.new
+      decorator.draw_nodes(nodes)
+      decorator.write_references(@reference_dir)
+    end
+  end
+
+end

data/lib/js2/test/selenium.rb

@@ -0,0 +1,111 @@
+begin
+require 'rubygems'
+gem "selenium-client", ">=1.2.16"
+require "selenium/client"
+require "yaml"
+require "json"
+
+
+class JS2::Test::Selenium < Selenium::Client::Driver
+  attr_accessor :reference_dir, :child_selector
+
+  RESET_SEL_MARKER = "if (window.JS2) { window.USE_SEL_MARKER = window.JS2.SEL_MARKER; }"
+
+  class << self
+
+    def logger
+      return @logger || nil
+    end
+
+    def logger= (a_logger)
+      @logger = a_logger
+    end
+
+    def connect (config_file, env = nil)
+      config = YAML.load_file(config_file)
+      config = config[env] if env
+
+      reference_dir = config['reference_dir'] || './spec/js2refs'
+      config = config['selenium']
+
+      ret =  self.new( :host    => config['host']    || 'localhost',
+                       :port    => config['port']    || 4444,
+                       :browser => config['browser'] || '*firefox',
+                       :url     => config['url']     || 'http://google.com',
+
+                       :timeout_in_second         => config[:timeout] || 60,
+                       :highlight_located_element => config['highlight'] || false,
+                       :javascript_framework      => config['framework'] || 'jquery' )
+
+      # hack to get an instance var in.
+      ret.reference_dir = reference_dir
+      ret.child_selector = nil
+
+      return ret
+    end
+  end
+
+  def get_sel_markers ()
+    json = self.execute("JS2.SEL_MARKER.toJson()")
+    struct = JSON.parse(json)
+    puts YAML::dump(struct)
+  end
+
+  def open!(uri)
+    ret = self.open(uri)
+    self.wait_for_page
+    self.set_sel_marker!
+    return ret
+  end
+
+  def execute (js)
+    puts js
+    return self.js_eval("window.eval(#{js.to_json});")
+  end
+
+  def uri 
+    return self.location.sub(%r|^https?://(.*)?/|, '/')
+  end
+
+  def get_helper (klass_name)
+    klass  = klass_name
+    ref_file = %|#{@reference_dir}/#{klass_name}.yml|
+    lookup = if File.exist? ref_file
+      YAML.load_file(ref_file)
+    else
+      Hash.new
+    end
+
+    return JS2::Test::SeleniumHelper.new(klass_name, lookup, self)
+  end
+
+  def child_scope (selector)
+    js = "if (window.JS2) { window.USE_SEL_MARKER = window.JS2.SEL_MARKER."
+    js << selector.split('>').collect { |s| "children.#{s}" }.join('.')
+    js << '};'
+    @keep_selector = js
+    self.set_sel_marker!
+    yield()
+    @keep_selector = nil
+    self.set_sel_marker!
+  end
+
+  def set_sel_marker! 
+    self.execute(@keep_selector || RESET_SEL_MARKER)
+  end
+
+  def scope(klass_name)
+    self.set_sel_marker!
+    helper = get_helper(klass_name)
+    if block_given?
+      yield(helper) 
+    else
+      return helper
+    end
+  end
+
+end
+
+rescue Exception => e
+  warn "No support for selenium"
+end