spade 0.0.8.1 → 0.1.0

data/lib/spade/bundle.rb

@@ -1,171 +0,0 @@
-# ==========================================================================
-# Project:   Spade - CommonJS Runtime
-# Copyright: ©2010 Strobe Inc. All rights reserved.
-# License:   Licened under MIT license (see LICENSE)
-# ==========================================================================
-
-module Spade
-  BOOT_PATH = File.expand_path(File.join(File.dirname(__FILE__), '..'));
-
-  module Bundle
-    class << self
-
-      def update(rootdir, opts ={})
-
-        verbose = opts[:verbose]
-        spade_path = File.join(rootdir, SPADE_DIR)
-        FileUtils.rm_r(spade_path) if File.exists? spade_path
-
-        FileUtils.mkdir_p spade_path
-        FileUtils.mkdir_p File.join(spade_path, 'packages')
-
-        FileUtils.ln_s BOOT_PATH, File.join(spade_path, 'boot')
-
-        installed = []
-
-        # Do this to get the Gem.dir right
-        env = Spade::Environment.new
-
-        # In reverse order of precedence
-        package_dirs = [File.join(env.spade_dir, 'gems')]
-        package_dirs += %w[vendor/cache vendor/packages packages].map{|p| File.join(rootdir, p.split('/')) }
-
-        for package_dir in package_dirs
-          Dir.glob(File.join(package_dir, '*')).each do |path|
-            json_file = File.join(path, 'package.json')
-            next unless File.exists?(json_file)
-
-            # How would this happen?
-            next if installed.include? path
-            installed << path
-
-            json = JSON.load File.read(json_file)
-            package_name = json['name']
-            package_version = json['version']
-
-            local = path.index(rootdir) == 0
-
-            # Use relative paths if embedded
-            old_path = if local
-              # Figure out how many levels deep the spade_path is in the project
-              levels = spade_path.sub(rootdir, '').split(File::SEPARATOR).reject{|p| p.empty? }.count + 1
-              # Build relative path
-              File.join(['..'] * levels, path.sub(rootdir, ''))
-            else
-              path
-            end
-
-            new_path = File.join(spade_path, 'packages', package_name)
-
-            FileUtils.ln_s old_path, new_path, :force => true
-
-            puts "Installing #{local ? "local" : "remote"} package #{package_name}" if verbose
-          end
-        end
-
-        File.open(File.join(rootdir, 'spade-boot.js'), 'w+') do |fp|
-          fp.write gen_spade_boot(rootdir, opts)
-        end
-        puts "Wrote spade-boot.js" if verbose
-
-
-      end
-
-      def gen_spade_boot(rootdir, opts={})
-        verbose = opts[:verbose]
-        spade_path = File.join(rootdir, SPADE_DIR, 'packages', '*')
-        known_packages = Dir.glob(spade_path).map do |path|
-          package_name = File.basename path
-          info = JSON.load File.read(File.join(path, 'package.json'))
-          info["sync"] = true
-          info["root"] = "#{SPADE_DIR}/packages/#{package_name}"
-          info["files"] = package_file_list(path)
-          info
-        end
-
-        if File.exists? File.join(rootdir, 'package.json')
-          info = JSON.load File.read(File.join(rootdir, 'package.json'))
-        else
-          info = { 
-            "name" => File.basename(rootdir), 
-            "directories" => { "lib" => "lib" } 
-          }
-        end
-
-        info["root"] = '.'
-        info["sync"] = true
-        info["files"] = package_file_list('.')
-
-        packages = resolve_dependencies(info, known_packages)
-
-%[// GENERATED: #{Time.now.to_s}
-// This file is automatically generated by spade.  To update run 
-// 'spade update'. To use this file, reference it in your HTML file.  Base 
-// sure that your base URL is to the top level directory containing all of 
-// your files.
-
-/*globals spade */
-//@ begin boot
-(function() {
-  // load spade itself
-  var script = document.createElement('script');
-  script.src = "#{SPADE_DIR}/boot/spade.js";
-  script.onload = function() {
-
-    // Register remaining packages with spade
-#{packages.map{|p| %[spade.register("#{p["name"]}", #{JSON.pretty_generate(p)});\n] } * "\n"}
-
-    // find the main module to run
-    var main = null;
-    var scripts = document.scripts || document.getElementsByTagName("script"),
-        len = scripts.length;
-    for(var idx=0;!main && idx<len;idx++) {
-      main = scripts[idx].getAttribute('data-require');
-    }
-    scripts = null; // avoid memory leaks in IE
-
-    if (main) spade.ready(function() { spade.require(main); });
-  };
-
-  var head = document.head || document.body || document;
-  head.appendChild(script);
-
-  script = head = null; // avoid memory leaks in IE
-})();
-//@ end boot
-]
-
-      end
-
-      private
-
-        def package_file_list(path)
-          get_all_files(path).map{|p| p.sub(path+File::SEPARATOR, '') } - %w(package.json spade-boot.js)
-        end
-
-        # Supports recursive, be careful
-        def get_all_files(path)
-          Dir.glob(File.join(path, '**', '*')).
-            map{|p| File.symlink?(p) ? get_all_files(p) : p }.
-            flatten.
-            reject{|p| File.extname(p).empty? }
-        end
-
-        def resolve_dependencies(package, available)
-          # TODO: Should available be a hash to speed lookup?
-          if package["dependencies"]
-            # TODO: Check version numbers
-            dependencies = package["dependencies"].keys
-            packages = available.select{|p| dependencies.include?(p["name"]) }.
-                                 map{|p| resolve_dependencies(p, available) }.
-                                 flatten
-            (packages << package).uniq
-          else
-            [package]
-          end
-        end
-
-    end
-
-  end
-end

