jax 1.1.1 → 2.0.0

data/lib/jax/shader.rb

@@ -1,185 +1,83 @@
-class Jax::Shader
-  # attr_reader :common, :fragment, :vertex
-  attr_accessor :name, :path, :exports, :manifest
-  
-  def initialize(path, name = File.basename(path))
-    @exports = {}
-    @name = name
-    @path = path
-    
-    detect_sources
-  end
-  
-  def common
-    detect_sources # force reloads the latest sources
-    @common
-  end
-  
-  def fragment
-    detect_sources # force reloads the latest sources
-    @fragment
-  end
-  
-  def vertex
-    detect_sources # force reloads the latest sources
-    @vertex
-  end
-  
-  def description
-    manifest && manifest['description']
-  end
-  
-  def to_s
-    "Jax.shaders['#{name}'] = new Jax.Shader(#{js_options.gsub(/<%/, '<%')});"
-  end
-  
-  def default_options
-    manifest && manifest['options'] || {}
-  end
-  
-  def save_to(file_or_filename)
-    if file_or_filename.kind_of?(String)
-      File.open(filename, "w") { |f| f.puts to_s }
-    else file_or_filename.puts to_s
+require 'sprockets'
+
+module Jax
+  class Shader < Sprockets::DirectiveProcessor
+    def self.default_mime_type
+      "application/javascript"
     end
-  end
-  
-  class << self
-    def from(path)
-      raise ArgumentError, "Expected path to be a directory" unless File.directory? path
-      new(path)
+
+    def exports
+      @exports ||= {}
     end
-  end
-  
-  def common=(str)
-    @common = preprocess(str).inspect
-  end
-  
-  def fragment=(str)
-    @fragment = preprocess(str).inspect
-  end
-  
-  def vertex=(str)
-    @vertex = preprocess(str).inspect
-  end
-  
-  def preprocess(str)
-    include_dependencies str
-    intercept_export_directives str
-#    intercept_import_directives str
-#    prepend_export_definitions str
     
-    str
-  end
-  
-  private
-  def detect_sources
-    detect_ejs
-    detect_manifest
-  end
-  
-  def detect_manifest
-    if File.file?(file = File.join(path, "manifest.yml"))
-      yml = YAML::load(File.read(file))
-      @manifest = yml || {}
-    end
-  end
-  
-  def detect_ejs
-    %w(common fragment vertex).each do |name|
-      if File.file?(file = File.join(path, "#{name}.ejs"))
-        send("#{name}=", File.read(file))
-      end
-    end
-  end
-  
-  def intercept_import_directives(str)
-    str.gsub! /import\s*\(\s*([^\s]*)\s*\)/ do
-      export_name($~[1])
-    end
-  end
-  
-  def prepend_export_definitions(str)
-    exports.each do |name, export|
-      str.insert 0, "#{export[:type]} #{name};\n"
-    end
-  end
-  
-  def intercept_export_directives(str)
-    intercept_export_directives_with_assignment(str)
-    intercept_export_directives_without_assignment(str)
-  end
-  
-  def intercept_export_directives_without_assignment(str)
-    str.gsub! /export\s*\(\s*([^\s]*),\s*([^\s]*)\s*\);?/ do |match|
-      export $~[1], $~[2]
-      match # we'll do the rest on the JS side
-    end
-  end
-  
-  def intercept_export_directives_with_assignment(str)
-    str.gsub! /export\s*\(\s*([^\s]*),\s*([^\s]*),\s*([^\s]*)\s*\);?/ do |match|
-      export $~[1], $~[2], $~[3]
-      match # we'll do the rest on the JS side
+    def process_require_directive(path)
+      super
+
+      # FIXME this is kind of a hacky solution to get function bodies included.
+      # Should shaders be rewritten entirely, including the JS APIs?
+      shader_name, shader_type = shader_type_and_name_for_path(path)
+        
+      str = "<%= Jax.import_shader_code(#{shader_name.inspect}, #{shader_type.inspect}) %>\n"
+      body.insert 0, str unless body[str]
     end
