jax 1.0.1 → 1.1.0.rc1

data/lib/jax/generators/plugin/templates/new_plugin/config/routes.rb

@@ -0,0 +1,3 @@
+Jax.application.routes.map do
+
+end

data/lib/jax/generators/plugin/templates/new_plugin/init.rb

@@ -0,0 +1 @@
+# This file is executed whenever Jax loads or reloads this plugin.

data/lib/jax/generators/plugin/templates/new_plugin/install.rb

@@ -0,0 +1,2 @@
+# This file is executed immediately after installing the plugin.
+# You can delete the file if you don't need to perform any post-installation tasks.

data/lib/jax/generators/plugin/templates/new_plugin/uninstall.rb

@@ -0,0 +1,2 @@
+# This file is executed immediately before removing the plugin.
+# You can delete the file if you don't need to perform any pre-uninstallation tasks.

data/lib/jax/generators/script_jax_loader.rb

@@ -1,5 +1,21 @@
 require 'pathname'
 
+if ARGV.include? '-v' or ARGV.include? '--version'
+  require 'thor'
+  require File.expand_path("../version", File.dirname(__FILE__))
+  
+  class VersionGenerator < Thor
+    map "--version" => :version, "-v" => :version
+    desc "--version, -v", "display the Jax version number"
+    def version
+      say "Jax v#{Jax::VERSION}"
+    end
+  end
+  VersionGenerator.start(['--version'])
+  exit
+end
+
+
 module Jax
   module Generators
     # Shamelessly lifted from Ruby on Rails
@@ -9,6 +25,7 @@ module Jax
   
       def self.exec_script_jax!
         cwd = Dir.pwd
+        ENV['JAX_CWD'] ||= cwd
         return unless in_jax_application? || in_jax_application_subdirectory?
         exec RUBY, SCRIPT_JAX, *ARGV if in_jax_application?
         Dir.chdir("..") do

data/lib/jax/generators/shader/shader_generator.rb

@@ -3,8 +3,7 @@ require 'active_support/core_ext'
 module Jax
   module Generators
     module Shader
-      class ShaderGenerator < Jax::Generators::Command
-        include Thor::Actions
+      class ShaderGenerator < Jax::Generators::PluggableCommand
         argument :name, :desc => "The name of this shader", :banner => "[name]"
 
         def self.source_root
@@ -12,7 +11,7 @@ module Jax
         end
 
         def check_conflicts
-          if Jax.application.shaders.find(file_name)
+          if Jax.application.shaders.find(file_name) && behavior != :revoke
             raise ArgumentError, "A shader called '#{file_name}' already exists!"
           end
         end

data/lib/jax/monkeypatch/jasmine/config.rb

@@ -1,14 +1,38 @@
 module Jasmine
   class Config
+    def plugin_and_app_files(src_files)
+      src_files.collect do |src_file|
+        Jax.application.plugins.inject([]) { |ary, plugin| 
+          ary + [File.join(plugin.relative_path, src_file)]
+        } + [src_file]
+      end.flatten
+    end
+    
     # overridden so that we can map source files separately from /public
     def src_files
       if simple_config['src_files']
-        match_files(src_dir, simple_config['src_files']).collect { |f| File.join("__src__", f) }
+        match_files(src_dir, plugin_and_app_files(simple_config['src_files'])).collect do |f|
+          File.join("__src__", f)
+        end.uniq
       else
         []
       end
     end
     
