jax 0.0.0.1

data/lib/jax/generators/model/USAGE

@@ -0,0 +1,5 @@
+Usage:
+  jax generate model NAME
+
+Generates a new model, a test file, and a default resource file for it.
+

data/lib/jax/generators/model/model_generator.rb

@@ -0,0 +1,42 @@
+require 'active_support/core_ext'
+
+module Jax
+  module Generators
+    module Model
+      class ModelGenerator < Jax::Generators::Command
+        include Thor::Actions
+        argument :model_name
+
+        def self.source_root
+          File.expand_path("templates", File.dirname(__FILE__))
+        end
+        
+        def source
+          template 'model.js.tt', File.join("app/models", "#{file_name}.js")
+        end
+        
+        def test
+          template 'test.js.tt', File.join('spec/javascripts/models', "#{file_name}_spec.js")
+        end
+        
+        def resources
+#          empty_directory File.join("app", "resources", plural_name)
+          create_file File.join("app", "resources", plural_name, "default.yml"), "# default attribute values\n# (these will apply to all #{plural_name})"
+        end
+        
+        protected
+        def file_name
+          model_name.underscore
+        end
+        
+        def class_name
+          model_name.camelize
+        end
+        
+        def plural_name
+          model_name.pluralize
+        end
+      end
+    end
+  end
+end

data/lib/jax/generators/model/templates/model.js.tt

@@ -0,0 +1,11 @@
+/**
+ * class <%=class_name%> < Jax.Model
+ * 
+ **/
+var <%=class_name%> = (function() {
+  return Jax.Model.create({
+    after_initialize: function() {
+      
+    }
+  });
+})();

data/lib/jax/generators/model/templates/test.js.tt

@@ -0,0 +1,11 @@
+describe("<%=class_name%>", function() {
+  var model;
+  
+  beforeEach(function() {
+    model = new <%=class_name%>();
+  });
+
+  it("does something", function() {
+    expect(1).toEqual(1);
+  });
+});

data/lib/jax/generators/script_jax_loader.rb

@@ -0,0 +1,32 @@
+require 'pathname'
+
+module Jax
+  module Generators
+    # Shamelessly lifted from Ruby on Rails
+    module ScriptJaxLoader
+      RUBY = File.join(*RbConfig::CONFIG.values_at("bindir", "ruby_install_name")) + RbConfig::CONFIG["EXEEXT"]
+      SCRIPT_JAX = File.join('script', 'jax')
+  
+      def self.exec_script_jax!
+        cwd = Dir.pwd
+        return unless in_jax_application? || in_jax_application_subdirectory?
+        exec RUBY, SCRIPT_JAX, *ARGV if in_jax_application?
+        Dir.chdir("..") do
+          # Recurse in a chdir block: if the search fails we want to be sure
+          # the application is generated in the original working directory.
+          exec_script_jax! unless cwd == Dir.pwd
+        end
+      rescue SystemCallError
+        # could not chdir, no problem just return
+      end
+  
+      def self.in_jax_application?
+        File.exists?(SCRIPT_JAX)
+      end
+  
+      def self.in_jax_application_subdirectory?(path = Pathname.new(Dir.pwd))
+        File.exists?(File.join(path, SCRIPT_JAX)) || !path.root? && in_jax_application_subdirectory?(path.parent)
+      end
+    end
+  end
+end

data/lib/jax/monkeypatch/jasmine.rb

@@ -0,0 +1,3 @@
+require 'jasmine'
+require File.expand_path("jasmine/server", File.dirname(__FILE__))
+require File.expand_path("jasmine/config", File.dirname(__FILE__))

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

