salticid 0.9.0

data/lib/salticid/interface/ncurses.rb

@@ -0,0 +1,30 @@
+module Ncurses
+  # Returns size of screen [y, x]
+  def self.dimensions
+    x = Array.new
+    y = Array.new
+    Ncurses.getmaxyx(Ncurses.stdscr, y, x)
+    [y.first, x.first]
+  end
+
+  class WINDOW
+    # Adds a FormattedString
+    def add_formatted_string(string)
+      string.each do |part|
+        # Set attributes
+        part[1..-1].each {| attribute| attron attribute }
+        addstr part[0]
+        # Unset attributes
+        part[1..-1].each {| attribute| attroff attribute }
+      end
+    end
+
+    # Returns cursor y and x coordinates.
+    def cursor
+      y = Array.new
+      x = Array.new
+      getyx y, x
+      [y.first, x.first]
+    end
+  end
+end

data/lib/salticid/interface/resizable.rb

@@ -0,0 +1,28 @@
+class Salticid
+  class Interface
+    module Resizeable
+      def resize(dimensions = nil)
+        case dimensions
+        when Hash
+          # Resize self
+          @height = dimensions[:height] if dimensions[:height]
+          @width  = dimensions[:width]  if dimensions[:width]
+          @top    = dimensions[:top]    if dimensions[:top]
+          @left   = dimensions[:left]   if dimensions[:left]
+
+          if @window
+            # Resize window
+            @window.mvwin @top, @left
+            @window.resize @height, @width
+          end
+
+          true
+        else
+          # Resize parent
+          @interface.resize
+          false
+        end
+      end
+    end
+  end
+end

data/lib/salticid/interface/tab_view.rb

@@ -0,0 +1,134 @@
+class Salticid
+  class Interface
+    class TabView < View
+
+      def initialize(interface, params = {})
+        super
+
+        @tabs = []
+        @active = -1
+      end
+
+      # Gets the active tab
+      def active
+        @tabs[@active] || nil
+      end
+
+      # Sets the active tab
+      def active=(tab)
+        @active = @tabs.index tab
+        render
+      end
+
+      # Adds a tab (and switches to it by default)
+      def add(tab)
+        @tabs << tab
+        @active = @tabs.size - 1
+        render
+      end
+
+      alias :<< :add
+
+      # Deletes a tab and switches to the previous tab
+      def delete(tab)
+        @tabs.delete tab
+        previous
+      end
+
+      # Iterates over each tab
+      def each(&block)
+        @tabs.each &block
+      end
+
+      # Advances to the next tab
+      def next
+        scroll 1
+      end
+
+      # Goes to the previous tab
+      def previous
+        scroll -1
+      end
+
+      # Draws to screen
+      def render
+        return false if @tabs.empty?
+        # Divide into regions
+
+        # Ignore dividers
+        width = @width - size + 1
+        base_width = width / size
+        regions = Array.new(size, base_width)
+        
+        # Add remainder to successive tabs.
+        (width - base_width * size).times do |i|
+          regions[i] += 1
+        end
+
+        # Move to start
+        @window.move 0,0
+
+        @tabs.each_with_index do |tab, i|
+          if i > 0
+            @window.addch Ncurses::ACS_VLINE
+          end
+
+          color = Interface::COLOR_PAIRS[tab.state]
+          @window.attron color if color
+          @window.attron Ncurses::A_BOLD
+          @window.attron Ncurses::A_REVERSE if i == @active
+          @window.addstr tab.to_s.slice(0,regions[i]).center(regions[i])
+          @window.attroff Ncurses::A_REVERSE if i == @active
+          @window.attroff Ncurses::A_BOLD
+          @window.attroff color if color
+        end
+
+        @window.refresh
+      end
+
+      def resize(dimensions = nil)
+        return unless super
+
+        @tabs.each do |tab|
+          tab.resize(
+            :top => 1,
+            :left => 0,
+            :height => height - 1,
+            :width => width
+          )
+        end
+        active.render
+      end
+
+      # Moves by a number of tabs
+      def scroll(delta = 1)
+        active.hide rescue NoMethodError
+        @active = (@active + delta).modulo(@tabs.size)
+        active.show
+        render
+      end
+
+      def shutdown
+        @tabs.each do |tab|
+          tab.shutdown
+        end
+        @tabs = []
+      end
+
+      # Number of tabs
+      def size
+        @tabs.size
+      end
+
+      # Switches the active tab to the specified label
+      def switch_to_label(label)
+        if index = @tabs.map{ |tab| tab.to_s }.index(label)
+          @active = index
+          render
+        else
+          raise RuntimeError.new("no tab labeled #{label}")
+        end
+      end
+    end
+  end
+end

data/lib/salticid/interface/view.rb

@@ -0,0 +1,49 @@
+class Salticid
+  class Interface
+    class View
+      include Resizeable
+
+      attr_accessor :window, :height, :width, :top, :left
+
+      def initialize(interface, params = {})
+        @interface = interface
+        @height = params[:height] || Ncurses.LINES
+        @width = params[:width] || Ncurses.COLS
+        @top = params[:top] || 0
+        @left = params[:left] || 0
+
+        @window = Ncurses::WINDOW.new @height, @width, @top, @left
+      end
+
+      def height=(height)
+        @height = height
+        @window.resize @height, @width
+      end
+
+      def hide
+        @hidden = true
+        @window.erase
+      end
+
+      def left=(left)
+        @left = left
+        @window.mvwin @top, @left
+      end
+
+      def show
+        @hidden = false
+        render
+      end
+
+      def top=(top)
+        @top = top
+        @window.mvwin @top, @left
+      end
+
+      def width=(width)
+        @width = width
+        @window.resize @height, @width
+      end
+    end
+  end
+end

