jax 1.1.1 → 2.0.0

data/lib/jax/configuration.rb

@@ -0,0 +1,64 @@
+module Jax
+  class Configuration
+    attr_accessor :webgl_start
+    attr_writer   :default_plugin_repository_url
+    attr_writer   :plugin_repository_url
+
+    def default_plugin_repository_url
+      "http://plugins.jaxgl.com/"
+    end
+
+    def plugin_repository_url
+      @plugin_repository_url ||=
+        config_file[:plugin_repository_url] ||
+        ENV['JAX_PLUGIN_REPOSITORY_URL']    ||
+        default_plugin_repository_url
+
+      @plugin_repository_url.dup # so that it can't be edited in-place
+    end
+
+    def specs
+      @specs ||= begin
+        specs = Sprockets::Environment.new
+        specs.append_path ::Rails.root.join("spec/javascripts").to_s
+        specs.append_path File.expand_path("../../spec/javascripts/helpers", File.dirname(__FILE__))
+        
+        # make all assets available to specs so they can //=require them as needed
+        ::Rails.application.config.assets.paths.each do |path|
+          specs.append_path path
+        end
+        
+        specs
+      end
+    end
+    
+    def initialize
+      @webgl_start = { :controller => "jax/suite", :action => "run_webgl" }
+    end
+    
+    private
+    def config_file
+      @config_file ||= begin
+        config_file = {}.with_indifferent_access
+        config_file.merge! hash_from_config_file(File.expand_path(".jax", Thor::Util.user_home))
+        config_file.merge! hash_from_config_file(File.expand_path(".jax", ::Rails.application.root))
+        config_file
+      end
+    end
+
+    def hash_from_config_file(path)
+      if File.file? path
+        hash = YAML::load(File.read(path)) || {}
+        raise "Error: #{hash.inspect} is not a hash (read from #{path})" unless hash.kind_of?(Hash)
+        hash
+      else
+        {}
+      end
+    rescue
+      puts $!.message
+      puts path
+      puts File.read(path)
+      raise $!
+    end
+  end
+end

data/lib/jax/directive_processor.rb

