jax 1.0.1 → 1.1.0.rc1

data/spec/generators/shader_generator_test.rb

@@ -0,0 +1,38 @@
+require 'test_helper'
+# require 'test_app'
+
+class Jax::Generators::Shader::ShaderGeneratorTest < Jax::Generators::TestCase
+  include TestHelpers::Paths
+  include TestHelpers::Generation
+
+  EXPECTED_FILES = %w(
+    app/shaders/clouds/common.ejs
+    app/shaders/clouds/fragment.ejs
+    app/shaders/clouds/manifest.yml
+    app/shaders/clouds/material.js
+    app/shaders/clouds/vertex.ejs
+    spec/javascripts/shaders/clouds_spec.js
+  )
+  
+  test "generator" do
+    build_app
+    boot_app
+    self.class.destination app_path
+    generate 'clouds'
+    
+    EXPECTED_FILES.each do |fi|
+      assert_file fi
+    end
+  end
+
+  test "in plugin" do
+    build_app
+    plugin_generator 'clouds'
+    boot_app
+    
+    generate "clouds"
+    EXPECTED_FILES.each do |fi|
+      assert_file File.join("vendor/plugins/clouds", fi)
+    end
+  end
+end

data/spec/lib/jax/application_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+class Jax::ApplicationTest < IsolatedTestCase
+  def setup
+    build_app
+    app_file "app/shaders/clouds/fragment.ejs", "void main(void) { }"
+    boot_app
+  end
+  
+  test "shaders" do
+    assert_not_nil Jax.application.shaders.find("clouds")
+    assert_equal abs("app/shaders/clouds"), Jax.application.shaders.find("clouds").path
+  end
+  
+  test "paths" do
+    assert_contains Jax.root.to_s, Jax.application.javascript_source_roots
+  end
+end

data/spec/lib/jax/generators/plugin/credentials_test.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+
+class Jax::Generators::Plugin::CredentialsTest < IsolatedTestCase
+  def shell
+    @shell ||= SpecShell.new
+  end
+  
+  def subject
+    @subject ||= Jax::Generators::Plugin::Credentials.new(
+      :home => FIXTURES_PATH,
+      :in => shell.stdin,
+      :out => shell.stdout
+    )
+  end
+  
+  def setup
+    build_app
+    boot_app
+    FileUtils.rm fixture_path(".jax") if File.exist?(fixture_path(".jax"))
+  end
+  
+  test "with new account" do
+    shell.stdin.returns [
+      'missing@gmail.com',
+      'password', 'password'
+    ]
+    
+    assert_equal "WXTzIXC2ODdbLAyvVL9p", subject.api_key
+  end
+  
+  test "with missing config file and valid existing credentials" do
+    shell.stdin.returns [
+      'sinisterchipmunk@gmail.com',
+      'password'
+    ]
+    
+    assert_equal "WXTzIXC2ODdbLAyvVL9p", subject.api_key
+  end
+  
+  test "with missing config file and invalid credentials for an existing account" do
+    shell.stdin.returns [
+      'missing@gmail.com',
+      'invalid'
+    ]
+    
+    assert_raises(RuntimeError) { subject.api_key }
+  end
+  
+  test "with missing api key" do
+    shell.stdin.returns [
+      'missing@gmail.com',
+      'password', 'password'
+    ]
+    subject.api_key
+    
+    assert_match /email/i, shell.stdout.string
+  end
+  
+  test "with api key" do
+    stub_fixture(".jax") { |f| f.print 'api_key: "1234"' }
+    
+    assert_equal "1234", subject.api_key
+  end
+  
+  test "default home" do
+    assert_equal File.expand_path("~"), Jax::Generators::Plugin::Credentials.new.home
+  end
+  
+  test "override home" do
+    assert_equal File.expand_path("."), Jax::Generators::Plugin::Credentials.new(:home => ".").home
+  end
+end

data/spec/lib/jax/packager_test.rb

