jax 0.0.0.1

data/spec/javascripts/jax/webgl_spec.js

@@ -0,0 +1,5 @@
+describe("WebGL", function() {
+  it("should define glClearColor", function() {
+    expect(GL_METHODS['glClearColor']).not.toBeUndefined();
+  });
+});

data/spec/javascripts/jax/world_spec.js

@@ -0,0 +1,88 @@
+describe("Jax.World", function() {
+  var context;
+  var world;
+  
+  beforeEach(function() {
+    context = new Jax.Context('canvas-element');
+    world = context.world;
+  });
+  
+  afterEach(function() {
+    context.dispose();
+  });
+  
+  describe("with an object", function() {
+    beforeEach(function() { world.addObject(new Jax.Model()); });
+    
+    it("should remove the object", function() {
+      world.removeObject(world.getObject(0));
+      expect(world.countObjects()).toEqual(0);
+    });
+  });
+  
+  describe("with lighting disabled", function() {
+    beforeEach(function() { world.lighting.disable(); });
+    
+    // we no longer switch materials in Jax.World depending on lighting. "Basic" and "default" are the same, now.
+    xit("should default to the 'basic' material", function() {
+      var model = new Jax.Model();
+      world.addObject(model);
+      expect(model).toDefaultToMaterial("basic", world);
+      world.render();
+    });
+  });
+
+  describe("with lighting enabled", function() {
+    beforeEach(function() { world.addLightSource(new Jax.Scene.LightSource({type:Jax.DIRECTIONAL_LIGHT})); });
+    
+    it("should default to the 'default' material", function() {
+      var model = new Jax.Model({mesh:new Jax.Mesh.Quad()});
+      world.addObject(model);
+      expect(model).toDefaultToMaterial('default', world);
+    });
+    
+    xit("should use the 'default' material", function() {
+      var model = new Jax.Model({mesh:new Jax.Mesh.Quad()});
+      world.addObject(model);
+      expect(model).toUseMaterial('default', world);
+    });
+    
+    describe("but the object unlit", function() {
+      var model;
+      
+      beforeEach(function() {
+        // notice the explicit use of "basic" here. This is so we can test that explicit "basic" types
+        // get rendered as such, instead of simply being chucked into the "lighting is enabled, use blinn-phong"
+        // category.
+        model = new Jax.Model({mesh:new Jax.Mesh.Sphere({material:"basic",color:[0.5,0.5,0.5,1]}), lit:false });
+      });
+      
+      describe("and unshadowed", function() {
+        beforeEach(function() {
+          model = new Jax.Model({mesh:new Jax.Mesh.Quad(), shadow_caster: false, lit:false});
+        });
+        
+        xit("should use basic material", function() {
+          world.addObject(model);
+          expect(model).toUseMaterial('basic', world);
+        });
+        
+        it("should not cast a shadow", function() {
+          world.addObject(model);
+          expect(model).not.toCastShadow(world);
+        });
+      });
+      
+      it("should still cast a shadow", function() {
+        world.addObject(model);
+        expect(world.getShadowCasters()).toContain(model);
+        expect(model).toCastShadow(world);
+      });
+      
+      xit("should be rendered with basic material", function() {
+        world.addObject(model);
+        expect(model).toUseMaterial('basic', world);
+      });
+    });
+  });
+});

data/spec/javascripts/jax_spec.js

@@ -0,0 +1,27 @@
+window.addEventListener("load", function() {
+  var canvas = document.createElement("canvas");
+  canvas.setAttribute("width", "600");
+  canvas.setAttribute("height", "400");
+  canvas.setAttribute("id", "canvas-element");
+  canvas.style.visibility = "hidden";
+  document.body.appendChild(canvas);
+  
+  var style = document.createElement('style');
+  style.innerHTML = ".resultMessage.fail { white-space:pre-line; }";
+  document.getElementsByTagName('head')[0].appendChild(style);
+}, false);
+
+describe("Jax", function() {
+  it("should be loaded", function() {
+    /* if false, then it didn't load all of the Jax libraries successfully */
+    expect(Jax.loaded).toBeTrue();
+  });
+  
+  it("should create the top-level view container", function() {
+    expect(Jax.views).not.toBeUndefined();
+  });
+  
+  it("should initialize the route set", function() {
+    expect(Jax.routes).not.toBeUndefined();
+  });
+});