@@ -0,0 +1,53 @@
+require 'sprockets'
+
+module Jax
+  class DirectiveProcessor < Sprockets::DirectiveProcessor
+    def evaluate(context, locals, &block)
+      # this is necessary because we don't *want* to handle shaders here,
+      # we want to handle them in Jax::Shader instead.
+      begin
+        path = context.resolve(context.logical_path).to_s
+        if path =~ /\.glsl$/
+          data
+        else
+          super
+        end
+      rescue Sprockets::FileNotFound # not sure why this can happen
+        super
+      end
+    end
+    
+    def depend_on_all_files_in(path)
+      context.depend_on path
+      Dir.glob(File.join path, "**/*") do |full_path|
+        context.depend_on full_path
+      end
+    end
+    
+    def process_require_everything_matching_directive(subpath)
+      # depend on any base subpath directories that may exist
+      # this should pick up any new shaders as they are added to app
+      context.environment.paths.each do |base_path|
+        path = File.join base_path, subpath
+        depend_on_all_files_in path if File.directory? path
+      end
+      
+      files = []
+      # context.environment.each_logical_path do |path|
+      context.environment.each_file do |path|
+        # skip all.js and skip manifest.yml
+        path = path.to_s
+        next if path == self.file || path =~ /\.yml$/
+        attrs = context.environment.attributes_for(path)
+        logical_path = attrs.logical_path
+        if logical_path[/^#{Regexp::escape subpath}/]
+          # skip if logical path has already been processed
+          next if files.include?(logical_path)
+          files << logical_path
+          path = context.resolve(logical_path).to_s
+          process_require_directive path
+        end
+      end
+    end
+  end
+end

data/lib/jax/engine.rb

@@ -1,64 +1,48 @@
-require 'pathname'
+require 'rails/engine'
 
-class ::Jax::Engine < ::Rails::Railtie
-  autoload :Configurable,  "jax/engine/configurable"
-  autoload :Configuration, "jax/engine/configuration"
-  
-  class << self
-    attr_accessor :called_from
+module Jax
+  class Engine < ::Rails::Engine
+    engine_name "jax"
+    isolate_namespace Jax
     
-    def inherited(base)
-      base.called_from = detect_caller unless base.abstract_railtie?
-      super
+    routes do
+      root :to => "suite#index"
+      match "/:action(/*id)", :controller => "suite"
     end
+    
+    config.before_configuration do
+      config.action_view.javascript_expansions[:jax] ||= [ 'jax', 'jax/application' ]
+    end
+    
+    initializer 'jax.engine' do |app|
+      app.config.assets.paths.unshift File.join(app.root, "app/assets/jax")
+      app.config.assets.paths.unshift File.join(app.root, "lib/assets/jax")
+      app.config.assets.paths.unshift File.join(app.root, "vendor/assets/jax")
 
-    def find_root_with_flag(flag, default=nil)
-      root_path = self.called_from
-
-      while root_path && File.directory?(root_path) && !File.exist?("#{root_path}/#{flag}")
-        parent = File.dirname(root_path)
-        root_path = parent != root_path && parent
-      end
-
-      root = File.exist?("#{root_path}/#{flag}") ? root_path : default
-      raise "Could not find root path for #{self}" unless root
+      app.assets.register_engine '.resource', Jax::ResourceFile
+      app.assets.register_engine '.glsl',     Jax::Shader
 
-      RbConfig::CONFIG['host_os'] =~ /mswin|mingw/ ?
-        Pathname.new(root).expand_path : Pathname.new(root).realpath
+      app.assets.unregister_preprocessor 'application/javascript', Sprockets::DirectiveProcessor
+      app.assets.register_preprocessor   'application/javascript', Jax::DirectiveProcessor
     end
-  end
-  
-  initializer :detect_shaders do |app|
-    app.shader_load_paths.concat config.paths.app.shaders.paths
-    app.detect_shaders config.paths.app.shaders.to_a
-  end
-  
-  initializer :asset_paths do |app|
-    app.asset_paths.concat config.paths.public.to_a
-  end
-  
-  initializer :javascript_source_roots do |app|
-    app.javascript_source_roots << config.root.to_s
-  end
-  
-  initializer :javascript_load_paths do |app|
-    config.paths.app.each do |app_path|
-      app.javascript_load_paths.push app_path
+        
+    config.to_prepare do
+      ActionController::Base.helper Jax::HelperMethods
     end
-    app.javascript_load_paths.push config.paths.lib.to_a.first
-  end
-  
-  initializer :javascript_sources do |app|
-    sources = []
-    %w(helpers models controllers views shaders).collect do |base|
-      config.paths.app.send(base).to_a.each do |path|
-        sources.concat Dir[File.join(path, "**/*.js")]
-      end
+    
+    config.to_prepare do
+      ::Rails.application.assets.each_file do |path|
+        path = path.to_s
+        if path =~ /javascripts\/shaders\/.*\.ejs$/
+          raise "Deprecated shader #{path}.\nTry renaming it to #{path.sub(/\.ejs$/, '.glsl')}."
+        elsif path =~ /resources\/.*\.yml$/
+          raise "Deprecated resource file #{path}.\nTry renaming it to #{path.sub(/\.yml$/, '.resource')}."
+        end
+      end unless @already_warned
+      
+      # only set @already_warned if no errors were raised, that way we ensure that
+      # all files are iterated over
+      @already_warned = true
     end
-    app.javascript_sources.concat sources.uniq
-  end
-  
-  initializer :resource_paths do |app|
-    app.resource_paths << config.paths.app.resources
   end
 end

data/lib/jax/helper_methods.rb

@@ -0,0 +1,3 @@
+# Contains helper methods to be included into view templates
+module Jax::HelperMethods
+end

data/lib/jax/rails/application.rb

@@ -0,0 +1,34 @@
+require 'action_controller/railtie'
+require 'sprockets/railtie'
+
+module Jax
+  module Rails
+    # Bootstraps a Rails 3 application for running the Jax dev server in
+    # a non-Rails environment. This class is not used in a Rails application.
+    class Application < ::Rails::Application
+      config.secret_token                      = "e10adc3949ba59abbe56e057f20f883e"
+      config.session_store :cookie_store, :key => "_jax_session"
+      config.active_support.deprecation        = :log
+      config.consider_all_requests_local       = true
+      config.action_controller.perform_caching = false
+      config.log_level                         = :debug
+      config.cache_classes                     = false
+      config.assets.enabled = true
+      config.assets.version = '1.0'
+      config.assets.debug = true
+      config.assets.digest = false
+      
+      # this excludes geometry/triangle/inliner.rb and all {jax,shaders}/**/manifest.yml files
+      original = config.assets.precompile[0]
+      config.assets.precompile[0] = Proc.new do |path|
+        original.call(path)                                  and
+        path !~ /(jax|shaders)[\\\/].*manifest\.yml/         and
+        path !~ /geometry[\\\/]triangle[\\\/]inliner\.rb$/
+      end
+
+      routes do
+        mount Jax::Engine => "/", :as => "jax"
+      end
+    end
+  end
+end

data/lib/jax/resource_file.rb

@@ -0,0 +1,29 @@
+require 'yaml'
+
+class Jax::ResourceFile < Tilt::Template
+  attr_reader :context
+  
+  def self.default_mime_type
+    "application/javascript"
+  end
+  
+  def prepare
+  end
+  
+  def evaluate(scope, locals, &block)
+    @context = scope
+    "#{class_name}.addResources(#{to_json});"
+  end
+  
+  def class_name
+    File.basename(File.dirname(context.logical_path)).camelize.singularize
+  end
+  
+  def resource_name
+    File.basename(context.logical_path)
+  end
+  
+  def to_json
+    { resource_name => (YAML::load(data) || {}) }.to_json
+  end
+end

data/lib/jax/script_loader.rb

@@ -0,0 +1,68 @@
+# The bin command 'jax' loads this file, and this file searches for and loads
+# either 'script/rails' or 'script/jax'. If neither are found, this isn't a
+# Rails or Jax app and it tells the user as much.
+
+module Jax
+  module ScriptLoader
+    class << self
+      def invoke!
+        @rails_or_jax = recursively_find_path("script/rails") || recursively_find_path("script/jax")
+        
+        if @rails_or_jax
+          if ARGV[0] && ARGV[0][/^(g|generate|destroy)$/]
+            if ARGV.length > 1
+              ARGV[1] = "jax:#{ARGV[1]}"
+            else
+              ARGV[1] = "jax"
+            end
+          end
+          
+          return if check_for_common_commands
+          ruby @rails_or_jax, *ARGV
+        end
+
+        if ARGV.shift == 'new'
+          require 'generators/jax/all'
+          return Jax::Generators::ApplicationGenerator.start
+        end
+        
+        friendly_help_message
+      end
+      
+      # if necessary, invoke a command common to both Rails and non-Rails apps
+      # returns true if a command was invoked
+      def check_for_common_commands
+        case ARGV[0].to_s.downcase
+          when 'plugin'
+            require File.expand_path("../config/environment", File.dirname(@rails_or_jax))
+            require 'jax'
+            Jax::PluginManager.start ARGV[1..-1]
+            true
+          else
+            false
+        end
+      end
+
+      def friendly_help_message
+        puts "Not in a Jax or Rails application."
+        puts "Try `jax new [app-name]` or `rails new [app-name]` instead."
+      end
+      
+      def recursively_find_path(relative_path, path = File.expand_path("."))
+        full_path = File.join(path, relative_path)
+        if File.file?(full_path)
+          full_path
+        else
+          new_path = File.dirname(path)
+          return false if new_path == path # root
+          recursively_find_path relative_path, new_path
+        end
+      end
+
+      def ruby(*args)
+        ruby = File.join(*RbConfig::CONFIG.values_at("bindir", "ruby_install_name")) + RbConfig::CONFIG["EXEEXT"]
+        exec [ ruby, *args ].join(" ")
+      end
+    end
+  end
+end

data/lib/jax/server.rb

@@ -0,0 +1,87 @@
+require 'rails/commands/server'
+
+module Jax
+  # The server is just a bare-bones Rails application built into the Jax gem.
+  # It mounts Jax::Engine at the root path.
+  #
+  # The server can be run from any Jax application by simply executing
+  # the `jax server` command.
+  #
+  # Note: in a Rails app, you should simply mount Jax::Engine directly in your
+  # `config/routes.rb` file:
+  #
+  #   Rails.application.routes.draw do
+  #     mount Jax::Engine => "/jax" if Rails.env != "production"
+  #   end
+  #
+  # The above example will mount the Jax development suite in development and
+  # test modes, but not in production mode. Usually, you won't want to expose
+  # Jax::Engine to a production environment, but of course this is up to you.
+  #
+  # Note that you only need to mount Jax::Engine if you want to use the development
+  # suite. You get the Jax assets (e.g. the Jax JavaScript API) for free when you
+  # add Jax to your Gemfile.
+  #
+  # Executing `jax server` in a Rails application is equivalent to executing
+  # `rails server`.
+  #
+  class Server < ::Rails::Server
+    class Options
+      def parse!(args)
+        args, options = args.dup, {}
+
+        opt_parser = OptionParser.new do |opts|
+          opts.banner = "Usage: jax server [mongrel, thin, etc] [options]"
+          opts.on("-p", "--port=port", Integer,
+                  "Runs Jax on the specified port.", "Default: 3000") { |v| options[:Port] = v }
+          opts.on("-b", "--binding=ip", String,
+                  "Binds Jax to the specified ip.", "Default: 0.0.0.0") { |v| options[:Host] = v }
+          opts.on("-c", "--config=file", String,
+                  "Use custom rackup configuration file") { |v| options[:config] = v }
+          opts.on("-d", "--daemon", "Make server run as a Daemon.") { options[:daemonize] = true }
+          opts.on("-u", "--debugger", "Enable ruby-debugging for the server.") { options[:debugger] = true }
+          opts.on("-e", "--environment=name", String,
+                  "Specifies the environment to run this server under (test/development/production).",
+                  "Default: development") { |v| options[:environment] = v }
+          opts.on("-P","--pid=pid",String,
+                  "Specifies the PID file.",
+                  "Default: tmp/pids/server.pid") { |v| options[:pid] = v }
+          opts.on('-q','--quiet',"Does not tail the log file.") { |v| options[:quiet] = true }
+
+          opts.separator ""
+
+          opts.on("-h", "--help", "Show this help message.") { puts opts; exit }
+        end
+
+        opt_parser.parse! args
+        options[:server] = args.shift
+
+        options
+      end
+    end
+        
+
+    attr_reader :args
+    
+    def opt_parser
+      Options.new
+    end
+        
+    def initialize(*args)
+      @args = args
+      super()
+    end
+    
+    def middleware
+      middlewares = []
+      middlewares << [::Rails::Rack::LogTailer, log_path] unless options[:daemonize] || options[:quiet]
+      middlewares << [::Rails::Rack::Debugger]  if options[:debugger]
+      middlewares << [::Rack::ContentLength]
+      Hash.new(middlewares)
+    end
+            
+    def options
+      @options ||= parse_options(args)
+    end
+  end
+end