nimbu 0.4 → 0.5.1

data/lib/nimbu/command/auth.rb

@@ -4,13 +4,31 @@ require "nimbu/command/base"
 #
 class Nimbu::Command::Auth < Nimbu::Command::Base
 
+  # auth
+  #
+  # Authenticate, display token and current user
+  def index
+    Nimbu::Command::Help.new.send(:help_for_command, current_command)
+  end
+
   # auth:login
   #
   # log in with your nimbu credentials
   #
+  #Example:
+  #
+  # $ nimbu auth:login
+  #
+  # Please enter your Nimbu credentials:
+  #
+  # Login: email@example.com (or your Nimbu username)
+  # Password (typing will be hidden)
+  #
+  # Authentication successful.
+  #
   def login
     Nimbu::Auth.login
-    display "Authentication successful."
+    display " => Authentication successful."
   end
 
   alias_command "login", "auth:login"
@@ -21,7 +39,7 @@ class Nimbu::Command::Auth < Nimbu::Command::Base
   #
   def logout
     Nimbu::Auth.logout
-    display "Local credentials cleared."
+    display "=> Local credentials cleared."
   end
 
   alias_command "logout", "auth:logout"
@@ -31,7 +49,7 @@ class Nimbu::Command::Auth < Nimbu::Command::Base
   # display your api token
   #
   def token
-    display Nimbu::Auth.api_key
+    display "=> Your personal API token is: #{Nimbu::Auth.token}"
   end
 
 end

data/lib/nimbu/command/base.rb

@@ -1,6 +1,5 @@
 require "fileutils"
 require "nimbu/auth"
-require "nimbu/client/rendezvous"
 require "nimbu/command"
 
 class Nimbu::Command::Base
@@ -16,28 +15,8 @@ class Nimbu::Command::Base
   def initialize(args=[], options={})
     @args = args
     @options = options
-
-    Nimbu.debug = args.include?("--debug")
-    Nimbu.development = args.include?("--development") || args.include?("--dev")
-    Nimbu.v2 = args.include?("--v2")
-  end
-
-  def app
-    @app ||= if options[:app].is_a?(String)
-      if confirm_mismatch?
-        raise Nimbu::Command::CommandFailed, "Mismatch between --app and --confirm"
-      end
-      options[:app]
-    elsif options[:confirm].is_a?(String)
-      options[:confirm]
-    elsif app_from_dir = extract_app_in_dir(Dir.pwd)
-      app_from_dir
-    else
-      raise Nimbu::Command::CommandFailed, "No app specified.\nRun this command from an app folder or specify which app to use with --app <app name>"
-    end
   end
 
-
   def nimbu
     Nimbu::Auth.client
   end
@@ -45,14 +24,14 @@ class Nimbu::Command::Base
 protected
 
   def self.inherited(klass)
-    return if klass == Nimbu::Command::Base
+    unless klass == Nimbu::Command::Base
+      help = extract_help_from_caller(caller.first)
 
-    help = extract_help_from_caller(caller.first)
-
-    Nimbu::Command.register_namespace(
-      :name => klass.namespace,
-      :description => help.split("\n").first
-    )
+      Nimbu::Command.register_namespace(
+        :name => klass.namespace,
+        :description => help.first
+      )
+    end
   end
 
   def self.method_added(method)
@@ -64,20 +43,17 @@ protected
     resolved_method = (method.to_s == "index") ? nil : method.to_s
     command = [ self.namespace, resolved_method ].compact.join(":")
     banner = extract_banner(help) || command
-    permute = !banner.index("*")
-    banner.gsub!("*", "")
 
     Nimbu::Command.register_command(
       :klass       => self,
       :method      => method,
       :namespace   => self.namespace,
       :command     => command,
-      :banner      => banner,
-      :help        => help,
+      :banner      => banner.strip,
+      :help        => help.join("\n"),
       :summary     => extract_summary(help),
       :description => extract_description(help),
-      :options     => extract_options(help),
-      :permute     => permute
+      :options     => extract_options(help)
     )
   end
 
@@ -91,19 +67,6 @@ protected
     app
   end
 
