jax 1.1.1 → 2.0.0

data/lib/jax/generators/plugin/plugin_manager.rb

@@ -1,254 +0,0 @@
-require 'active_support/core_ext'
-require 'rest_client'
-require 'jax'
-require 'archive/tar/minitar'
-
-module Jax
-  module Generators
-    module Plugin
-      class PluginManager < Thor
-        include Thor::Actions
-        include Jax::Generators::Plugin
-        include Jax::Generators::Interactions
-        
-        desc "install NAME [NAME2...]", "Installs the named plugin from the plugin repository"
-        long_desc "Searches for a plugin by the specified name and installs it. The "   \
-                  "search is case-insensitive. If an exact match (other than case) is " \
-                  "found, the matching plugin will be installed. Otherwise, a list of " \
-                  "potential matches will be shown, and you will be prompted with a "   \
-                  "selection."
-        method_option :version, :type => :string, :default => false, :aliases => '-v',
-                      :desc => "The exact version to install. If not given, the latest will be used."
-        def install(name, *other_names)
-          catch(:complete) do
-            message = catch(:aborted) do
-              list = matching_plugins(name)
-              if list.empty?
-                raise "No plugin names match or begin with the text '#{name}'."
-              elsif list.length == 1
-                if list[0]['name'] != name
-                  prompt_yn "Plugin '#{name}' was not found, but '#{list[0]['name']}' was. Install it instead?"
-                end
-                install_plugin list[0]
-              else
-                say "No plugin was found with the name '#{name}', but the following candidates were found:"
-                menu list.collect { |c| c['name'] } do |selected_name, selected_index|
-                  install_plugin list[selected_index]
-                end
-              end
-              throw :complete
-            end
-            say_status :aborted, message, :yellow
-            return # cancel any additional plugins if this one was aborted
-          end
-          
-          install *other_names unless other_names.empty?
-        end
-        
-        desc "uninstall NAME", "Removes the named plugin from this application"
-        long_desc "Removes the plugin with the given name from this application."
-        def uninstall(name)
-          catch :complete do
-            message = catch :aborted do
-              plugin_path = Jax.root.join("vendor/plugins/#{name}")
-              if File.exist?(plugin_path.to_s)
-                uninstall_plugin name, plugin_path
-              else
-                # see if it's a partial name
-                matches = search installed_plugins, name
-                throw :aborted, "Plugin '#{name}' does not seem to be installed." if matches.empty?
-
-                if matches.length == 1 && match = matches.shift
-                  prompt_yn "Plugin '#{name}' is not installed, but '#{match[0]}' was. Delete it instead?"
-                  uninstall_plugin *match
-                else
-                  say "Plugin '#{name}' is not installed, but the following partial matches are:"
-                  menu matches.keys.sort, :allow_all => true do |name,index|
-                    uninstall_plugin name, matches[name]
-                  end
-                end
-              end
-
-              throw :complete
-            end
-            
-            say_status :aborted, message, :yellow
-          end
-        end
-        
-        desc "push", "Pushes this plugin to the repository, making it available to other people"
-        long_desc "Releases the plugin to the plugin repository. If you do not have an "   \
-                  "account, you will be prompted to create one. The name of the plugin "   \
-                  "must be unique."
-        def push
-          if ENV['JAX_CWD'] && ENV['JAX_CWD'] =~ /^#{Regexp::escape Jax.root.join("vendor/plugins").to_s}\/?([^\/]+)(\/|$)/
-            plugin_name = $1
-            plugin_dir = Jax.root.join("vendor/plugins", plugin_name)
-            manifest = plugin_dir.join("manifest.yml").to_s
-            if File.exist? manifest
-              manifest = Jax::Plugin::Manifest.find(plugin_name)
-              if manifest.description.blank?
-                say "Please enter a plugin description in the manifest.yml file"
-              else
-                publish_plugin manifest
-              end
-            else
-              say "Plugin manifest is missing!"
-              say "A default manifest file will be written. Please modify "
-              say "this file before continuing."
-              say ""
-              Jax::Plugin::Manifest.new(plugin_name).save
-              say_status :created, "manifest.yml", :green
-            end
-          else
-            say_status :aborted, "Please run this script from within a plugin directory.", :red
-          end
-        end
-        
-        desc "list [NAME]", "Lists all plugins, or searches for a plugin by the specified name"
-        long_desc "Lists all plugins, or searches for a plugin that starts with the specified name."
-        method_option :detailed, :type => :boolean, :default => false,
-                      :desc => "Lists the plugins with detailed multiline descriptions."
-        method_option :local, :type => :boolean, :default => false,
-                      :desc => "Lists only plugins that are currently installed."
-        def list(name = nil)
-          if options[:local] && matching_plugins(name).empty?
-            say_status :missing, "There do not seem to be any plugins installed for this application."
-            return
-          else
-            each_plugin(name) do |plugin|
-              name, description = plugin['name'], plugin['description']
-
-              if options[:detailed]
-                say name
-                say "  #{description}"
-                say ""
-              else
-                if description.length > 60
-                  description = description[0...57] + "..."
-                end
-                say "#{name.ljust 19} #{description}"
-              end
-            end
-          end
-          say ""
-        end
-        
-        def self.source_root
-          File.expand_path("templates", File.dirname(__FILE__))
-        end
-
-        protected
-        def publish_plugin(manifest)
-          credentials = Jax::Generators::Plugin::Credentials.new
-          api_key = credentials.api_key
-          tmp = Jax.application.config.paths.tmp.to_a.first
-          
-          file = File.join(tmp, "#{manifest.name}-#{manifest.version}.tgz")
-          FileUtils.mkdir_p File.dirname(file) unless File.directory?(File.dirname(file))
-          tar = Zlib::GzipWriter.new(File.open(file, "wb"))
-          Dir.chdir Jax.root.join("vendor/plugins", manifest.name).to_s do
-            Archive::Tar::Minitar.pack(".", tar) # closes tar
-          end
-          
-          plugin = {
-            :single_access_token => api_key,
-            :plugin => {
-              :name => manifest.name,
-              :description => manifest.description,
-              :version => manifest.version,
-              :stream => File.new(file, "r")
-            }
-          }
-          
-          begin
-            res = Hash.from_xml(credentials.plugins.post plugin).with_indifferent_access
-            if res && res[:hash] && !res[:hash][:error].blank?
-              say_status :error, res[:hash][:error], :red
-            else
-              say_status :done, "Plugin #{File.basename(file)} published", :green
-            end
-          rescue RestClient::RequestFailed
-            res = Hash.from_xml($!.http_body)
-            if error = res['hash'] && res['hash']['error']
-              say_status :error, error, :red
-            else
-              say_status :error, "A server-side error has occurred.", :red
-            end
-          end
-        end
-        
-        def uninstall_plugin(name, plugin_path)
-          run_uninstall_script plugin_path
-          FileUtils.rm_rf plugin_path
-          say_status :complete, "Plugin '#{name}' has been removed.", :green
-        end
-        
-        def install_plugin(details)
-          name, version = details['name'], plugin_version(details)
-          plugin_dir = Jax.root.join("vendor/plugins/#{name}")
-          overwrite plugin_dir
-
-          Dir.mktmpdir do |tmp|
-            tarfile = download_tgz(name, version, tmp)
-            untar tarfile, plugin_dir
-            run_install_script plugin_dir
-          end
-          
-          save_manifest plugin_dir, details unless File.exist?(File.join(plugin_dir, "manifest.yml"))
-          
-          say_status :installed, "#{plugin_dir} -v=#{version}", :green
-        end
-        
-        def save_manifest(plugin_dir, details)
-          # collect necessary details
-          details = details.inject({}) do |hash,(k,v)|
-            case k.to_s
-            when 'name', 'description', 'version' then hash[k.to_s] = v
-            when 'releases' then
-              version = v.last['version']
-              hash['version'] = version if hash['version'].blank? || hash['version'] < version
-            end
-            hash
-          end
-          
-          File.open(File.join(plugin_dir, "manifest.yml"), "w") do |f|
-            f.print details.to_yaml
-          end
-        end
-        
-        def run_uninstall_script(plugin_dir)
-          run_script plugin_dir, "uninstall.rb"
-        end
-        
-        def run_script(plugin_dir, script_filename)
-          script = File.join(plugin_dir, script_filename)
-          load script if File.exist? script
-        end
-        
-        def run_install_script(plugin_dir)
-          run_script plugin_dir, "install.rb"
-        end
-        
-        def untar(tarfile, destination)
-          tgz = Zlib::GzipReader.new(File.open(tarfile, "rb"))
-          Archive::Tar::Minitar.unpack(tgz, destination.to_s) # closes tgz
-        end
-
-        def download_tgz(name, version, destdir)
-          filename = "#{name}-#{version}.tgz"
-          tgz = rest_resource("plugins/#{name}.tgz").get(:params => { :version => version })
-          tarfile = File.join destdir, filename
-          File.open(tarfile, "wb") { |f| f.print tgz }
-          tarfile
-        end
-        
-        class << self
-          def basename
-            "jax plugin"
-          end
-        end
-      end
-    end
-  end
-end

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

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