-  end
-  
-  def export(type, name, value = name)
-    exports[name] ||= { :type => type, :value => value }
-    "#{exported_name(name)} = #{value};"
-  end
-  
-  def include_dependencies(str)
-    # look for Sprockets-style require directives
-    str.gsub! /\/\/=\s*require\s*['"]([^'"]*)['"]/m do |sub|
-      filename = $~[1]
-      found = false
-      paths = Jax.shader_load_paths
-      result = nil
-      for path in paths
-        if File.file?(real = File.join(path, "#{filename}.ejs"))
-          found = true
-          macro_name = "dependency_#{filename}".underscore.gsub(/[^a-zA-Z0-9_]/, '_')
-          result = <<-end_code
-          #ifndef #{macro_name}
-          #define #{macro_name}
+    
+    def evaluate(context, locals, &block)
+      body = super
+      body = process_exports(body)
+      
+      shader_name, shader_type = shader_type_and_name_for_path
       
-          #{File.read(real)}
-          #endif
-          end_code
-          break
+      result = "Jax.shader_data(#{shader_name.inspect})[#{shader_type.inspect}] = #{body.inspect};\n"
+      unless exports.empty?
+        exports_var = "Jax.shader_data(#{shader_name.inspect})[\"exports\"]"
+        exports_str   = "#{exports_var} = #{exports_var} || {};\n"
+        exports.each do |name, type|
+          exports_str+= "#{exports_var}[#{name.inspect}] = #{type.inspect};\n"
         end
+        result.insert 0, exports_str
       end
-      
-      raise "Required file '#{filename}.ejs' not found in load paths #{paths.inspect} for shader '#{name}'!" if !found
       result
     end
-  end
-  
-  def exported_name(name)
-    "_#{self.name}_#{name}"
-  end
-  
-  def export_keys_as_js
-    "{" + exports.collect { |key,value| export_descriptor(key, value) }.join(",") + "}"
-  end
-  
-  def export_descriptor(name, info)
-    "#{name.to_s.inspect}:#{info[:type].to_s.inspect}"
-  end
-  
-  def js_options
-    result = "{"
-    %w(common fragment vertex).each do |segment|
-      data = send segment
-      if data
-        result += "  #{segment}:#{data},\n"
+    
+    def process_exports(body, rx = nil)
+      if rx
+        body.scan(rx).uniq.each do |export|
+          # scan gets us mostly there, but we still need the arguments.
+          export =~ rx
+          type  = $~[1]
+          name  = $~[2]
+          value = $~[3]
+          exports[name] = type
+          # we may use type later, when we start actively generating the export code.
+          # Currently, that's done in JS.
+        end
+        body
+      else
+        process_exports_without_assignment(process_exports_with_assignment(body))
       end
     end
-    result += "exports: #{export_keys_as_js},\n"
-    result += "name: #{name.inspect}"
-    result += "}"
     