data/spec/javascripts/support/jasmine.yml

@@ -0,0 +1,85 @@
+# src_files
+#
+# Return an array of filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# src_files:
+#   - lib/source1.js
+#   - lib/source2.js
+#   - dist/**/*.js
+#
+src_files:
+    - dist/jax.js
+    - tmp/shaders.js
+
+# stylesheets
+#
+# Return an array of stylesheet filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# stylesheets:
+#   - css/style.css
+#   - stylesheets/*.css
+#
+stylesheets:
+
+# helpers
+#
+# Return an array of filepaths relative to spec_dir to include before jasmine specs.
+# Default: ["helpers/**/*.js"]
+#
+# EXAMPLE:
+#
+# helpers:
+#   - helpers/**/*.js
+#
+helpers:
+
+# spec_files
+#
+#  Return an array of filepaths relative to spec_dir to include.
+# Default: ["**/*[sS]pec.js"]
+#
+# EXAMPLE:
+#
+# spec_files:
+#   - **/*[sS]pec.js
+#
+spec_files:
+
+# src_dir
+#
+# Source directory path. Your src_files must be returned relative to this path. Will use root if left blank.
+# Default: project root
+#
+# EXAMPLE:
+#
+# src_dir: public
+#
+src_dir:
+
+# spec_dir
+#
+# Spec directory path. Your spec_files must be returned relative to this path.
+# Default: spec/javascripts
+#
+# EXAMPLE:
+#
+# spec_dir: spec/javascripts
+#
+spec_dir:
+
+# root_dir
+#
+# Root directory path. Files in this directory will be mounted in the web server's root ("/") path.
+# Default: project directory
+#
+# EXAMPLE:
+#
+# root_dir: public
+#
+root_dir: public

data/spec/javascripts/support/jasmine_runner.rb

@@ -0,0 +1,32 @@
+$:.unshift(ENV['JASMINE_GEM_PATH']) if ENV['JASMINE_GEM_PATH'] # for gem testing purposes
+
+require 'rubygems'
+require 'jasmine'
+jasmine_config_overrides = File.expand_path(File.join(File.dirname(__FILE__), 'jasmine_config.rb'))
+require jasmine_config_overrides if File.exist?(jasmine_config_overrides)
+if Jasmine::rspec2?
+  require 'rspec'
+else
+  require 'spec'
+end
+
+jasmine_config = Jasmine::Config.new
+spec_builder = Jasmine::SpecBuilder.new(jasmine_config)
+
+should_stop = false
+
+if Jasmine::rspec2?
+  RSpec.configuration.after(:suite) do
+    spec_builder.stop if should_stop
+  end
+else
+  Spec::Runner.configure do |config|
+    config.after(:suite) do
+      spec_builder.stop if should_stop
+    end
+  end
+end
+
+spec_builder.start
+should_stop = true
+spec_builder.declare_suites

data/spec/lib/jax/routes_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'stringio'
+
+describe Jax::Routes do
+  before(:each) { @out = ""; @io = StringIO.new(@out) }
+  
+  it "should map root" do
+    subject.root "welcome"
+    subject.compile(@io)
+    @out.strip.should == 'Jax.routes.root(WelcomeController, "index");'
+  end
+  
+  it "should map" do
+    subject.map "path/to", "welcome"
+    subject.compile(@io)
+    @out.strip.should == 'Jax.routes.map("path/to", WelcomeController, "index");'
+  end
+
+  it "should map with action name" do
+    subject.map "path/to", "welcome", "another"
+    subject.compile(@io)
+    @out.strip.should == 'Jax.routes.map("path/to", WelcomeController, "another");'
+  end
+end