data/lib/spade/cli/base.rb

@@ -1,354 +0,0 @@
-module Spade::CLI
-  class Base < Thor
-    include Thor::Actions
-
-    source_root File.expand_path('../../templates', __FILE__)
-
-    desc "owner", "Manage users for a package"
-    subcommand "owner", Owner
-
-    class_option :working, :required => false,
-      :default => Spade.discover_root(Dir.pwd),
-      :aliases => ['-w'],
-      :desc    => 'Root working directory.'
-
-    class_option :verbose, :type => :boolean, :default => false,
-      :aliases => ['-V'],
-      :desc => 'Show additional debug information while running'
-
-    class_option :require, :type => :array, :required => false,
-      :aliases => ['-r'],
-      :desc => "optional JS files to require before invoking main command"
-
-    map  "-i" => "console", "--interactive" => "console"
-    desc "console", "Opens an interactive JavaScript console"
-    def console
-      require 'readline'
-
-      shell = Spade::Shell.new
-      context(:with => shell) do |ctx|
-        shell.ctx = ctx
-        puts "help() for help. quit() to quit."
-        puts "Spade #{Spade::VERSION} (V8 #{V8::VERSION})"
-        puts "WORKING=#{options[:working]}" if options[:verbose]
-
-        trap("SIGINT") { puts "^C" }
-        repl ctx
-      end
-    end
-
-    map  "-e" => "exec"
-    desc "exec [FILENAME]", "Executes filename or stdin"
-    def exec(*)
-      exec_args = ARGV.dup
-      arg = exec_args.shift while arg != "exec" && !exec_args.empty?
-
-      filename = exec_args.shift
-      puts "Filename: #{filename}" if options[:verbose]
-
-      if filename
-        puts "Working: #{options[:working]}" if options[:verbose]
-        filename = File.expand_path filename, Dir.pwd
-        throw "#{filename} not found" unless File.exists?(filename)
-        fp      = File.open filename
-        source  = File.basename filename
-        rootdir = Spade.discover_root filename
-
-        caller_id = nil
-        if rootdir
-          json_path = File.join(rootdir, 'package.json')
-          if File.exist?(json_path)
-            package_json = JSON.parse(File.read(json_path))
-            caller_id = "#{package_json['name']}/main"
-          end
-        end
-
-        # peek at first line.  If it is poundhash, skip. else rewind file
-        unless fp.readline =~ /^\#\!/
-          fp.rewind
-        end
-
-        # Can't set pos on STDIN so we can only do this for files
-        if options[:verbose]
-          pos = fp.pos
-          puts fp.read
-          fp.pos = pos
-        end
-      else
-        fp = $stdin
-        source = '<stdin>'
-        rootdir = options[:working]
-        caller_id = nil
-      end
-
-      if options[:verbose]
-        puts "source: #{source}"
-        puts "rootdir: #{rootdir}"
-        puts "caller_id: #{caller_id}"
-      end
-
-      begin
-        # allow for poundhash
-        context(:argv => exec_args, :rootdir => rootdir, :caller_id => caller_id) do |ctx|
-          ctx.eval(fp, source) # eval the rest
-        end
-      rescue Interrupt => e
-        puts; exit
-      end
-    end
-
-    map  "server" => "preview"
-    desc "preview", "Starts a preview server for testing"
-    long_desc %[
-      The preview command starts a simple file server that can be used to
-      load JavaScript-based apps in the browser.  This is a convenient way to
-      run apps in the browser instead of having to setup Apache on your
-      local machine.  If you are already loading apps through your own web
-      server (for ex using Rails) the preview server is not required.
-    ]
-    method_option :port, :type => :string, :default => '4020',
-      :aliases => ['-p'],
-      :desc => 'Port number'
-    def preview
-      require 'spade/server'
-      trap("SIGINT") { Spade::Server.shutdown }
-      Spade::Server.run(options[:working], options[:port]);
-    end
-
-    desc "update", "Update package info in the current project"
-    def update
-      Spade::Bundle.update(options[:working], :verbose => options[:verbose])
-    end
-
-    desc "install [PACKAGE]", "Installs one or many spade packages"
-    method_option :version,    :type => :string,  :default => ">= 0", :aliases => ['-v'],    :desc => 'Specify a version to install'
-    method_option :prerelease, :type => :boolean, :default => false,  :aliases => ['--pre'], :desc => 'Install a prerelease version'
-    def install(*packages)
-      report_arity_error("install") and return if packages.size.zero?
-
-      begin
-        packages.each do |package|
-          installed = Spade::Remote.new.install(package, options[:version], options[:prerelease])
-          installed.each do |spec|
-            say "Successfully installed #{spec.full_name}"
-          end
-        end
-      rescue Gem::InstallError => e
-        abort "Install error: #{e}"
-      rescue Gem::GemNotFoundException => e
-        abort "Can't find package #{e.name} #{e.version} available for install"
-      rescue Errno::EACCES, Gem::FilePermissionError => e
-        abort e.message
-      end
-    end
-
-    desc "installed [PACKAGE]", "Shows what spade packages are installed"
-    def installed(*packages)
-      local = Spade::Local.new
-      index = local.installed(packages)
-      print_specs(packages, index)
-    end
-
-    desc "uninstall [PACKAGE]", "Uninstalls one or many packages"
-    def uninstall(*packages)
-      local = Spade::Local.new
-      if packages.size > 0
-        packages.each do |package|
-          if !local.uninstall(package)
-            abort %{No packages installed named "#{package}"}
-          end
-        end
-      else
-        report_arity_error('uninstall')
-      end
-    end
-
-    desc "login", "Log in with your Spade credentials"
-    def login
-      highline = HighLine.new
-      say "Enter your Spade credentials."
-
-      begin
-        email = highline.ask "\nEmail:" do |q|
-          next unless STDIN.tty?
-          q.readline = true
-        end
-
-        password = highline.ask "\nPassword:" do |q|
-          next unless STDIN.tty?
-          q.echo = "*"
-        end
-      rescue Interrupt => ex
-        abort "Cancelled login."
-      end
-
-      say "\nLogging in as #{email}..."
-
-      if Spade::Remote.new.login(email, password)
-        say "Logged in!"
-      else
-        say "Incorrect email or password."
-        login
-      end
-    end
-
-    desc "push", "Distribute your spade package"
-    def push(package)
-      remote = Spade::Remote.new
-      if remote.logged_in?
-        say remote.push(package)
-      else
-        say LOGIN_MESSAGE
-      end
-    end
-
-    desc "yank", "Remove a specific package version release from SproutCutter"
-    method_option :version, :type => :string,  :default => nil,   :aliases => ['-v'],    :desc => 'Specify a version to yank'
-    method_option :undo,    :type => :boolean, :default => false,                        :desc => 'Unyank package'
-    def yank(package)
-      if options[:version]
-        remote = Spade::Remote.new
-        if remote.logged_in?
-          if options[:undo]
-            say remote.unyank(package, options[:version])
-          else
-            say remote.yank(package, options[:version])
-          end
-        else
-          say LOGIN_MESSAGE
-        end
-      else
-        say "Version required"
-      end
-    end
-
-    desc "list", "View available packages for download"
-    method_option :all,        :type => :boolean, :default => false, :aliases => ['-a'],    :desc => 'List all versions available'
-    method_option :prerelease, :type => :boolean, :default => false, :aliases => ['--pre'], :desc => 'List prerelease versions available'
-    def list(*packages)
-      remote = Spade::Remote.new
-      index  = remote.list_packages(packages, options[:all], options[:prerelease])
-      print_specs(packages, index)
-    end
-
-    desc "new [NAME]", "Generate a new project skeleton"
-    def new(name)
-      ProjectGenerator.new(self,
-        name, File.expand_path(name)).run
-    end
-
-    desc "build", "Build a spade package from a package.json"
-    def build
-      local = Spade::Local.new
-      if local.logged_in?
-        package = local.pack("package.json")
-        if package.errors.empty?
-          puts "Successfully built package: #{package.to_ext}"
-        else
-          failure_message = "Spade encountered the following problems building your package:"
-          package.errors.each do |error|
-            failure_message << "\n* #{error}"
-          end
-          abort failure_message
-        end
-      else
-        abort LOGIN_MESSAGE
-      end
-    end
-
-    desc "unpack [PACKAGE]", "Extract files from a spade package"
-    method_option :target, :type => :string, :default => ".", :aliases => ['-t'], :desc => 'Unpack to given directory'
-    def unpack(*paths)
-      local = Spade::Local.new
-
-      paths.each do |path|
-        begin
-          package     = local.unpack(path, options[:target])
-          unpack_path = File.expand_path(File.join(Dir.pwd, options[:target], package.to_full_name))
-          puts "Unpacked spade into: #{unpack_path}"
-        rescue Errno::EACCES, Gem::FilePermissionError => ex
-          abort "There was a problem unpacking #{path}:\n#{ex.message}"
-        end
-      end
-    end
-
-    private
-
-    def report_arity_error(name)
-      self.class.handle_argument_error(self.class.tasks[name], nil)
-    end
-
-    def repl(ctx)
-      ctx.reactor.next_tick do
-        line = Readline.readline("spade> ", true)
-        begin
-          result = ctx.eval(line, '<console>')
-          puts result unless result.nil?
-        rescue V8::JSError => e
-          puts e.message
-          puts e.backtrace(:javascript)
-        rescue StandardError => e
-          puts e
-          puts e.backtrace.join("\n")
-        end
-        repl(ctx)
-      end
-    end
-
-    # Loads a JS file into the context.  This is not a require; just load
-    def load(cxt, libfile)
-      begin
-        content = File.readlines(libfile)
-        content.shift if content.first && (content.first =~ /^\#\!/)
-        cxt.eval(content*'')
-        #cxt.load(libfile)
-      rescue V8::JSError => e
-        puts e.message
-        puts e.backtrace(:javascript)
-      rescue StandardError => e
-        puts e
-      end
-    end
-
-    # Initialize a context to work against.  This will load also handle 
-    # autorequires
-    def context(opts={})
-      opts[:rootdir] ||= options[:working]
-      opts[:verbose] = options[:verbose]
-      Spade::MainContext.new(opts) do |ctx|
-
-        requires = opts[:require]
-        requires.each { |r| load(ctx, r) } if requires
-
-        yield(ctx) if block_given?
-      end
-    end
-
-    def print_specs(packages, index)
-      spades = {}
-
-      index.each do |(name, version, platform)|
-        spades[name] ||= []
-        spades[name] << version
-      end
-
-      if spades.size.zero?
-        abort %{No packages found matching "#{packages.join('", "')}".}
-      else
-        spades.each do |name, versions|
-          puts "#{name} (#{versions.sort.reverse.join(", ")})"
-        end
-      end
-    end
-
-    def method_missing(meth, *)
-      if File.exist?(meth.to_s)
-        ARGV.unshift("exec")
-        invoke :exec
-      else
-        super
-      end
-    end
-
-  end
-end