-  #
-  # Parse the caller format and identify the file and line number as identified
-  # in : http://www.ruby-doc.org/core/classes/Kernel.html#M001397.  This will
-  # look for a colon followed by a digit as the delimiter.  The biggest
-  # complication is windows paths, which have a color after the drive letter.
-  # This regex will match paths as anything from the beginning to a colon
-  # directly followed by a number (the line number).
-  #
-  # Examples of the caller format :
-  # * c:/Ruby192/lib/.../lib/nimbu/command/addons.rb:8:in `<module:Command>'
-  # * c:/Ruby192/lib/.../nimbu-2.0.1/lib/nimbu/command/pg.rb:96:in `<class:Pg>'
-  # * /Users/ph7/...../xray-1.1/lib/xray/thread_dump_signal_handler.rb:9
-  #
   def self.extract_help_from_caller(line)
     # pull out of the caller the information for the file path and line number
     if line =~ /^(.+?):(\d+)/
@@ -112,50 +75,46 @@ protected
     raise "unable to extract help from caller: #{line}"
   end
 
-  def self.extract_help(file, line)
+  def self.extract_help(file, line_number)
     buffer = []
-    lines  = File.read(file).split("\n")
-
-    catch(:done) do
-      (line.to_i-2).downto(0) do |i|
-        case lines[i].strip[0..0]
-          when "", "#" then buffer << lines[i]
-          else throw(:done)
-        end
+    lines = Nimbu::Command.files[file]
+
+    (line_number.to_i-2).downto(0) do |i|
+      line = lines[i]
+      case line[0..0]
+        when ""
+        when "#"
+          buffer.unshift(line[1..-1])
+        else
+          break
       end
     end
 