@@ -0,0 +1,21 @@
+module Jasmine
+  class Config
+    # 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) }
+      else
+        []
+      end
+    end
+    
+    # new, used by overridden 'server.rb' so that we can map /public to root
+    def root_dir
+      if simple_config['root_dir']
+        File.join project_root, simple_config['root_dir']
+      else
+        project_root
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module Jasmine
+  class RunAdapter
+    alias _run run
+    # overridden method so that we can use a custom html file
+    #noinspection RubyUnusedLocalVariable
+    def run(focused_suite = nil)
+      # regenerate volatile files
+      Rake::Task['compile'].execute if $JAX_DEVELOPMENT             # rebuild jax itself if we're in gem development
+      Rake::Task['jax:generate_files'].execute if !$JAX_RAKE        # rebuild the project resources, routes, etc
+      
+      custom_file = Jax.root && Jax.root.join("spec/javascripts/support/spec_layout.html.erb")
+      return _run(focused_suite) if !custom_file || !File.file?(custom_file)
+      
+      jasmine_files = @jasmine_files
+      css_files = @jasmine_stylesheets + (@config.css_files || [])
+      js_files = @config.js_files(focused_suite)
+      body = ERB.new(File.read(custom_file)).result(binding)
+      [
+        200,
+        { 'Content-Type' => 'text/html' },
+        [body]
+      ]
+    end
+  end
+  
+  # overridden so that we can map source files separately from /public
+  def self.app(config)
+    Rack::Builder.app do
+      use Rack::Head
+      
+      map("/run.html")  { run Jasmine::Redirect.new('/') }
+      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.root_path) { run Rack::File.new(config.project_root) }
+      
+      map '/' do
+        run Rack::Cascade.new([
+          Rack::URLMap.new(
+            '/' => Rack::File.new(config.root_dir),
+            '/__src__' => Rack::File.new(config.src_dir)
+          ),
+        
+          Jasmine::RunAdapter.new(config)
+        ])
+      end
+    end
+  end
+end

data/lib/jax/packager.rb

@@ -0,0 +1,58 @@
+require 'sprockets'
+
+class Jax::Packager
+  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
+      puts "Build complete! Package is available at: "
+      puts "    #{package.pkg_path}"
+      puts
+    end
+  end
+  
+  def build!
+    @secretary.preprocessor.require(project)
+    
+    mkdir_p File.dirname(@path)
+    @secretary.concatenation.save_to @path
+    
+    file = File.open(@path, "a")
+    Jax.application.shaders.each { |shader| shader.save_to file }
+    Jax::ResourceCompiler.new.save(file)
+    Jax.application.routes.compile(file)
+    
+    file.close
+    
+    @secretary.install_assets
+  end
+  
+  def initialize(pkg_path)
+    @pkg_path = pkg_path
+    @manifest = []
+    
+    @path = File.join(@pkg_path, "javascripts/#{Jax.application.class.name.underscore}.js")
+    @secretary = Sprockets::Secretary.new(
+            :root => Jax.root,
+            :asset_root => @pkg_path.to_s,
+            :load_path => [Jax.root.to_s],
+            :source_files => []
+    )
+    @project = Jax::Packager::SprocketsTemplate.new(@secretary.environment)
+  end
+  
+  private
+  def localized_path(fi)
+    fi.gsub(/^#{Regexp::escape Jax.root.to_s}[\/\\]?/, '')
+  end
+end

data/lib/jax/packager/sprockets_template.rb

@@ -0,0 +1,49 @@
+class Jax::Packager::SprocketsTemplate < Sprockets::SourceFile
+  def initialize(environment)
+    pathname = environment.pathname_from(File.join(Jax.root, "template.js"))
+    super(environment, pathname)
+  end
+  
+  def template
+    @template ||= begin
+      template = [
+        'Jax.environment = Jax.PRODUCTION;',
+        '',
+        '//= provide "public/"',
+        ''
+      ]
+      Dir[Jax.root.join("app/**/*.js")].each do |jsfi|
+        if File.file?(jsfi)
+          relative_path = jsfi.sub(/^#{Regexp::escape Jax.root.to_s}[\/\\]?/, '')
+          template << "//= require \"#{relative_path}\""
+        end
+      end
+      template
+    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?
+    @lines ||= begin
+      lines = []
+      comments = []
+      
+      template.each_with_index do |line, lineno|
+        lines << line = Sprockets::SourceLine.new(self, line, lineno+1)
+        if line.begins_pdoc_comment? || comments.any?
+          comments << line
+        end
+        
+        if line.ends_multiline_comment?
+          if line.ends_pdoc_comment?
+            comments.each { |l| l.comment! }
+          end
+          comments.clear
+        end
+      end
+
+      lines
+    end
+  end
+end

data/lib/jax/resource_compiler.rb

@@ -0,0 +1,50 @@
+class Jax::ResourceCompiler
+  def save(destination_file)
+    resources = gather_resources
+
+    if destination_file.kind_of?(IO)
+      save_resources destination_file, resources
+    else
+      mkdir_p File.dirname(destination_file)
+      File.open destination_file, "w" do |f|
+        save_resources f, resources
+      end
+    end
+  end
+  
+  private
+  def save_resources(io, resources)
+    resources.each do |model_name, instances|
+      io.puts "#{model_name.camelize}.addResources(#{instances.to_json});"
+    end
+  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)) || {}
+
+      resources[model_name] ||= {}
+      resources[model_name].merge!({ resource_id => hash })
+      resources
+    end
+  end
+  
+  # Camelizes the keys in this hash, except the first character,
+  # following the JavaScript variable naming conventions.
+  #
+  # If the camelized key already exists, no change is made.
+  def camelize_keys(hash)
+    hash.keys.each do |key|
+      camelized = key.gsub(/[_\-](.)/) { |m| $~[1].upcase }
+      unless hash.key?(camelized)
+        value = hash[camelized] = hash.delete(key)
+        if value.kind_of?(Hash)
+          camelize_keys(value)
+        end
+      end
+    end
+    hash
+  end
+end

