nimbu 0.1

data/lib/nimbu/command/init.rb

@@ -0,0 +1,38 @@
+require "nimbu/command/base"
+require 'term/ansicolor'
+
+# authentication (login, logout)
+#
+class Nimbu::Command::Init < Nimbu::Command::Base
+  include Term::ANSIColor
+
+  # index
+  #
+  # log in with your nimbu credentials
+  #
+  def index
+    if Nimbu::Auth.read_configuration
+      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
+
+      display "Configuration ready: #{config}"
+      config = Nimbu::Auth.get_credentials
+
+      display "Initializing directories:"
+      display " - layouts"
+      FileUtils.mkdir_p(File.join(Dir.pwd,'layouts'))
+      display " - templates"
+      FileUtils.mkdir_p(File.join(Dir.pwd,'templates'))
+      display " - stylesheets"
+      FileUtils.mkdir_p(File.join(Dir.pwd,'stylesheets'))
+      display " - javascripts"
+      FileUtils.mkdir_p(File.join(Dir.pwd,'javascripts'))
+      display " - images"
+      FileUtils.mkdir_p(File.join(Dir.pwd,'images'))
+      print green(bold("Done. Happy coding!\n"))
+    end
+  end
+end
+

data/lib/nimbu/command/server.rb

@@ -0,0 +1,22 @@
+require "nimbu/command/base"
+require "nimbu/server/base"
+require 'term/ansicolor'
+
+# running a local server to speed up designing Nimbu themes
+#
+class Nimbu::Command::Server < Nimbu::Command::Base
+  include Term::ANSIColor
+  # server
+  #
+  # list available commands or display help for a specific command
+  #
+  def index
+    # Check if config file is present?
+    if !Nimbu::Auth.read_configuration
+      print red(bold("WARNING")), ": this directory does not seem to contain any Nimbu theme. \n ==> Run \"", bold { "nimbu init ."}, "\" to initialize a new Nimbu project."
+    else
+      puts "Starting the server..."
+      Nimbu::Server::Base.run!
+    end
+  end
+end

data/lib/nimbu/command/themes.rb

@@ -0,0 +1,86 @@
+require "nimbu/command/base"
+
+# working with themes (upload / download)
+#
+class Nimbu::Command::Themes < Nimbu::Command::Base
+
+  # server
+  #
+  # list available commands or display help for a specific command
+  #
+  def index
+    themes = json_decode(nimbu.list_themes)
+    if themes.any?
+      puts "You have following themes for this website:"
+      themes.each do |theme|
+        puts " - #{theme['theme']['name']} (#{theme['theme']['id']})"
+      end
+    else
+      puts "Hm. You seem to have no themes. Is that normal?"
+    end
+    puts ""
+    puts "Currently this directory is configured for '#{Nimbu::Auth.theme}'"
+  end
+
+  # list
+  #
+  # list all layouts, templates and assets
+  #
+  def list
+    input = args.shift.downcase rescue nil
+    if !input.to_s.strip.empty?
+      theme = input.to_s.strip
+    else
+      theme = Nimbu::Auth.theme
+    end
+    display "Showing layouts, templates and assets for '#{theme}':"
+    contents = json_decode(nimbu.show_theme_contents(theme))
+    contents["layouts"].each do |l|
+      display " - layouts/#{l["name"]}"
+    end unless contents["layouts"].nil?
+    contents["templates"].each do |t|
+      display " - templates/#{t["name"]}"
+    end unless contents["templates"].nil?
+    contents["assets"].each do |a|
+      display " - #{a["folder"]}/#{a["name"]}"
+    end unless contents["assets"].nil?
+  end
+
+  # download
+  #
+  # download all layouts, templates and assets
+  #
+  def download
+    input = args.shift.downcase rescue nil
+    if !input.to_s.strip.empty?
+      theme = input.to_s.strip
+    else
+      theme = Nimbu::Auth.theme
+    end
+    display "Downloading layouts, templates and assets for '#{theme}':"
+    contents = json_decode(nimbu.show_theme_contents(theme))
+    contents["layouts"].each do |asset|
+      print " - layouts/#{asset["name"]}"
+      data = json_decode(nimbu.fetch_theme_layout(theme,asset["id"]))
+      filename = File.join(Dir.pwd,"layouts",asset["name"])
+      FileUtils.mkdir_p(File.dirname(filename))
+      File.open(filename, 'w') do |file| 
+        file.puts(data["code"])
+      end
+
+      print " (ok)\n"
+    end
+
+    contents["templates"].each do |asset|
+      print " - templates/#{asset["name"]}"
+      data = json_decode(nimbu.fetch_theme_template(theme,asset["id"]))
+      filename = File.join(Dir.pwd,"templates",asset["name"])
+      FileUtils.mkdir_p(File.dirname(filename))
+      File.open(filename, 'w') do |file| 
+        file.puts(data["code"])
+      end
+
+      print " (ok)\n"
+    end
+  end
+end