data/lib/jax/generators/script_jax_loader.rb

@@ -1,49 +0,0 @@
-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
-    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
-        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
-          # 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/generators/shader/USAGE

@@ -1,4 +0,0 @@
-Usage:
-  jax generate shader NAME
-
-Generates a new custom shader, which can then be used in materials.

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

@@ -1,70 +0,0 @@
-require 'active_support/core_ext'
-
-module Jax
-  module Generators
-    module Shader
-      class ShaderGenerator < Jax::Generators::PluggableCommand
-        argument :name, :desc => "The name of this shader", :banner => "[name]"
-
-        def self.source_root
-          File.expand_path("templates", File.dirname(__FILE__))
-        end
-
-        def check_conflicts
-          if Jax.application.shaders.find(file_name) && behavior != :revoke
-            raise ArgumentError, "A shader called '#{file_name}' already exists!"
-          end
-        end
-             
-        def common
-          template_to 'common.ejs'
-        end
-
-        def fragment
-          template_to 'fragment.ejs'
-        end
-
-        def manifest
-          template_to 'manifest.yml'
-        end
-
-        def material
-          template_to 'material.js'
-        end
-
-        def vertex
-          template_to 'vertex.ejs'
-        end
-
-        def spec
-          template "spec.js.tt", File.join("spec/javascripts/shaders", "#{file_name}_spec.js")
-        end
-        
-        protected
-        def template_to(basename)
-          template "#{basename}.tt", path_to(basename)
-        end
-
-        def path_to(basename)
-          File.join("app/shaders", file_name, basename)
-        end
-
-        def banner
-          "jax generate shader #{self.arguments.map { |a| a.usage }.join(' ')}"
-        end
-
-        def file_name
-          name.underscore
-        end
-        
-        def class_name
-          name.camelize
-        end
-        
-        def plural_name
-          name.pluralize
-        end
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-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, 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']
-        File.join project_root, simple_config['root_dir']
-      else
-        project_root
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-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.project_root) }
-      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/monkeypatch/jasmine.rb

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

