jax 1.0.1 → 1.1.0.rc1

data/lib/jax/generators/light_source/light_source_generator.rb

@@ -3,8 +3,7 @@ require 'active_support/core_ext'
 module Jax
   module Generators
     module LightSource
-      class LightSourceGenerator < Jax::Generators::Command
-        include Thor::Actions
+      class LightSourceGenerator < Jax::Generators::PluggableCommand
         argument :name, :desc => "The name of this light source", :banner => "[name]"
         argument :type, :default => "point", :desc => "The light type: one of 'point', 'spot', 'directional'",
                 :banner => "[point|spot|directional]"

data/lib/jax/generators/material/material_generator.rb

@@ -3,8 +3,7 @@ require 'active_support/core_ext'
 module Jax
   module Generators
     module Material
-      class MaterialGenerator < Jax::Generators::Command
-        include Thor::Actions
+      class MaterialGenerator < Jax::Generators::PluggableCommand
         argument :name, :desc => "The name of this material", :banner => "[name]"
         class_option :append, :default => false, :type => :boolean
         

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

@@ -3,8 +3,7 @@ require 'active_support/core_ext'
 module Jax
   module Generators
     module Model
-      class ModelGenerator < Jax::Generators::Command
-        include Thor::Actions
+      class ModelGenerator < Jax::Generators::PluggableCommand
         argument :model_name
 
         def self.source_root
@@ -20,7 +19,6 @@ module Jax
         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
         

data/lib/jax/generators/packager/package_generator.rb

@@ -0,0 +1,32 @@
+require 'active_support/core_ext'
+
+module Jax
+  module Generators
+    module Packager
+      class PackageGenerator < Thor::Group
+        include Thor::Actions
+
+        def self.source_root
+          File.expand_path("templates", File.dirname(__FILE__))
+        end
+
+        def build_package
+          pkg_dir = Jax.root.join("pkg")
+          remove_dir pkg_dir, :verbose => false
+
+          package = Jax::Packager.new pkg_dir
+          say "Packaging according to the following template:"
+          say ""
+          package.project.template.each { |line| say line }
+
+          package.build!
+
+          say
+          say_status :done, "Build complete! Package is available at: ", :green
+          say_status "",    "  #{package.pkg_path}"
+          say
+        end
+      end
+    end
+  end
+end

data/lib/jax/generators/plugin/USAGE

@@ -0,0 +1,4 @@
+Usage:
+  jax generate plugin NAME
+
+Generates a new plugin with the specified name.

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

@@ -0,0 +1,113 @@
+module Jax
+  module Generators
+    module Plugin
+      class ResponseError < StandardError
+        def initialize(message)
+          super("#{message} Make sure your firewall isn't injecting invalid responses.")
+        end
+      end
+      
+      def rest_resource(name, accept = :xml)
+        url = Jax.plugin_repository_url
+        url.concat "/" unless url =~ /\/$/
+        url.concat name
+        RestClient::Resource.new(url, :accept => accept)
+      end
+      
+      def search_query_rx(query)
+        /^#{Regexp::escape query}/i
+      end
+      
+      def search(plugin_list, query)
+        plugin_list.select { |plugin, path_to_plugin|
+          !query || plugin =~ search_query_rx(query)
+        }.inject({}) do |hash, (plugin, path_to_plugin)|
+          hash[plugin] = path_to_plugin
+          hash
+        end
+      end
+      
+      def installed_plugins
+        plugins = []
+        Dir.glob(Jax.root.join("vendor/plugins/*").to_s).each do |path|
+          if File.directory? path
+            plugins.push [File.basename(path), Pathname.new(path)]
+          end
+        end
+        plugins.sort { |a, b| a[0] <=> b[0] }
+      end
+      
+      def load_or_infer_manifest(name, plugin_dir)
+        if File.file?(manifest_path = File.join(plugin_dir, "manifest.yml"))
+          YAML::load(File.read(manifest_path)) || { 'name' => name, 'description' => '(Description unavailable)' }
+        else
+          { 'name' => name, 'description' => '(Manifest file not found!)' }
+        end
+      end
+      
+      def installed_plugin_manifests(filter_name = nil)
+        { 'jax_plugins' => search(installed_plugins, filter_name).collect do |name, path|
+            load_or_infer_manifest(name, path)
+          end
+        }
+      end
+      
+      def matching_plugins(name = nil)
+        if options[:local]
+          hash = installed_plugin_manifests(name)
+        else
+          hash = get_remote_plugins_matching name
+        end
+        
+        find_plugin_list(hash)
+      end
+      
+      def find_plugin_list(hash_containing_plugin_list)
+        hash_containing_plugin_list['jax_plugins'] ||
+        hash_containing_plugin_list['nil_classes'] ||
+        raise(ResponseError.new("Fatal: couldn't find plugin list."))
+      end
+      
+      def get_remote_plugins_matching(name = nil)
+        plugins = rest_resource("plugins")
+        if name
+          extract_hash_from_response plugins['search'][name].get
+        else
+          extract_hash_from_response plugins.get
+        end
+      end
+      
+      def each_plugin(name = nil, &block)
+        matching_plugins(name).each &block
+      end
+      
+      def plugin_version(details)
+        if options['version']
+          for release in details['releases']
+            if release['version'] && release['version'] == options['version']
+              return options['version']
+            end
+          end
+          raise "Release information for version #{options['version']} not found for plugin '#{details['name']}'!"
+        else
+          if release = details['releases'].last and release['version']
+            return release['version']
+          end
+          raise "Release information not found for plugin '#{details['name']}'!"
+        end
+      end
+      
+      def extract_hash_from_response(response)
+        begin
+          hash = Hash.from_xml(response)
+        rescue
+          raise ResponseError.new("Fatal: response couldn't be parsed. (Maybe it wasn't valid XML?)")
+        end
+      end
+    end
+  end
+end
+
+require File.join(File.dirname(__FILE__), "credentials")
+require File.join(File.dirname(__FILE__), "plugin_generator")
+require File.join(File.dirname(__FILE__), "plugin_manager")

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