data/spec/lib/jax/shader_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+describe Jax::Shader do
+  subject { Jax::Shader.new("path/to/shader") }
+  
+  it "should set name" do
+    subject.name.should == "shader"
+  end
+  
+  it "should set path" do
+    subject.path.should == "path/to/shader"
+  end
+  
+  context "with an export" do
+    before(:each) { subject.fragment = "void main(void)\n{\n  vec4 ambient;\n  export(vec4, ambient, ambient);\n}" }
+    
+    it "should NOT produce global variable declaration because that's done in JS" do
+      # 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
+      subject.to_s.should_not =~ /vec4 _shader_ambient;/
+    end
+#    it "should produce global variable declaration" do
+#      subject.to_s.should =~ /vec4 _shader_ambient;/
+#    end
+    
+    # moved to JS for greater flexibility -- doing it here we can't adjust for shader chains
+#    it "should produce global variable assignment" do
+#      subject.to_s.should =~ /_shader_ambient = ambient;/
+#    end
+    
+    it "should save exports to js" do
+      subject.to_s.should =~ /exports: \{['"]ambient['"]:\s*['"]vec4['"]\},/
+    end
+  end
+  
+  context "with conflicting export values" do
+    before(:each) { subject.fragment = "void main(void) { export(vec4, ambient, one); export(vec4, ambient, two); }" }
+    
+#    it "should not have two exports" do
+#      subject.to_s.should_not =~ /vec4 _shader_ambient.*vec4 _shader_ambient/
+#    end
+  end
+  
+  context "with an import" do
+    before(:each) { subject.fragment = "void main(void)\n{\n  vec4 a = import(ambient);\n}" }
+    
+    it "should NOT produce global variable reference because that's done in JS" do
+      # 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
+      subject.to_s.should_not =~ /_shader_ambient/
+    end
+    
+#    it "should produce global variable reference" do
+#      subject.to_s.should =~ /vec4 a = _shader_ambient;/
+#    end
+  end
+end

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

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+pwd = File.join(Dir.pwd, "generator_tests")
+
+describe "Rake Tasks:" do
+  def shell
+    @shell ||= SpecShell.new
+  end
+  
+  def rake(args)
+    output = `bundle exec rake #{args} 2>&1`
+    if !$?.success?
+      raise output
+    end
+  end
+
+  before :all do
+    FileUtils.rm_rf pwd
+    Dir.chdir File.expand_path('..', pwd)
+    FileUtils.mkdir_p pwd
+    Dir.chdir pwd
+    Jax::Generators::App::AppGenerator.start(["test_app"], :shell => shell)
+#    puts shell.output.string
+    Dir.chdir File.join(pwd, "test_app")
+    File.open("Gemfile", "w") { |f| f.print "gem 'jax', :path => '#{File.join(File.dirname(__FILE__), "../../../..")}'"}
+    `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
+
+  after :all do
+    FileUtils.rm_rf pwd
+    Dir.chdir File.expand_path('..', pwd)
+  end
+  
+  context "jax:package" do
+    before(:each) { rake('jax:package') }
+    
+    context "javascript" do
+      subject { File.read(File.expand_path('pkg/javascripts/test_app.js')) }
+      
+      it "should install assets" do
+        File.should exist('pkg/images/test.png')
+      end
+      
+      it "should contain views" do
+        subject.should =~ /Jax.views.push\('welcome\/index'/
+      end
+      
+      it "should contain welcome controller" do
+        subject.should =~ /var WelcomeController = /
+      end
+      
+      it "should contain application controller" do
+        subject.should =~ /var ApplicationController = /
+      end
+      
+      it "should contain welcome helper" do
+        subject.should =~ /var WelcomeHelper = /
+      end
+      
+      it "should contain application helper" do
+        subject.should =~ /var ApplicationHelper = /
+      end
+      
+      it "should contain routes" do
+        subject.should =~ /#{Regexp::escape 'Jax.routes.root(WelcomeController, "index")'}/
+      end
+      
+      it "should not contain ruby package names" do
+        subject.should =~ /#{Regexp::escape 'Jax.routes.map("another/index", AnotherController, "index")'}/
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require File.join(File.dirname(__FILE__), "../lib/jax")
+require File.join(File.dirname(__FILE__), "../lib/jax/generators/app")
+require File.join(File.dirname(__FILE__), "../lib/jax/generators/commands")
+
+Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each do |fi|
+  require fi
+end
+
+RSpec.configure do |config|
+  config.include FileExistMatcher
+end

data/spec/support/file_exist_matcher.rb

@@ -0,0 +1,23 @@
+module FileExistMatcher
+  def exist(name)
+    FileExistMatcher.new(name)
+  end
+
+  class FileExistMatcher
+    def initialize(name)
+      @name = name
+    end
+
+    def matches?(what)
+      what.exist?(@name)
+    end
+
+    def failure_message
+      "Expected file '#{@name}' to exist"
+    end
+
+    def negative_failure_message
+      "Expected file '#{@name}' to not exist"
+    end
+  end
+end

data/spec/support/spec_shell.rb

@@ -0,0 +1,97 @@
+require 'thor/shell/basic'
+
+class SpecShell < Thor::Shell::Basic
+  attr_reader :stdin, :stdout, :stderr
+  alias input stdin
+  alias output stdout
+  
+  def initialize(options = { })
+    super()
+    @stdin  = StringIO.new(options[:in ] || '')
+    @stdout = StringIO.new(options[:out] || '')
+    @stderr = StringIO.new(options[:err] || '')
+  end
+
+  def ask(statement, color=nil)
+    say("#{statement} ", color)
+    @stdin.gets.strip
+  end
+
+  def say(message="", color=nil, force_new_line=(message.to_s !~ /( |\t)$/))
+    message = message.to_s
+    message = set_color(message, color) if color
+
+    spaces = "  " * padding
+
+    if force_new_line
+      @stdout.puts(spaces + message)
+    else
+      @stdout.print(spaces + message)
+    end
+    @stdout.flush
+  end
+
+  def say_status(status, message, log_status=true)
+    return if quiet? || log_status == false
+    spaces = "  " * (padding + 1)
+    color  = log_status.is_a?(Symbol) ? log_status : :green
+
+    status = status.to_s.rjust(12)
+    status = set_color status, color, true if color
+
+    @stdout.puts "#{status}#{spaces}#{message}"
+    @stdout.flush
+  end
+
+  def print_table(table, options={})
+    return if table.empty?
+
+    formats, ident, colwidth = [], options[:ident].to_i, options[:colwidth]
+    options[:truncate] = terminal_width if options[:truncate] == true
+
+    formats << "%-#{colwidth + 2}s" if colwidth
+    start = colwidth ? 1 : 0
+
+    start.upto(table.first.length - 2) do |i|
+      maxima ||= table.max{|a,b| a[i].size <=> b[i].size }[i].size
+      formats << "%-#{maxima + 2}s"
+    end
+
+    formats[0] = formats[0].insert(0, " " * ident)
+    formats << "%s"
+
+    table.each do |row|
+      sentence = ""
+
+      row.each_with_index do |column, i|
+        sentence << formats[i] % column.to_s
+      end
+
+      sentence = truncate(sentence, options[:truncate]) if options[:truncate]
+      @stdout.puts sentence
+    end
+  end
+
+  def print_wrapped(message, options={})
+    ident = options[:ident] || 0
+    width = terminal_width - ident
+    paras = message.split("\n\n")
+
+    paras.map! do |unwrapped|
+      unwrapped.strip.gsub(/\n/, " ").squeeze(" ").
+      gsub(/.{1,#{width}}(?:\s|\Z)/){($& + 5.chr).
+      gsub(/\n\005/,"\n").gsub(/\005/,"\n")}
+    end
+
+    paras.each do |para|
+      para.split("\n").each do |line|
+        @stdout.puts line.insert(0, " " * ident)
+      end
+      @stdout.puts unless para == paras.last
+    end
+  end
+
+  def error(statement)
+    @stderr.puts statement
+  end
+end