+    def helpers
+      helpers = simple_config['helpers'] || ['helpers/**/*.js']
+      helpers.collect! { |s| File.expand_path(s, spec_dir).gsub(/^#{Regexp::escape Jax.root.to_s}\/?/, '') }
+      
+      match_files(project_root, plugin_and_app_files(helpers)).uniq
+    end
+    
+    def spec_files
+      spec_files = simple_config['spec_files'] || ['**/*[sS]pec.js']
+      spec_files.collect! { |s| File.expand_path(s, spec_dir).gsub(/^#{Regexp::escape Jax.root.to_s}\/?/, '') }
+      
+      match_files(project_root, plugin_and_app_files(spec_files)).uniq
+    end
+    
     # new, used by overridden 'server.rb' so that we can map /public to root
     def root_dir
       if simple_config['root_dir']

data/lib/jax/monkeypatch/jasmine/server.rb

@@ -32,7 +32,7 @@ module Jasmine
       map("/__suite__") { run Jasmine::FocusedSuite.new(config) }
       
       map("/__JASMINE_ROOT__") { run Rack::File.new(Jasmine.root) }
-      map(config.spec_path) { run Rack::File.new(config.spec_dir) }
+      map(config.spec_path) { run Rack::File.new(config.project_root) }
       map(config.root_path) { run Rack::File.new(config.project_root) }
       
       map '/' do

data/lib/jax/packager.rb

@@ -1,23 +1,24 @@
 require 'sprockets'
+require 'fileutils'
 
 class Jax::Packager
+  include FileUtils
   attr_reader :pkg_path, :path, :project
   autoload :SprocketsTemplate, File.join(File.dirname(__FILE__), "packager/sprockets_template")
   
   class << self
     def invoke
-      pkg_dir = Jax.root.join("pkg")
-      rm_rf pkg_dir
-      
-      package = new pkg_dir
-      puts package.project.template
-      
-      package.build!
-      
+      puts "DEPRECATED"
+      puts
+      puts "Please invoke the Jax packager with the following command:"
       puts
-      puts "Build complete! Package is available at: "
-      puts "    #{package.pkg_path}"
+      puts "  jax package"
       puts
+      puts "This notice will be removed sometime around Jax v1.2."
+      puts
+      puts
+      
+      Jax::Generators::Packager::PackageGenerator.start([])
     end
   end
   
@@ -45,7 +46,7 @@ class Jax::Packager
     @secretary = Sprockets::Secretary.new(
             :root => Jax.root,
             :asset_root => @pkg_path.to_s,
-            :load_path => [Jax.root.to_s],
+            :load_path => Jax.application.javascript_load_paths,
             :source_files => []
     )
     @project = Jax::Packager::SprocketsTemplate.new(@secretary.environment)

data/lib/jax/packager/sprockets_template.rb

@@ -10,12 +10,11 @@ class Jax::Packager::SprocketsTemplate < Sprockets::SourceFile
       template = [
         'Jax.environment = Jax.PRODUCTION;',
         '',
-        '//= provide "public/"',
+        asset_paths,
         ''
-      ]
-      # Need to verify that helpers come first
-      Dir[Jax.root.join("app/helpers/**/*.js")].each { |jsfi| try_to_add_file(template, jsfi) }
-      Dir[Jax.root.join("app/**/*.js")].each { |jsfi| try_to_add_file(template, jsfi) }
+      ].flatten
+      
+      Jax.application.javascript_sources.each { |jsfi| try_to_add_file(template, jsfi) }
 
       template
     end
@@ -29,7 +28,7 @@ class Jax::Packager::SprocketsTemplate < Sprockets::SourceFile
   
   def add_file(template, jsfi)
     relative_path = jsfi.sub(/^#{Regexp::escape Jax.root.to_s}[\/\\]?/, '')
-    template << "//= require \"#{relative_path}\""
+    template << "//= require <#{relative_path}>"
     added_files << jsfi
   end
   
@@ -41,6 +40,16 @@ class Jax::Packager::SprocketsTemplate < Sprockets::SourceFile
     @added_files ||= []
   end
   
+  def asset_paths
+    Jax.application.asset_paths.collect do |path|
+      if File.directory?(path)
+        "//= provide \"#{File.join(path, "").gsub(/^#{Regexp::escape Jax.root.to_s}\/?/, '')}\""
+      end
+    end.reject do |result|
+      result.nil?
+    end
+  end
+  
   def source_lines
     # basically the same as super but with a string instead of a file
     # TODO would templating be a worthy addition to Sprockets itself?

data/lib/jax/plugin.rb

@@ -0,0 +1,49 @@
+require 'active_support/core_ext'
+require 'rails/initializable'
+
+class Jax::Plugin < Jax::Engine
+  autoload :Manifest, 'jax/plugin/manifest'
+  
+  attr_reader :relative_path
+  
+  class << self
+    def all(list, paths)
+      plugins = []
+      paths.each do |path|
+        Dir["#{path}/*"].each do |plugin_path|
+          plugin = new(plugin_path)
+          next unless list.include?(plugin.name) || list.include?(:all)
+          plugins << plugin
+        end
+      end
+
+      plugins.sort_by do |p|
+        [list.index(p.name) || list.index(:all), p.name.to_s]
+      end
+    end
+  end
+  
+  def initialize(path)
+    super()
+    @relative_path = path.sub(/^#{Regexp::escape Jax.root.to_s}\/?/, '')
+  end
+  
+  def manifest
+    @manifest ||= begin
+      manifest = Jax::Plugin::Manifest.new(name)
+      manifest.load
+    end
+  end
+  
+  def full_path
+    File.expand_path(relative_path, Jax.root)
+  end
+  
+  def name
+    File.basename(relative_path)
+  end
+  
+  def config
+    @config ||= Jax::Engine::Configuration.new(full_path)
+  end
+end

data/lib/jax/plugin/manifest.rb

@@ -0,0 +1,71 @@
+require 'active_support/hash_with_indifferent_access'
+
+class Jax::Plugin::Manifest < ActiveSupport::HashWithIndifferentAccess
+  class << self
+    def find(name)
+      man = new name
+      man.load
+    end
+  end
+  
+  def initialize(plugin_name)
+    super()
+    self[:name] = plugin_name
+    defaults
+  end
+  
+  def name
+    self[:name]
+  end
+  
+  def name=(n)
+    self[:name] = n
+  end
+  
+  def version
+    self[:version]
+  end
+  
+  def version=(n)
+    self[:version] = n
+  end
+  
+  def description
+    self[:description]
+  end
+  
+  def description=(n)
+    self[:description] = n
+  end
+  
+  def load
+    load_from path
+  end
+  
+  def load_from(path)
+    yml = YAML::load(File.read(path))
+    yml.each do |key, value|
+      self[key] = value
+    end
+    self
+  end
+  
+  def save
+    save_to path
+  end
+  
+  def save_to(path)
+    File.open(path, "w") { |f| f.print to_yaml }
+    self
+  end
+  
+  def path
+    File.join(Jax.root, "vendor/plugins", name, "manifest.yml")
+  end
+  
+  def defaults
+    self[:description] ||= ""
+    self[:version] ||= "0.0.1"
+    self
+  end
+end

data/lib/jax/resource_compiler.rb

@@ -1,32 +1,42 @@
 class Jax::ResourceCompiler
   def save(destination_file)
-    resources = gather_resources
-
     if destination_file.kind_of?(IO)
-      save_resources destination_file, resources
+      save_resources destination_file
     else
       mkdir_p File.dirname(destination_file) unless File.exist?(File.dirname(destination_file))
       File.open destination_file, "w" do |f|
-        save_resources f, resources
+        save_resources f
       end
     end
   end
   
-  private
-  def save_resources(io, resources)
-    resources.each do |model_name, instances|
-      io.puts "#{model_name.camelize}.addResources(#{instances.to_json});"
+  def to_s
+    resources.inject("") do |result, (model_name, instances)|
+      result + "#{model_name.camelize}.addResources(#{instances.to_json});\n"
     end
   end
   
+  def resources
+    gather_resources
+  end
+  
+  private
+  def save_resources(io)
+    io.puts to_s
+  end
+  
   def gather_resources
-    Dir[Jax.root.join("app/resources/**/*.yml")].inject({}) do |resources, yml|
-      model_name = File.basename(File.dirname(yml)).singularize
-      resource_id = File.basename(yml).sub(/^(.*)\..*$/, '\1')
-      hash = YAML::load(File.read(yml)) || {}
+    # app.resource_files.concat config.paths.app.resources.to_a
+    
+    Jax.application.resource_paths.inject({}) do |resources, paths|
+      paths.to_a.each do |yml|
+        model_name = File.basename(File.dirname(yml)).singularize
+        resource_id = File.basename(yml).sub(/^(.*)\..*$/, '\1')
+        hash = YAML::load(File.read(yml)) || {}
 
-      resources[model_name] ||= {}
-      resources[model_name].merge!({ resource_id => hash })
+        resources[model_name] ||= {}
+        resources[model_name].merge!({ resource_id => hash })
+      end
       resources
     end
   end

data/lib/jax/routes.rb

@@ -17,6 +17,7 @@ module Jax
           @map << args
         end
       end
+      @map && @map.uniq!
       @map
     end
     

data/lib/jax/shader.rb

@@ -1,5 +1,5 @@
 class Jax::Shader
-  attr_reader :common, :fragment, :vertex
+  # attr_reader :common, :fragment, :vertex
   attr_accessor :name, :path, :exports, :manifest
   
   def initialize(path, name = File.basename(path))
@@ -10,6 +10,21 @@ class Jax::Shader
     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

data/lib/jax/tasks/rake.rb

@@ -19,7 +19,7 @@ namespace :jax do
   
   task :generate_files do
     # resources
-    Jax::ResourceCompiler.new.save(Jax.root.join 'tmp/resources.js')
+    Jax.application.resources.save(Jax.root.join 'tmp/resources.js')
     
     # routes
     File.open("tmp/shaders.js", "w") { |file| Jax.application.shaders.each { |shader| shader.save_to file } }