@@ -0,0 +1,108 @@
+require 'rest_client'
+
+class Jax::Generators::Plugin::Credentials
+  attr_reader :home, :out, :in
+  
+  def api_key
+    @api_key ||= find_api_key
+  end
+  
+  def initialize(options = {})
+    @home = home_path(options)
+    @out = options[:out] || $stdout || STDOUT
+    @in = options[:in] || $stdin || STDIN
+  end
+  
+  def config_file
+    File.join(home, ".jax")
+  end
+  
+  def home_path(options = {})
+    File.expand_path(options[:home] || Thor::Util.user_home)
+  end
+  
+  def plugins
+    @plugins ||= RestClient::Resource.new(File.join(Jax.application.plugin_repository_url, "plugins"), :accept => :xml)
+  end
+
+  def authors
+    @authors ||= RestClient::Resource.new(File.join(Jax.application.plugin_repository_url, "authors"), :accept => :xml)
+  end
+  
+  def profile
+    @profile ||= RestClient::Resource.new(File.join(Jax.application.plugin_repository_url, "profile"), :accept => :xml)
+  end
+  
+  private
+  def login
+    profile.options[:user] = email
+    profile.options[:password] = password
+    
+    begin
+      Hash.from_xml(profile.get).with_indifferent_access
+    rescue RestClient::RequestFailed => err # login doesn't exist
+      message = Hash.from_xml($!.http_body)
+      if message && (message = message['hash']) && (message = message['error']) && (message =~ /Login not found/i)
+        create_account
+      else
+        raise err
+      end
+    rescue RestClient::Unauthorized # bad password
+      raise "Invalid password."
+    end
+  end
+  
+  def email
+    @email ||= begin
+      print "Please enter your email address: "
+      gets.chomp
+    end
+  end
+  
+  def password
+    @password ||= begin
+      print "Please enter your password: "
+      gets.chomp
+    end
+  end
+  
+  def create_account
+    print "Please confirm your password: "
+    confirmation = gets.chomp
+    raise "Password and confirmation don't match" if confirmation != password
+    
+    login = email && email[/\@/] ? email[0...$~.offset(0)[0]] : email
+    Hash.from_xml(profile.post(:author => {
+      :login => login, :password => password, :password_confirmation => confirmation, :email => email
+    })).with_indifferent_access
+  rescue RestClient::RequestFailed
+    raise Hash.from_xml($!.http_body)['hash']['error']
+  end
+  
+  def puts(*a)
+    out.puts *a
+  end
+  
+  def print(*a)
+    out.print *a
+  end
+  
+  def gets(*a)
+    self.in.gets(*a).to_s
+  end
+  
+  def find_api_key
+    if File.file?(config_file)
+      yml = (YAML::load(File.read(config_file)) || {}).with_indifferent_access
+      if yml[:api_key]
+        yml[:api_key]
+      else
+        key = login[:author][:single_access_token]
+        yml[:api_key] = key
+        File.open(config_file, "w") { |f| f.print yml.to_yaml }
+        key
+      end
+    else login[:author][:single_access_token]
+    end
+  end
+end

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

@@ -0,0 +1,72 @@
+require 'active_support/core_ext'
+require 'rest_client'
+require 'jax'
+
+module Jax
+  module Generators
+    module Plugin
+      class PluginGenerator < Jax::Generators::Command
+        argument :name
+        class_option :local, :type => :boolean, :desc => "Does not connect to the plugin server for any reason",
+                     :default => false
+        include Jax::Generators::Plugin
+        include Jax::Generators::Interactions
+        
+        def check_for_remote_name_conflicts
+          return if options[:local]
+          
+          message = catch :aborted do
+            begin
+              plugins = find_plugin_list get_remote_plugins_matching(name)
+              if plugins.length == 1 && (plugin = plugins.shift)['name'].downcase == name.downcase
+                say "A plugin named '#{name}' would conflict with an existing upstream plugin called '#{plugin['name']}'."
+                prompt_yn "Attempts to publish your plugin will be rejected. Are you sure you wish to proceed?"
+              end
+            rescue RestClient::Exception, Errno::ECONNREFUSED
+              say $!.message
+              say ""
+              say "An error occurred while checking for conflicting plugin names. If"
+              say "a plugin named '#{name}' already exists, you will not be able to"
+              say "publish your plugin until it is renamed."
+              prompt_yn "Do you wish to continue? "
+            end
+            nil
+          end
+          if message
+            say_status :aborted, message, :yellow
+            exit
+          end
+        end
+        
+        def check_for_local_name_conflicts
+          if File.directory? plugin_base_directory
+            message = catch(:aborted) do
+              prompt_yn("'#{name}' conflicts with another installed plugin of the same name. Overwrite?")
+              FileUtils.rm_rf plugin_base_directory
+              say_status :remove, plugin_base_directory, :green
+              nil
+            end
+            if message
+              say_status :aborted, message, :yellow
+              exit
+            end
+          end
+        end
+        
+        def create_plugin_directory
+          directory "new_plugin", plugin_base_directory
+        end
+        
+        def create_manifest
+          Jax::Plugin::Manifest.new(name).save
+          say_status :create, File.join("vendor/plugins", name, 'manifest.yml')
+        end
+        
+        private
+        def plugin_base_directory
+          Jax.root.join("vendor/plugins", name).to_s
+        end
+      end
+    end
+  end
+end

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

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