@@ -0,0 +1,87 @@
+require 'test_helper'
+
+class Jax::Generators::Packager::PackageGeneratorTest < Jax::Generators::TestCase
+  include TestHelpers::Paths
+  include TestHelpers::Generation
+  
+  setup do
+    build_app
+    app_file "public/asset.txt", 'content'
+    app_file 'app/helpers/my_helper.js', 'var MyHelper = "ONE";'
+    app_file "app/models/my_model.js", "//= require <support.js>\nvar MyModel = 'TWO';"
+    app_file "app/resources/my_models/default.yml", "three: 3"
+    app_file "app/resources/my_models/first.yml", "four: 4"
+    app_file "app/controllers/my_controller.js", "//= require \"application_controller.js\"\nvar MyController = Jax.Controller.create('my', ApplicationController, {});"
+    app_file "lib/support.js", "var SUPPORT = 1.0;"
+
+    plugin "cloud" do |p|
+      p.write "app/shaders/cloud/vertex.ejs", "void main() { }"
+      p.write "public/plugin-asset.txt", 'content'
+      
+      p.write 'app/helpers/plugin_helper.js', 'var PluginHelper = "ONE";'
+      p.write "app/models/plugin_model.js", "//= require <plugin/support.js>\nvar PluginModel = 'TWO';"
+      p.write "app/resources/plugin_models/default.yml", "five: 5"
+      p.write "app/resources/plugin_models/second.yml", "six: 6"
+      p.write "app/controllers/plugin_controller.js", "//= require <application_controller.js>\nvar PluginController = Jax.Controller.create('plugin', ApplicationController, {});"
+      p.write "lib/plugin/support.js", "var PLUGIN_SUPPORT = 1.0;"
+    end
+    
+    boot_app
+    self.class.destination Jax.root.to_s
+    @result = run_generator([])
+  end
+  
+  test "lib" do
+    assert_file "pkg/javascripts/app_template.js" do |content|
+      assert_match /var SUPPORT = 1.0;/, content
+      assert_match /var PLUGIN_SUPPORT = 1.0;/, content
+    end
+  end
+  
+  test "controllers" do
+    assert_file "pkg/javascripts/app_template.js" do |content|
+      # app and plugin controllers should both exist
+      assert_match /var MyController = Jax.Controller.create\('my', ApplicationController/, content
+      assert_match /var PluginController = Jax.Controller.create\('plugin', ApplicationController/, content
+      
+      # application controller should precede both
+      assert_match /ApplicationController\s*=.*?MyController\s*=/m, content
+      assert_match /ApplicationController\s*=.*?PluginController\s*=/m, content
+    end
+  end
+  
+  test "assets" do
+    assert_file "pkg/asset.txt"
+    assert_file "pkg/plugin-asset.txt"
+  end
+  
+  test "models" do
+    assert_file "pkg/javascripts/app_template.js" do |content|
+      assert_match /var MyModel = 'TWO';/, content
+      assert_match /var PluginModel = 'TWO';/, content
+    end
+  end
+  
+  test "resources" do
+    assert_file "pkg/javascripts/app_template.js" do |content|
+      content =~ /MyModel.addResources\((.*)?\)/
+      assert_not_nil $1, "MyModel has no resources"
+      hash = ActiveSupport::JSON.decode($1)
+      assert_equal 3, hash['default']['three']
+      assert_equal 4, hash['first']['four']
+
+      content =~ /PluginModel.addResources\((.*)?\)/
+      assert_not_nil $1, "PluginModel has no resources"
+      hash = ActiveSupport::JSON.decode($1)
+      assert_equal 5, hash['default']['five']
+      assert_equal 6, hash['second']['six']
+    end
+  end
+
+  test "helpers" do
+    assert_file "pkg/javascripts/app_template.js" do |content|
+      assert_match /var MyHelper = "ONE";/, content
+      assert_match /var PluginHelper = "ONE";/, content
+    end
+  end
+end

data/spec/lib/jax/plugin_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+# see also ./packager_test.rb for plugin stuff related to app packaging
+
+class Jax::PluginTest < IsolatedTestCase
+  def setup
+    build_app
+    plugin "cloud" do |p|
+      p.write "app/shaders/cloud/vertex.ejs", "void main() { }"
+    end
+    
+    boot_app
+  end
+  
+  test "detecting presence of plugin" do
+    assert_not_empty Jax.application.plugins
+  end
+  
+  test "plugin shaders" do
+    assert_not_nil Jax.application.shaders.find("cloud")
+    assert_equal abs("vendor/plugins/cloud/app/shaders/cloud"), Jax.application.shaders.find("cloud").path
+  end
+  
+  test "plugin paths" do
+    assert_contains abs("vendor/plugins/cloud"), Jax.application.javascript_source_roots
+  end
+end

data/spec/lib/jax/reloading_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+class Jax::ReloadingTest < IsolatedTestCase
+  def setup
+    build_app
+    app_file "app/shaders/clouds/fragment.ejs", "void main(void) { }"
+    boot_app
+  end
+  
+  test "shaders" do
+    assert_match /#{Regexp::escape("void main(void) { }")}/, Jax.application.shaders.find("clouds").fragment
+
+    app_file "app/shaders/clouds/fragment.ejs", "void main(void) { gl_FragColor = vec4(1,1,1,1); }"
+    assert_match /#{Regexp::escape("void main(void) { gl_FragColor = vec4(1,1,1,1); }")}/,
+                 Jax.application.shaders.find("clouds").fragment
+  end
+
+  test "resources" do
+    assert_no_match(/#{Regexp::escape "Door"}/, Jax.application.resources.to_s)
+    app_file "app/resources/doors/default.yml", "one: 1"
+    assert_match(/#{Regexp::escape "Door"}/, Jax.application.resources.to_s)
+  end
+end

data/spec/lib/jax/routes_test.rb

@@ -0,0 +1,28 @@
+require 'test_helper'
+require 'stringio'
+
+class Jax::RoutesTest < ActiveSupport::TestCase
+  def subject
+    @subject ||= Jax::Routes.new
+  end
+  
+  setup { @out = ""; @io = StringIO.new(@out) }
+  
+  test "should map root" do
+    subject.root "welcome"
+    subject.compile(@io)
+    assert_equal 'Jax.routes.root(WelcomeController, "index");', @out.strip
+  end
+  
+  test "should map" do
+    subject.map "path/to", "welcome"
+    subject.compile(@io)
+    assert_equal 'Jax.routes.map("path/to", WelcomeController, "index");', @out.strip
+  end
+
+  test "should map with action name" do
+    subject.map "path/to", "welcome", "another"
+    subject.compile(@io)
+    assert_equal 'Jax.routes.map("path/to", WelcomeController, "another");', @out.strip
+  end
+end

data/spec/lib/jax/shader_test.rb

@@ -0,0 +1,29 @@
+require 'test_helper'
+
+class Jax::ShaderTest < ActiveSupport::TestCase
+  def subject
+    @subject ||= Jax::Shader.new("path/to/shader")
+  end
+  
+  test "subject properties" do
+    assert_equal "shader", subject.name
+    assert_equal "path/to/shader", subject.path
+  end
+  
+  test "with an export" do
+    subject.fragment = "void main(void)\n{\n  vec4 ambient;\n  export(vec4, ambient, ambient);\n}"
+    
+    # This has to be done in JS because we can't possibly avoid variable redefinitions at this stage
+    # it's this or have broken shader chains whenever two shaders happen to export the same variable
+    assert_no_match(/vec4 _shader_ambient;/, subject.to_s)
+    assert_match /exports: \{['"]ambient['"]:\s*['"]vec4['"]\},/, subject.to_s
+  end
+  
+  test "with an import" do
+    subject.fragment = "void main(void)\n{\n  vec4 a = import(ambient);\n}"
+    
+    # This has to be done in JavaScript because we can't possibly know the exports of other shaders at this stage...
+    # it's this or have broken shader chains whenever they're not used in an expected order
+    assert_no_match(/_shader_ambient/, subject.to_s)
+  end
+end

data/spec/lib/jax/tasks/jax_rake_test.rb

@@ -0,0 +1,85 @@
+require 'test_helper'
+require 'test_app'
+
+class Jax::RakeTasksTest < Rails::Generators::TestCase
+  PWD = File.expand_path("../tmp/generator_tests/test_app", Jax.framework_root)
+  self.destination_root = PWD
+  
+  def shell
+    @shell ||= SpecShell.new
+  end
+  
+  def rake(args)
+    output = `bundle exec rake #{args} 2>&1`
+    if !$?.success?
+      raise output
+    end
+  end
+
+  # TODO clean this up
+  setup do
+    FileUtils.rm_rf PWD
+    FileUtils.mkdir_p File.dirname(PWD) unless File.exist?(File.dirname(PWD))
+    Dir.chdir File.expand_path('..', PWD)
+    FileUtils.mkdir_p PWD
+    Dir.chdir File.dirname(PWD)
+    Jax::Generators::App::AppGenerator.start(["test_app"], :shell => shell)
+    Dir.chdir PWD
+    File.open("Gemfile", "w") { |f| f.print "gem 'jax', :path => '#{File.expand_path('../../../', PWD)}'"}
+    `bundle install`
+    Jax::Generators::Controller::ControllerGenerator.start(['welcome', 'index'], :shell => shell)
+    File.open("config/routes.rb", "w") do |f|
+      f.puts "TestApp.routes.map do\n  root 'welcome'\nmap 'another/index'\nend"
+    end
+    FileUtils.mkdir_p "public/images"
+    FileUtils.touch "public/images/test.png"
+  end
+
+  teardown do
+    FileUtils.rm_rf PWD
+    Dir.chdir File.expand_path('..', PWD)
+  end
+  
+  test "jax:generate_files" do
+    rake('jax:generate_files')
+    
+    assert_match /jax:update/, File.read(File.expand_path('tmp/version_check.js'))
+  end
+  
+  test "jax:generate_files does not duplicate routes" do
+    rake('jax:generate_files')
+    assert_file "tmp/routes.js" do |routes|
+      routes.lines.each do |line|
+        assert routes.split(line.chomp).length < 3
+      end
+    end
+  end
+  
+  test "jax:package" do
+    rake('jax:package')
+
+    subject = File.read(File.expand_path('pkg/javascripts/test_app.js'))
+    
+    # should install assets
+    assert_file 'pkg/images/test.png'
+    
+    assert_file 'pkg/javascripts/test_app.js' do |app|
+      # should not do a version check
+      assert_no_match /jax:update/, app
+      # should contain views
+      assert_match /Jax.views.push\('welcome\/index'/, app
+      # should contain welcome controller
+      assert_match /var WelcomeController = /, app
+      # should contain application controller
+      assert_match /var ApplicationController = /, app
+      # should contain welcome helper
+      assert_match /var WelcomeHelper = /, app
+      # should contain application helper
+      assert_match /var ApplicationHelper = /, app
+      # should contain routes
+      assert_match /#{Regexp::escape 'Jax.routes.root(WelcomeController, "index")'}/, app
+      # should not contain ruby package names
+      assert_match /#{Regexp::escape 'Jax.routes.map("another/index", AnotherController, "index")'}/, app
+    end
+  end
+end

data/spec/support/bases/generator_test_case.rb

@@ -0,0 +1,108 @@
+require 'rails/generators/test_case'
+require 'active_support/testing/isolation'
+
+# probably should have one of these in standard jax dist, but not
+# necessarily *this* class
+class Jax::Generators::TestCase < Rails::Generators::TestCase
+  include ActiveSupport::Testing::Isolation unless ENV['DO_NOT_ISOLATE']
+  
+  def self.inherited(base)
+    super
+    base.class_eval do
+      destination Jax.application ? Jax.root : File.expand_path('../tmp/tmp', Jax.framework_root)
+      setup :prepare_destination
+      teardown :restore_streams
+      
+      begin
+        name = base.name.sub(/Test$/, '').split(/::/)
+        konst = (name.first == "Jax") ? Object.class : Jax::Generators
+        while const_name = name.shift
+          konst = konst.const_get(const_name)
+        end
+        base.tests konst
+      rescue
+      end
+    end
+  end
+  
+  # call this when you've included both TestHelpers::Paths and TestHelpers::Generation
+  # and want to test Jax generators within plugin directories.
+  def plugin_generator(plugin_name, &block)
+    plugin plugin_name, &block
+    # this happens in bin/jax
+    self.class.destination app_path
+    @jax_cwd = File.join(app_path, "vendor/plugins", plugin_name)
+    File.mkdir_p @jax_cwd unless File.directory?(@jax_cwd)
+  end
+  
+  setup do
+    unless Jax.application || self.class.include?(TestHelpers::Generation)
+      require 'test_app'
+      self.class.destination Jax.root
+    end
+  end
+  
+  def generate(*args)
+    ENV['JAX_CWD'] = @jax_cwd
+    result = run_generator args
+    ENV['JAX_CWD'] = nil
+    result
+  end
+  
+  def copy_routes
+    routes = File.expand_path("../../../../lib/jax/generators/app/templates/config/routes.rb.tt", __FILE__)
+    destination = File.join(destination_root, "config")
+    FileUtils.mkdir_p destination
+    FileUtils.cp routes, File.join(destination, "routes.rb")
+  end
+  
+  def stub_file(path, content = nil)
+    file = File.expand_path(path, destination_root)
+    FileUtils.mkdir_p File.dirname(file)
+    File.open(file, "w") do |f|
+      f.print content if content
+      yield f if block_given?
+    end
+    File.read(file)
+  end
+  
+  def stdin
+    mock_stream :stdin
+  end
+  
+  def stdout
+    mock_stream :stdout
+  end
+  
+  def stderr
+    mock_stream :stderr
+  end
+  
+  def mock_stream(type)
+    @mock_streams ||= {}
+    @mock_streams[type] ||= StringIO.new
+    @mock_streams[type].instance_eval do
+      def returns(str)
+        self.string = str
+      end
+    end
+    prepare_mock_stream type, @mock_streams[type]
+  end
+  
+  def real_streams
+    @real_streams ||= {}
+  end
+  
+  def prepare_mock_stream(type, stream)
+    real_streams[type] ||= eval("$#{type}")
+    set_stream type, stream
+  end
+  
+  def restore_streams
+    real_streams.each { |type, stream| set_stream type, stream }
+  end
+  
+  def set_stream(type, stream)
+    eval "$#{type} = stream"
+  end
+end