data/lib/jax/routes.rb

@@ -0,0 +1,61 @@
+require 'active_support/core_ext'
+
+module Jax
+  class Routes
+    def map(*args, &block)
+      if block_given?
+        instance_eval &block
+      else
+        if !args.empty?
+          @map ||= []
+          case args.length
+            when 1 then args.push(args[0], "index")
+            when 2 then args.push("index")
+            when 3 then ;
+            else raise ArgumentError, "expected #map(path, controller_name[, action_name]), got #{args.inspect}"
+          end
+          @map << args
+        end
+      end
+      @map
+    end
+    
+    def compile(outfile)
+      if root
+        outfile.puts "Jax.routes.root(#{controller_name_for(root[0])}, #{root[1].inspect});"
+      end
+      map && map.each do |set|
+        path = set[0]
+        args = set[2..-1].collect { |s| s.inspect }.join(",")
+        
+        outfile.puts "Jax.routes.map(#{path.inspect}, #{controller_name_for(set[1])}, #{args});"
+      end
+    end
+    
+    def root(controller = nil, action = 'index')
+      if controller
+        @root = [controller, action]
+      end
+      @root
+    end
+    
+    def reload!
+      load File.join(Jax.root, "config/routes.rb")
+    end
+    
+    private
+    def controller_name_for(str)
+      ctrlr = str.to_s.camelize
+      ctrlr.sub! /^(.*)?::.*$/, '\1'
+      ctrlr = "#{ctrlr}Controller" unless ctrlr['Controller']
+      ctrlr
+    end
+    
+    class << self
+      def load!
+        @loaded = true
+        require File.join(Jax.root, "config/routes.rb")
+      end
+    end
+  end
+end

data/lib/jax/shader.rb

@@ -0,0 +1,158 @@
+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 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
+    end
+  end
+  
+  class << self
+    def from(path)
+      raise ArgumentError, "Expected path to be a directory" unless File.directory? path
+      new(path)
+    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
+    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]
+      macro_name = "dependency_#{filename}".underscore.gsub(/[^a-zA-Z0-9_]/, '_')
+      <<-end_code
+      #ifndef #{macro_name}
+      #define #{macro_name}
+      
+      #{File.read(File.join(path, "#{filename}.ejs"))}
+      #endif
+      end_code
+    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"
+      end
+    end
+    result += "exports: #{export_keys_as_js},\n"
+    result += "name: #{name.inspect}"
+    result += "}"
+    
+    result
+  end
+end