data/lib/salticid/message.rb

@@ -0,0 +1,8 @@
+class Message
+  attr_reader :severity, :text, :time
+  def initialize(*args)
+    @text = args.pop
+    @severity = args.first
+    @time = Time.now
+  end
+end

data/lib/salticid/role.rb

@@ -0,0 +1,98 @@
+class Salticid::Role
+  # A role is a list of tasks.
+  attr_reader :name, :tasks, :salticid
+
+  def initialize(name, opts = {})
+    @name = name.to_s
+    @tasks = []
+    @salticid = opts[:salticid]
+  end
+
+  # Runs the block in the context of each.
+  def each_host(&block)
+    hosts.each do |host|
+      host.instance_exec &block
+    end
+  end
+
+  # Returns an array of all hosts in this salticid which include this role.
+  def hosts
+    @salticid.hosts.select do |host|
+      host.roles.include? self
+    end
+  end
+
+  def inspect
+    "#<Role #{name} tasks=#{@tasks.inspect}>"
+  end
+
+  # Sets or gets the name of this role.
+  def name(name = nil)
+    if name
+      @name = name.to_s
+    else
+      @name
+    end
+  end
+
+  # Finds (and optionally defines) a task.
+  # 
+  # Tasks are first resolved in the role's task list, then in the Salticid's task
+  # list. Finally, tasks are created from scratch. Any invocation of task adds
+  # that task to this role.
+  # 
+  # If a block is given, the block is assigned to the local (role) task. The
+  # task is dup'ed to prevent modifying a possible global task.
+  #
+  # The task is returned at the end of the method.
+  def task(name, &block)
+    name = name.to_s
+
+    if task = @tasks.find{|t| t.name == name}
+      # Found in self
+    elsif (task = @salticid.tasks.find{|t| t.name == name}) and not block_given?
+      # Found in salticid
+      @tasks << task
+    else
+      # Create new task in self
+      task = Salticid::Task.new(name, :salticid => @salticid)
+      @tasks << task
+    end
+
+    if block_given?
+      # Remove the task from our list, and replace it with a copy.
+      # This is to prevent local declarations from clobbering global tasks.
+      i = @tasks.index(task) || @task.size
+      task = task.dup
+      task.block = block
+      @tasks[i] = task
+    end
+
+    task
+  end
+
+  def to_s
+    @name.to_s
+  end
+
+  def to_string
+    r = "Role #{@name}:\n"
+    r << "  Tasks:\n"
+    r << tasks.map { |t| "    #{t}" }.sort!.join("\n")
+    r << "\n  Hosts:\n"
+    r << hosts.map { |h| "    #{h}" }.join("\n")
+  end
+
+  # When a task name is called on a role, it is automatically run on every host
+  # associated with that role.
+  #
+  # role(:myapp).deploy => role(:myapp).each_host { |h| h.myapp.deploy }
+  def method_missing(meth, *args, &block)
+    name = meth.to_s
+    if task = @tasks.find { |t| t.name == name }
+      hosts.each do |host|
+        task.run(host, *args)
+      end
+    end
+  end
+end

data/lib/salticid/role_proxy.rb

@@ -0,0 +1,26 @@
+class RoleProxy
+  # Wraps a Role in the context of a Host: calls to the RoleProxy are passed to
+  # the Role it wraps, but called with the host as the first argument. This
+  # allows role-method chaining for nice namespaces.
+  #
+  # RoleProxy.new(host, role).some_task(*args) =>
+  #   role.some_task(host, *args)
+  #
+  # RoleProxies are created on the fly by Hosts; you shouldn't have to
+  # instantiate them directly. They're involved when you do something like:
+  #
+  # host :foo do
+  #   my_role.some_task
+  # end
+
+  undef_method(*(instance_methods.map(&:intern) - [:__id__, :__send__, :respond_to?, :object_id]))
+
+  def initialize(host, role)
+    @host = host
+    @role = role
+  end
+
+  def method_missing(meth, *args, &block)
+    @role.tasks.find{|t| t.name == meth.to_s}.run(@host, *args, &block)
+  end
+end

data/lib/salticid/task.rb

@@ -0,0 +1,49 @@
+class Salticid::Task
+  # A named block, runnable in some context
+  attr_accessor :name, :block
+
+  def initialize(name, opts = {})
+    @name = name.to_s
+  end
+
+  def ==(other)
+    self.name == other.name and
+    self.block == other.block
+  end
+
+  def dup
+    dup = Salticid::Task.new(@name)
+    dup.block = @block 
+    dup
+  end
+
+  def inspect
+    "#<Task #{@name}>"
+  end
+
+  # Sets or gets the name of this task.
+  def name(name = nil)
+    if name
+      @name = name.to_s
+    else
+      @name
+    end
+  end
+
+  # Runs the task in a given context
+  def run(context = nil, *args)
+    if context
+      context.instance_exec(*args, &@block)
+    else
+      @block.call(*args)
+    end
+  end
+
+  def to_s
+    @name.to_s
+  end
+
+  def to_string
+    "Task #{self}"
+  end
+end

data/lib/salticid/version.rb

@@ -0,0 +1,3 @@
+class Salticid
+  VERSION = "0.9.0"
+end

data/lib/snippets/init.rb

@@ -0,0 +1,5 @@
+require 'snippets/string/slash'
+require 'snippets/symbol/slash'
+require 'snippets/symbol/to_proc'
+require 'snippets/object/instance_exec'
+require 'snippets/object/__dir__'