data/lib/jax/packager/sprockets_template.rb

@@ -1,77 +0,0 @@
-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
-    added_files.clear
-    @template ||= begin
-      template = [
-        'Jax.environment = Jax.PRODUCTION;',
-        '',
-        asset_paths,
-        ''
-      ].flatten
-      
-      Jax.application.javascript_sources.each { |jsfi| try_to_add_file(template, jsfi) }
-
-      template
-    end
-  end
-  
-  def try_to_add_file(template, jsfi)
-    if File.file?(jsfi) && !already_added?(jsfi)
-      add_file(template, jsfi)
-    end
-  end
-  
-  def add_file(template, jsfi)
-    relative_path = jsfi.sub(/^#{Regexp::escape Jax.root.to_s}[\/\\]?/, '')
-    template << "//= require <#{relative_path}>"
-    added_files << jsfi
-  end
-  
-  def already_added?(jsfi)
-    added_files.include?(jsfi)
-  end
-  
-  def added_files
-    @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?
-    @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/packager.rb

@@ -1,59 +0,0 @@
-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
-      puts "DEPRECATED"
-      puts
-      puts "Please invoke the Jax packager with the following command:"
-      puts
-      puts "  jax package"
-      puts
-      puts "This notice will be removed sometime around Jax v1.2."
-      puts
-      puts
-      
-      Jax::Generators::Packager::PackageGenerator.start([])
-    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.application.javascript_load_paths,
-            :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/plugin/manifest.rb

@@ -1,71 +0,0 @@
-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