-    buffer.map! do |line|
-      line.strip.gsub(/^#/, "")
-    end
-
-    buffer.reverse.join("\n").strip
+    buffer
   end
 
   def self.extract_banner(help)
-    help.split("\n").first
+    help.first
   end
 
   def self.extract_summary(help)
-    extract_description(help).split("\n").first
+    extract_description(help).split("\n")[2].to_s.split("\n").first
   end
 
   def self.extract_description(help)
-    lines = help.split("\n").map { |l| l.strip }
-    lines.shift
-    lines.reject do |line|
-      line =~ /^-(.+)#(.+)/
-    end.join("\n").strip
+    help.reject do |line|
+      line =~ /^\s+-(.+)#(.+)/
+    end.join("\n")
   end
 
   def self.extract_options(help)
-    help.split("\n").map { |l| l.strip }.select do |line|
-      line =~ /^-(.+)#(.+)/
-    end.inject({}) do |hash, line|
-      description = line.split("#", 2).last.strip
-      long  = line.match(/--([A-Za-z\- ]+)/)[1].strip
-      short = line.match(/-([A-Za-z ])/)[1].strip
-      hash.update(long.split(" ").first => { :desc => description, :short => short, :long => long })
+    help.select do |line|
+      line =~ /^\s+-(.+)#(.+)/
+    end.inject([]) do |options, line|
+      args = line.split('#', 2).first
+      args = args.split(/,\s*/).map {|arg| arg.strip}.sort.reverse
+      name = args.last.split(' ', 2).first[2..-1]
+      options << { :name => name, :args => args }
     end
   end
 
@@ -170,6 +129,10 @@ protected
     options[:confirm] && (options[:confirm] != options[:app])
   end
 
+  def current_command
+    Nimbu::Command.current_command
+  end
+
   def extract_app_in_dir(dir)
     return unless remotes = git_remotes(dir)
 

data/lib/nimbu/command/browse.rb

@@ -0,0 +1,63 @@
+require "nimbu/command/base"
+
+# open the current site in your browser (simulator, admin)
+#
+class Nimbu::Command::Browse < Nimbu::Command::Base
+  # index
+  #
+  # open the current site in your browser
+  #
+  def index
+    cmd = browse_command(args) do
+      dest = args.shift
+      dest = nil if dest == '--'
+
+      if dest
+        #site = nimbu browser dest
+      else
+        # $ nimbu browse
+        site = Nimbu::Auth.site
+      end
+
+      abort "Usage: nimbu browse <SITE>" unless site
+      "https://#{site}.#{Nimbu::Auth.admin_host}"
+    end
+    exec(cmd)
+  end
+
+  # index
+  #
+  # open the simulator for your current site
+  #
+  def simulator
+    cmd = browse_command(args) do
+      "http://localhost:4567"
+    end
+    exec(cmd)
+  end
+
+  # index
+  #
+  # open the admin area for your current site
+  #
+  def admin
+    cmd = browse_command(args) do
+      "https://#{Nimbu::Auth.site}.#{Nimbu::Auth.admin_host}/admin"
+    end
+    exec(cmd)
+  end
+
+  protected
+
+  def browse_command(args)
+    url_only = args.delete('-u')
+    url = yield
+
+    exec_args = []
+    exec_args.push(url_only ? 'echo' : browser_launcher)
+    exec_args.push url
+    exec_args.join(" ")
+  end
+
+end
+

data/lib/nimbu/command/help.rb

@@ -4,7 +4,7 @@ require "nimbu/command/base"
 #
 class Nimbu::Command::Help < Nimbu::Command::Base
 
-  PRIMARY_NAMESPACES = %w( auth server themes )
+  PRIMARY_NAMESPACES = %w( auth server themes sites init browse )
 
   # help [COMMAND]
   #

data/lib/nimbu/command/helpers.rb

@@ -261,10 +261,12 @@ module Nimbu
       display(format_with_bang(message), new_line)
     end
 
-    def error_with_failure(message)
-      display "failed"
-      output_with_bang(message)
-      exit 1
+    def self.error_with_failure
+      @@error_with_failure ||= false
+    end
+
+    def self.error_with_failure=(new_error_with_failure)
+      @@error_with_failure = new_error_with_failure
     end
 
     def self.included_into

data/lib/nimbu/command/init.rb

@@ -1,24 +1,23 @@
 require "nimbu/command/base"
 require 'term/ansicolor'
 
-# authentication (login, logout)
+# working directory initialization
 #
 class Nimbu::Command::Init < Nimbu::Command::Base
   include Term::ANSIColor
 
   # index
   #
-  # log in with your nimbu credentials
+  # initialize your working directory to code a selected theme
   #
   def index
     if Nimbu::Auth.read_configuration && Nimbu::Auth.read_credentials
       print green(bold("CONGRATULATIONS!")), ": this directory is already configured as a Nimbu theme."
     else
-      display "Initialize the Nimbu configuration file."
-      config = Nimbu::Auth.get_configuration
+      credentials = Nimbu::Auth.get_credentials
 
-      display "Configuration ready: #{config}"
-      config = Nimbu::Auth.get_credentials
+      display "Initializing the Nimbu configuration file."
+      config = Nimbu::Auth.get_configuration
 
       display "Initializing directories:"
       display " - layouts"

data/lib/nimbu/command/server.rb

@@ -1,8 +1,6 @@
 require "nimbu/command/base"
 require "nimbu/server/base"
 require 'term/ansicolor'
-require 'compass'
-require 'compass/exec'
 require 'thin'
 
 # running a local server to speed up designing Nimbu themes
@@ -11,124 +9,190 @@ class Nimbu::Command::Server < Nimbu::Command::Base
   include Term::ANSIColor
   # server
   #
-  # list available commands or display help for a specific command
+  # starts a local development server, using the data from the Nimbu cloud in real time.
+  #
+  # -p PORT, --port PORT      # set the port on which to start the http server
+  # -h,  --haml           # start local HAML watcher
+  # -c,  --compass        # start local Compass watcher
+  # -d,  --debug          # enable debugging output
   #
   def index
     # Check if config file is present?
     if !Nimbu::Auth.read_configuration || !Nimbu::Auth.read_credentials
       print red(bold("ERROR")), ": this directory does not seem to contain any Nimbu theme or your credentials are not set. \n ==> Run \"", bold { "nimbu init"}, "\" to initialize this directory."
     else
-      no_haml = args.include?("--no-haml")
-      no_compass = args.include?("--no-compass")
+      no_compilation = true #! options[:'no-compile']
+      with_haml = options[:haml]
+      with_compass = options[:compass]
 
-      if !(File.exists?(File.join(Dir.pwd,'haml')) && File.directory?(File.join(Dir.pwd,'haml')))
-          no_haml = true
-          puts red("\n !! WARNING: no ./haml directory detected => starting without HAML support !!")
+      if with_compass
+        require 'compass'
+        require 'compass/exec'
       end
 
-      puts white("\nStarting up Nimbu Server" + (no_compass ? "" : " + Compass Watcher") + (no_haml ? "" : " + HAML Compiler") + "...")
-      puts green(
-            "\n             _   ___            __         \n" +
-            "            / | / (_)____ ___  / /_  __  __\n" +
-            "           /  |/ / // __ `__ \\/ __ \\/ / / /\n" +
-            "          / /|  / // / / / / / /_/ / /_/ / \n" +
-            "         /_/ |_/_//_/ /_/ /_/_.___/\\__,_/  \n")
+      if with_haml
+        require 'haml'
+      end
 
-      puts green("\nConnnected to '#{Nimbu::Auth.host}', using '#{Nimbu::Auth.theme}' theme.\n")
+      services = []
+      services << "HAML" if with_haml
+      services << "Compass" if with_compass
+      title = "Starting up Nimbu Server"
+      title << "(with local #{services.join(' and ')} watcher)" if with_compass || with_haml
+      title << "..."
+      puts white("\n#{title}")
+      puts green(nimbu_header)
+      puts green("\nConnnected to '#{Nimbu::Auth.site}.#{Nimbu::Auth.admin_host}', using '#{Nimbu::Auth.theme}' theme#{Nimbu.debug ? ' (in debug mode)'.red : nil}.\n")
 
-      rd1, wr1 = IO::pipe
-      rd2, wr2 = IO::pipe
-      rd3, wr3 = IO::pipe
+      server_read, server_write = IO::pipe
+      haml_read, haml_write = IO::pipe
+      compass_read, compass_write = IO::pipe
+      compiler_read, compiler_write = IO::pipe
 
       server_pid = Process.fork do
-        $stdout.reopen(wr1)
-        rd1.close
-        puts "Starting..."
-        options = {
-          :Port               => 4567,
+        $stdout.reopen(server_write)
+        server_read.close
+        puts "Starting server..."
+        server_options = {
+          :Port               => options[:port] || 4567,
           :DocumentRoot       => Dir.pwd
         }
-        Rack::Handler::Thin.run Nimbu::Server::Base, options  do |server|
+        Rack::Handler::Thin.run Nimbu::Server::Base, server_options  do |server|
           [:INT, :TERM].each { |sig| trap(sig) { server.respond_to?(:stop!) ? server.stop! : server.stop } }
         end
       end
 
+      # assets_pid = Process.fork do
+      #   $stdout.reopen(compiler_write)
+      #   compiler_read.close
+      #   puts "Starting watcher..."
+      #   HamlWatcher.watch
+      # end unless no_compilation
+
       haml_pid = Process.fork do
-        $stdout.reopen(wr2)
-        rd2.close
+        $stdout.reopen(haml_write)
+        haml_read.close
         puts "Starting..."
-        HamlWatcher.watch
-      end unless no_haml
+        haml_listener = HamlWatcher.watch
+        [:INT, :TERM].each do |sig|
+          Signal.trap(sig) do
+            puts green("== Stopping HAML watcher\n")
+            haml_listener.stop
+            puts haml_listener
+          end
+        end
+        Process.waitall
+      end if with_haml
 
       compass_pid = Process.fork do
-        $stdout.reopen(wr3)
-        rd3.close
+        $stdout.reopen(compass_write)
+        compass_read.close
         puts "Starting..."
         Compass::Exec::SubCommandUI.new(["watch","."]).run!
-      end unless no_compass
-
+      end if with_compass
 
       watch_server_pid = Process.fork do
         trap('INT') { exit }
-        wr1.close
-        rd1.each do |line|  
+        server_write.close
+        server_read.each do |line|
           print cyan("SERVER:  ") + white(line) + ""
         end
       end
+
+      # watch_assets_pid = Process.fork do
+      #   trap('INT') { exit }
+      #   compiler_write.close
+      #   compiler_read.each do |line|
+      #     print magenta("ASSETS:    ") + white(line) + ""
+      #   end
+      # end unless no_compilation
+
       watch_haml_pid = Process.fork do
         trap('INT') { exit }
-        wr2.close
-        rd2.each do |line|  
+        haml_write.close
+        haml_read.each do |line|
           print magenta("HAML:    ") + white(line) + ""
         end
-      end unless no_haml
+      end if with_haml
 
       watch_compass_pid = Process.fork do
         trap('INT') { exit }
-        wr3.close
-        rd3.each do |line|  
+        compass_write.close
+        compass_read.each do |line|
           print yellow("COMPASS: ") + white(line) + ""
         end
-      end unless no_compass
+      end if with_compass
 
-      [:INT, :TERM].each do |sig| 
+      [:INT, :TERM].each do |sig|
         trap(sig) do
           puts yellow("\n== Waiting for all processes to finish...")
+          Process.kill('INT', haml_pid) if haml_pid && running?(haml_pid)
           Process.waitall
           puts green("== Nimbu has ended its work " + bold("(crowd applauds!)\n"))
         end
       end
 
-      Process.waitall      
+      Process.waitall
+    end
+  end
+
+  protected
+
+  def nimbu_header
+    h = ""
+    h << "\n             o8o                     .o8"
+    h << "\n             `\"'                    \"888"
+    h << "\nooo. .oo.   oooo  ooo. .oo.  .oo.    888oooo.  oooo  oooo"
+    h << "\n`888P\"Y88b  `888  `888P\"Y88bP\"Y88b   d88' `88b `888  `888"
+    h << "\n 888   888   888   888   888   888   888   888  888   888"
+    h << "\n 888   888   888   888   888   888   888   888  888   888"
+    h << "\no888o o888o o888o o888o o888o o888o  `Y8bod8P'  `V88V\"V8P'"
+  end
+
+  def running?(pid)
+    begin
+      Process.getpgid( pid )
+      true
+    rescue Errno::ESRCH
+      false
     end
   end
 end
 
 require 'rubygems'
-require 'fssm'
+require 'listen'
 require 'haml'
 
 class HamlWatcher
   class << self
     include Term::ANSIColor
-    
+
     def watch
       refresh
       puts ">>> Haml is polling for changes. Press Ctrl-C to Stop."
-      FSSM.monitor('haml', '**/*.haml') do
-        update do |base, relative|
+      listener = Listen.to('haml')
+      listener.relative_paths(true)
+      listener.filter(/\.haml$/)
+      modifier = lambda do |modified, added, removed|
+        puts modified.inspect
+        modified.each do |relative|
           puts ">>> Change detected to: #{relative}"
           HamlWatcher.compile(relative)
-        end
-        create do |base, relative|
+        end if modified
+
+        added.each do |relative|
           puts ">>> File created: #{relative}"
           HamlWatcher.compile(relative)
-        end
-        delete do |base, relative|
+        end if added
+
+        removed.each do |relative|
           puts ">>> File deleted: #{relative}"
           HamlWatcher.remove(relative)
-        end
+        end if removed
       end
+      listener.change(&modifier)
+      listener.start(false)
+      listener
     end
 
     def output_file(filename)
@@ -153,7 +217,7 @@ class HamlWatcher
         puts "\033[0;#{color}m#{action}\033[0m #{output_file_name}"
         FileUtils.mkdir_p(File.dirname(output_file_name))
         File.open(output_file_name,'w') {|f| f.write(result)}
-      rescue Exception => e 
+      rescue Exception => e
         print red("#{plainError e, file}\n")
         output_file_name = output_file(file)
         result = goHere(e, file)
@@ -194,7 +258,7 @@ class HamlWatcher
       return (exception.message.scan(/:(\d+)/).first || ["??"]).first if exception.is_a?(::SyntaxError)
       (exception.backtrace[0].scan(/:(\d+)/).first || ["??"]).first
     end
-    
+
     def plainError(message, nameoffile)
       @plainMessage = ""
       @plainMessage += "Error: #{message} \n"
@@ -202,7 +266,7 @@ class HamlWatcher
       @plainMessage += "File error detected: #{nameoffile}"
       return @plainMessage
     end
-    
+
     def sassErrorLine message
       return message
     end