-    result
+    def process_exports_without_assignment(body)
+      process_exports body, /export\s*\(\s*([^\s]*),\s*([^\s]*)\s*\);?/
+    end
+    
+    def process_exports_with_assignment(body)
+      process_exports body, /export\s*\(\s*([^\s]*),\s*([^\s]*),\s*([^\)]*)\);?/
+    end
+    
+    def shader_type_and_name_for_path(path = nil)
+      if path.nil?
+        logical_path = context.logical_path
+      else
+        logical_path = context.environment.attributes_for(context.resolve path).logical_path
+      end
+      shader_name = File.basename(File.dirname(logical_path))
+      shader_type = File.basename(logical_path)
+      if (shader_type =~ /\.[^\.]+$/)
+        shader_type = $`
+      end
+      
+      [shader_name, shader_type]
+    end
   end
-end
+end

data/lib/jax/testing/rails_environment.rb

@@ -0,0 +1,94 @@
+module Jax
+  module Testing
+    # Set up a subclass of Rails::Application and set `config.root` to a temporary
+    # path prior to calling #setup_rails_environment.
+    # 
+    # Example:
+    #   include Jax::Testing::RailsEnvironment
+    #   
+    #   setup do
+    #     setup_rails_environment
+    #     
+    #     create_file "app/assets/jax/resources/people/default.resource" do |f|
+    #       f.puts "name: Colin"
+    #     end
+    #     
+    #     create_file "version", "1.0.0"
+    #   end
+    #
+    module RailsEnvironment
+      # WARNING: Set Rails.application.config.root to some temporary directory name
+      # before calling this method! This method deletes the Rails root in order to set
+      # up the fixture for the next test run.
+      def setup_rails_environment
+        root = ::Rails.root.to_s
+        
+        create_empty_directory root
+        create_directory 'app/assets' # required for Rails to pick up assets paths
+        create_file "config/routes.rb" do |f|
+          f.puts "Rails.application.routes.draw do\nend"
+        end
+
+        Jax.reset_config!
+      end
+
+      def local(path)
+        path =~ /^#{Regexp::escape ::Rails.root.to_s}/ ? path : ::Rails.root.join(path).to_s
+      end
+
+      def create_empty_directory dir
+        FileUtils.rm_rf local(dir)
+        create_directory dir
+      end
+
+      def create_directory(dir)
+        FileUtils.mkdir_p local(dir)
+      end
+
+      def create_file(file, content = nil)
+        create_directory File.dirname(file)
+        File.open(local(file), "w") do |f|
+          f.puts content if content
+          yield f if block_given?
+        end
+      end
+      
+      def create_asset(file, content = nil, &block)
+        create_file File.join("app/assets/jax", file), content, &block
+      end
+      
+      def create_shader(path, contents = {})
+        create_asset File.join("shaders", path, "common.glsl"),   contents[:common]   if contents[:common]
+        create_asset File.join("shaders", path, "fragment.glsl"), contents[:fragment] if contents[:fragment]
+        create_asset File.join("shaders", path, "vertex.glsl"),   contents[:vertex]   if contents[:vertex]
+      end
+
+      def assets
+        ::Rails.application.assets
+      end
+
+      def asset(path)
+        asset = assets.find_asset(path)
+        raise "asset not found: #{path} in #{@asset_dir}" unless asset
+        asset.body
+      end
+
+      def append_to_file(file, content = nil, &block)
+        if File.file?(local file)
+          File.open(local(file), "w+") do |f|
+            f.puts content if content
+            yield f if block_given?
+          end
+        else
+          create_file(file, content, &block)
+        end
+      end
+
+      def route(content)
+        append_to_file "config/routes.rb" # create it if missing
+        routes = File.read(local "config/routes.rb")
+        create_file("config/routes.rb", routes.sub(/Rails.application.routes.draw do$/, "\\1#{content}"))
+      end
+    end
+  end
+end

data/lib/jax/util/tar.rb

@@ -0,0 +1,75 @@
+require 'rubygems'
+require 'rubygems/package'
+require 'zlib'
+require 'fileutils'
+
+module Jax::Util::Tar
+  # Creates a tar file in memory recursively
+  # from the given path.
+  #
+  # Returns a StringIO whose underlying String
+  # is the contents of the tar file.
+  def tar(path)
+    tarfile = StringIO.new("")
+    Gem::Package::TarWriter.new(tarfile) do |tar|
+      Dir[File.join(path, "**/*")].each do |file|
+        mode = File.stat(file).mode
+        relative_file = file.sub /^#{Regexp::escape path}\/?/, ''
+        
+        if File.directory?(file)
+          tar.mkdir relative_file, mode
+        else
+          tar.add_file relative_file, mode do |tf|
+            File.open(file, "rb") { |f| tf.write f.read }
+          end
+        end
+      end
+    end
+    
+    tarfile.rewind
+    tarfile
+  end
+  
+  # gzips the underlying string in the given StringIO,
+  # returning a new StringIO representing the 
+  # compressed file.
+  def gzip(tarfile)
+    gz = StringIO.new("")
+    z = Zlib::GzipWriter.new(gz)
+    z.write tarfile.string
+    z.close # this is necessary!
+    
+    # z was closed to write the gzip footer, so
+    # now we need a new StringIO
+    StringIO.new gz.string
+  end
+  
+  # un-gzips the given IO, returning the
+  # decompressed version as a StringIO
+  def ungzip(tarfile)
+    z = Zlib::GzipReader.new(tarfile)
+    unzipped = StringIO.new(z.read)
+    z.close
+    unzipped
+  end
+  
+  # untars the given IO into the specified
+  # directory
+  def untar(io, destination)
+    Gem::Package::TarReader.new io do |tar|
+      tar.each do |tarfile|
+        destination_file = File.join destination, tarfile.full_name
+        
+        if tarfile.directory?
+          FileUtils.mkdir_p destination_file
+        else
+          destination_directory = File.dirname(destination_file)
+          FileUtils.mkdir_p destination_directory unless File.directory?(destination_directory)
+          File.open destination_file, "wb" do |f|
+            f.print tarfile.read
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jax/util.rb

@@ -0,0 +1,3 @@
+module Jax::Util
+  autoload :Tar, "jax/util/tar"
+end

data/lib/jax/version.rb

@@ -1,12 +1,11 @@
 module Jax
   module Version
-    MAJOR  = 1
-    MINOR  = 1
-    TINY   = 1
-    PREREL = nil
-
-    STRING = PREREL ? "#{MAJOR}.#{MINOR}.#{TINY}.#{PREREL}" : "#{MAJOR}.#{MINOR}.#{TINY}"
+    MAJOR = 2
+    MINOR = 0
+    PATCH = 0
+    BUILD = nil
+    STRING = BUILD ? [MAJOR, MINOR, PATCH, BUILD].join(".") : [MAJOR, MINOR, PATCH].join(".")
   end
-
-  VERSION = Version::STRING
+  
+  VERSION = Jax::Version::STRING
 end

data/lib/jax.rb

@@ -1,46 +1,28 @@
-require "active_support/core_ext"
-require "rails/railtie"
-require File.expand_path("jax/core_ext/kernel", File.dirname(__FILE__))
-
-# Don't raise an error when we extend Jax::Engine or Jax::Application
-Rails::Railtie::ABSTRACT_RAILTIES << "Jax::Engine" << "Jax::Application"
-
-JAX_FRAMEWORK_ROOT = File.expand_path('.', File.dirname(__FILE__)) unless defined?(JAX_FRAMEWORK_ROOT)
+require 'rails'
+require 'jquery/rails'
+require 'jax/engine'
 
 module Jax
-  autoload :Engine,           "jax/engine"
-  autoload :Generators,       "jax/generators/commands"
-  autoload :VERSION,          "jax/version"
-  autoload :Version,          "jax/version"
-  autoload :Application,      "jax/application"
-  autoload :Packager,         "jax/packager"
-  autoload :ResourceCompiler, "jax/resource_compiler"
-  autoload :Routes,           "jax/routes"
-  autoload :Shader,           "jax/shader"
-  autoload :Plugin,           "jax/plugin"
+  autoload :Commands,           "jax/commands"
+  autoload :Configuration,      "jax/configuration"
+  autoload :DirectiveProcessor, "jax/directive_processor"
+  autoload :Generators,         "generators/jax/all"
+  autoload :HelperMethods,      "jax/helper_methods"
+  autoload :ResourceFile,       "jax/resource_file"
+  autoload :Server,             "jax/server"
+  autoload :Shader,             "jax/shader"
+  autoload :Version,            "jax/version"
+  autoload :VERSION,            "jax/version"
+  autoload :PluginManager,      "jax/commands/plugin_manager"
+  autoload :Util,               "jax/util"
   
-  class << self
-    def application
-      @application ||= nil
-    end
-    
-    def application=(application)
-      @application = application
-    end
-    
-    def root
-      application && application.root
-    end
-    
-    def framework_root
-      JAX_FRAMEWORK_ROOT
-    end
-    
-    delegate :shader_load_paths, :javascript_load_paths, :plugin_repository_url, :default_plugin_repository_url,
-             :plugin_repository_url=, :to => :application
+  module_function
+  
+  def config
+    @config || reset_config!
+  end
+  
+  def reset_config!
+    @config = Jax::Configuration.new
   end
-end
-
-if defined?(APP_PATH) && Jax.application.nil?
-  require APP_PATH
 end

data/spec/bin/jax_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+
+base_dir = File.expand_path '../..', File.dirname(__FILE__)
+
+class AppFailure < RuntimeError
+end
+
+describe 'bin/jax' do
+  before :each do
+    FileUtils.rm_rf File.join(base_dir, "tmp/jax-bin")
+    FileUtils.mkdir_p File.join(base_dir, "tmp/jax-bin")
+    FileUtils.chdir File.join(base_dir, "tmp/jax-bin")
+    @args = []
+  end
+  
+  subject do
+    jax = File.join base_dir, "bin/jax"
+    result = %x[#{jax} #{@args.join(' ')} 2>&1]
+    if $?.success?
+      result
+    else
+      raise AppFailure, result
+    end
+  end
+  
+  def subject_with_rescue
+    @subject ||= subject
+  rescue AppFailure => err
+    @subject = err.message
+  end
+  
+  describe "in a rails application" do
+    before :each do
+      FileUtils.mkdir_p "script"
+      FileUtils.mkdir_p "config"
+      File.open "config/application.rb", "w" do |f|
+        f.puts "require 'rails/all'"
+        f.puts "class TmpApp < Rails::Application"
+        f.puts "  config.active_support.deprecation = :log"
+        f.puts "end"
+      end
+      File.open "config/environment.rb", "w" do |f|
+        f.puts "require File.expand_path('application', File.dirname(__FILE__))"
+        f.puts "::Rails.application.initialize!"
+      end
+      File.open "script/rails", "w" do |f|
+        f.puts "APP_PATH = File.expand_path('../../config/application',  __FILE__)"
+        f.puts "require 'rails/commands'"
+      end
+    end
+    
+    shared_examples_for 'rails app' do
+      it "should give usage" do
+        subject_with_rescue.should =~ /Usage:/
+      end
+      
+      it "should invoke `rails g jax` generator" do
+        @args.push "generate"
+        subject_with_rescue.should =~ /You can invoke the following Jax generators:/
+        subject_with_rescue.should =~ /rails generate jax:controller/
+      end
+    end
+    
+    it "should invoke plugin manager" do
+      @args.push "plugin"
+      subject.should =~ /jax plugin install/
+    end
+      
+    it "should revoke generators with destroy" do
+      @args.push "destroy", "controller", "welcome"
+      subject.should     match(/remove/)
+      subject.should_not match(/app\/views\/jax\/welcome/)
+      subject.should     match(/app\/assets\/jax\/controllers\/welcome_controller.js.coffee/)
+    end
+    
+    it_should_behave_like 'rails app'
+    
+    describe "subdirectory" do
+      before :each do
+        FileUtils.chdir "script"
+      end
+      
+      it_should_behave_like 'rails app'
+    end
+  end
+  
+  describe "in a jax application" do
+    before(:each) do
+      Jax::Generators::ApplicationGenerator.start ["test_app", "--skip-bundle"], :shell => GenSpec::Shell.new
+      FileUtils.chdir "test_app"
+    end
+    
+    shared_examples_for 'jax app' do
+      it "should give usage" do
+        subject_with_rescue.should =~ /Usage:/
+      end
+      
+      it "should invoke `jax g` generator" do
+        @args.push "generate"
+        subject_with_rescue.should =~ /You can invoke the following Jax generators:/
+        subject_with_rescue.should =~ /jax generate controller/
+      end
+    end
+    
+    it "should invoke plugin manager" do
+      @args.push "plugin"
+      subject.should =~ /jax plugin install/
+    end
+      
+    it "should revoke generators with destroy" do
+      @args.push "destroy", "controller", "welcome"
+      subject.should     match(/remove/)
+      subject.should_not match(/app\/views\/jax\/welcome/)
+      subject.should     match(/app\/assets\/jax\/controllers\/welcome_controller.js.coffee/)
+    end
+    
+    it_should_behave_like 'jax app'
+    
+    describe "subdirectory" do
+      before :each do
+        FileUtils.chdir "script"
+      end
+      
+      it_should_behave_like 'jax app'
+    end
+  end
+  
+  describe 'not in any application' do
+    describe "creating a new jax app" do
+      before :each do
+        @args << 'new' << 'testapp' << '--skip-bundle'
+      end
+      
+      it "should create a new jax application" do
+        subject.should_not =~ /Not in a Jax or Rails application\./
+        subject.should =~ /create(\e\[0m|)\s*testapp/
+      end
+    end
+    
+    it "should not invoke plugin manager" do
+      @args.push "plugin"
+      subject_with_rescue.should_not =~ /jax plugin install/
+    end
+      
+    it "should output a friendly help message" do
+      subject_with_rescue.should =~ /Not in a Jax or Rails application\./
+    end
+  end
+end