data/lib/nimbu/helpers.rb

@@ -0,0 +1,382 @@
+require "vendor/nimbu/okjson"
+
+module Nimbu
+  module Helpers
+    def home_directory
+      running_on_windows? ? ENV['USERPROFILE'].gsub("\\","/") : ENV['HOME']
+    end
+
+    def running_on_windows?
+      RUBY_PLATFORM =~ /mswin32|mingw32/
+    end
+
+    def running_on_a_mac?
+      RUBY_PLATFORM =~ /-darwin\d/
+    end
+
+    def display(msg="", new_line=true)
+      if new_line
+        puts(msg)
+      else
+        print(msg)
+        STDOUT.flush
+      end
+    end
+
+    def redisplay(line, line_break = false)
+      display("\r\e[0K#{line}", line_break)
+    end
+
+    def deprecate(version)
+      display "!!! DEPRECATION WARNING: This command will be removed in version #{version}"
+      display
+    end
+
+    def error(msg)
+      STDERR.puts(format_with_bang(msg))
+      exit 1
+    end
+
+    def confirm_billing
+      display
+      display "This action will cause your account to be billed at the end of the month"
+      display "For more information, see http://devcenter.nimbu.com/articles/billing"
+      display "Are you sure you want to do this? (y/n) ", false
+      if ask.downcase == 'y'
+        nimbu.confirm_billing
+        return true
+      end
+    end
+
+    def confirm(message="Are you sure you wish to continue? (y/n)?")
+      display("#{message} ", false)
+      ask.downcase == 'y'
+    end
+
+    def confirm_command(app_to_confirm = app, message=nil)
+      raise(Nimbu::Command::CommandFailed, "No app specified.\nRun this command from app folder or set it adding --app <app name>") unless app_to_confirm
+
+      if respond_to?(:extract_option) && confirmed_app = extract_option('--confirm', false)
+        unless confirmed_app == app_to_confirm
+          raise(Nimbu::Command::CommandFailed, "Confirmed app #{confirmed_app} did not match the selected app #{app_to_confirm}.")
+        end
+        return true
+      else
+        display
+        message ||= "WARNING: Potentially Destructive Action\nThis command will affect the app: #{app_to_confirm}"
+        message << "\nTo proceed, type \"#{app_to_confirm}\" or re-run this command with --confirm #{app_to_confirm}"
+        output_with_bang(message)
+        display
+        display "> ", false
+        if ask.downcase != app_to_confirm
+          output_with_bang "Input did not match #{app_to_confirm}. Aborted."
+          false
+        else
+          true
+        end
+      end
+    end
+
+    def format_date(date)
+      date = Time.parse(date) if date.is_a?(String)
+      date.strftime("%Y-%m-%d %H:%M %Z")
+    end
+
+    def ask
+      STDIN.gets.strip
+    end
+
+    def shell(cmd)
+      FileUtils.cd(Dir.pwd) {|d| return `#{cmd}`}
+    end
+
+    def run_command(command, args=[])
+      Nimbu::Command.run(command, args)
+    end
+
+    def retry_on_exception(*exceptions)
+      retry_count = 0
+      begin
+        yield
+      rescue *exceptions => ex
+        raise ex if retry_count >= 3
+        sleep 3
+        retry_count += 1
+        retry
+      end
+    end
+
+    def has_git?
+      %x{ git --version }
+      $?.success?
+    end
+
+    def git(args)
+      return "" unless has_git?
+      flattened_args = [args].flatten.compact.join(" ")
+      %x{ git #{flattened_args} 2>&1 }.strip
+    end
+
+    def time_ago(elapsed)
+      if elapsed < 60
+        "#{elapsed.floor}s ago"
+      elsif elapsed < (60 * 60)
+        "#{(elapsed / 60).floor}m ago"
+      else
+        "#{(elapsed / 60 / 60).floor}h ago"
+      end
+    end
+
+    def truncate(text, length)
+      if text.size > length
+        text[0, length - 2] + '..'
+      else
+        text
+      end
+    end
+
+    @@kb = 1024
+    @@mb = 1024 * @@kb
+    @@gb = 1024 * @@mb
+    def format_bytes(amount)
+      amount = amount.to_i
+      return '(empty)' if amount == 0
+      return amount if amount < @@kb
+      return "#{(amount / @@kb).round}k" if amount < @@mb
+      return "#{(amount / @@mb).round}M" if amount < @@gb
+      return "#{(amount / @@gb).round}G"
+    end
+
+    def quantify(string, num)
+      "%d %s" % [ num, num.to_i == 1 ? string : "#{string}s" ]
+    end
+
+    def create_git_remote(remote, url)
+      return unless has_git?
+      return if git('remote').split("\n").include?(remote)
+      return unless File.exists?(".git")
+      git "remote add #{remote} #{url}"
+      display "Git remote #{remote} added"
+    end
+
+    def longest(items)
+      items.map { |i| i.to_s.length }.sort.last
+    end
+
+    def display_table(objects, columns, headers)
+      lengths = []
+      columns.each_with_index do |column, index|
+        header = headers[index]
+        lengths << longest([header].concat(objects.map { |o| o[column].to_s }))
+      end
+      display_row headers, lengths
+      display_row lengths.map { |length| "-" * length }, lengths
+      objects.each do |row|
+        display_row columns.map { |column| row[column] }, lengths
+      end
+    end
+
+    def display_row(row, lengths)
+      row.zip(lengths).each do |column, length|
+        format = column.is_a?(Fixnum) ? "%#{length}s  " : "%-#{length}s  "
+        display format % column, false
+      end
+      display
+    end
+
+    def json_encode(object)
+      Nimbu::OkJson.encode(object)
+    rescue Nimbu::OkJson::ParserError
+      nil
+    end
+
+    def json_decode(json)
+      Nimbu::OkJson.decode(json)
+    rescue Nimbu::OkJson::ParserError
+      nil
+    end
+
+    def set_buffer(enable)
+      with_tty do
+        if enable
+          `stty icanon echo`
+        else
+          `stty -icanon -echo`
+        end
+      end
+    end
+
+    def with_tty(&block)
+      return unless $stdin.tty?
+      begin
+        yield
+      rescue
+        # fails on windows
+      end
+    end
+
+    def get_terminal_environment
+      { "TERM" => ENV["TERM"], "COLUMNS" => `tput cols`, "LINES" => `tput lines` }
+    rescue
+      { "TERM" => ENV["TERM"] }
+    end
+
+    def fail(message)
+      raise Nimbu::Command::CommandFailed, message
+    end
+
+    ## DISPLAY HELPERS
+
+    def action(message)
+      output_with_arrow("#{message}... ", false)
+      Nimbu::Helpers.enable_error_capture
+      yield
+      Nimbu::Helpers.disable_error_capture
+      display "done", false
+      display(", #{@status}", false) if @status
+      display
+    end
+
+    def status(message)
+      @status = message
+    end
+
+    def output(message="", new_line=true)
+      return if message.to_s.strip == ""
+      display("      " + message.split("\n").join("\n      "), new_line)
+    end
+
+    def output_with_arrow(message="", new_line=true)
+      return if message.to_s.strip == ""
+      display("----> " + message.split("\n").join("\n      "), new_line)
+    end
+
+    def format_with_bang(message)
+      return '' if message.to_s.strip == ""
+      " !    " + message.split("\n").join("\n !    ")
+    end
+
+    def output_with_bang(message="", new_line=true)
+      return if message.to_s.strip == ""
+      display(format_with_bang(message), new_line)
+    end
+
+    def error_with_failure(message)
+      display "failed"
+      output_with_bang(message)
+      exit 1
+    end
+
+    def self.included_into
+      @@included_into ||= []
+    end
+
+    def self.extended_into
+      @@extended_into ||= []
+    end
+
+    def self.included(base)
+      included_into << base
+    end
+
+    def self.extended(base)
+      extended_into << base
+    end
+
+    def self.enable_error_capture
+      included_into.each do |base|
+        base.send(:alias_method, :error_without_failure, :error)
+        base.send(:alias_method, :error, :error_with_failure)
+      end
+      extended_into.each do |base|
+        class << base
+          alias_method :error_without_failure, :error
+          alias_method :error, :error_with_failure
+        end
+      end
+    end
+
+    def self.disable_error_capture
+      included_into.each do |base|
+        base.send(:alias_method, :error, :error_without_failure)
+      end
+      extended_into.each do |base|
+        class << base
+          alias_method :error, :error_without_failure
+        end
+      end
+    end
+
+
+    def display_header(message="", new_line=true)
+      return if message.to_s.strip == ""
+      display("=== " + message.to_s.split("\n").join("\n=== "), new_line)
+    end
+
+    def display_object(object)
+      case object
+      when Array
+        # list of objects
+        object.each do |item|
+          display_object(item)
+        end
+      when Hash
+        # if all values are arrays, it is a list with headers
+        # otherwise it is a single header with pairs of data
+        if object.values.all? {|value| value.is_a?(Array)}
+          object.keys.sort_by {|key| key.to_s}.each do |key|
+            display_header(key)
+            display_object(object[key])
+            hputs
+          end
+        end
+      else
+        hputs(object.to_s)
+      end
+    end
+
+    def hputs(string='')
+      Kernel.puts(string)
+    end
+
+    def hprint(string='')
+      Kernel.print(string)
+      STDOUT.flush
+    end
+
+    def string_distance(first, last)
+      distances = [] # 0x0s
+      0.upto(first.length) do |index|
+        distances << [index] + [0] * last.length
+      end
+      distances[0] = 0.upto(last.length).to_a
+      1.upto(last.length) do |last_index|
+        1.upto(first.length) do |first_index|
+          first_char = first[first_index - 1, 1]
+          last_char = last[last_index - 1, 1]
+          if first_char == last_char
+            distances[first_index][last_index] = distances[first_index - 1][last_index - 1] # noop
+          else
+            distances[first_index][last_index] = [
+              distances[first_index - 1][last_index],     # deletion
+              distances[first_index][last_index - 1],     # insertion
+              distances[first_index - 1][last_index - 1]  # substitution
+            ].min + 1 # cost
+            if first_index > 1 && last_index > 1
+              first_previous_char = first[first_index - 2, 1]
+              last_previous_char = last[last_index - 2, 1]
+              if first_char == last_previous_char && first_previous_char == last_char
+                distances[first_index][last_index] = [
+                  distances[first_index][last_index],
+                  distances[first_index - 2][last_index - 2] + 1 # transposition
+                ].min
+              end
+            end
+          end
+        end
+      end
+      distances[first.length][last.length]
+    end
+
+  end
+end