amun 0.1.3 → 0.2.0

data/lib/amun/windows/base.rb

@@ -0,0 +1,42 @@
+require 'amun/object'
+require 'forwardable'
+require 'curses'
+
+module Amun
+  module Windows
+    # based on amun object, means it has event manager inside
+    # and respond to all event manager methods (bind, undind, trigger...etc)
+    # and has a size (Rect instance), it also expose the methods of the size
+    # to the public, it also creates a subwindow from the curses standard screen
+    # and resizes it whenever you set a new (size) value
+    class Base < Object
+      extend Forwardable
+
+      attr_reader :size
+      def_delegators :size, :top, :left, :width, :height
+
+      def initialize(size)
+        super()
+        @size = size
+        @curses_window = Curses.stdscr.subwin(height, width, top, left)
+      end
+
+      # change the object size
+      # the internal curses window will be
+      # resized and moved along with it
+      def size=(size)
+        @size = size
+        resize
+      end
+
+      private
+
+      attr_accessor :curses_window
+
+      def resize
+        curses_window.resize(height, width)
+        curses_window.move(top, left)
+      end
+    end
+  end
+end

data/lib/amun/windows/buffer_window.rb

@@ -0,0 +1,73 @@
+require 'amun/buffer'
+require 'amun/windows/base'
+require 'amun/windows/text_renderer'
+require 'amun/windows/mode_line'
+require 'amun/primitives/rect'
+require 'forwardable'
+
+module Amun
+  module Windows
+    # a window to display any buffer
+    # or the current buffer
+    class BufferWindow < Base
+      extend Forwardable
+
+      def_delegator :buffer, :trigger
+
+      attr_accessor :mode_line
+
+      def initialize(size, buffer = nil)
+        super(size)
+        @buffer = buffer
+        @mode_line = ModeLine.new(mode_line_size)
+        @text_renderer = TextRenderer.new(text_renderer_size)
+      end
+
+      def render
+        @text_renderer.render(buffer)
+        @mode_line.render(buffer)
+      end
+
+      # set a specific buffer to be displayed in this window
+      def display_buffer(buffer)
+        @buffer = buffer
+      end
+
+      # render current buffer from the Buffer class
+      def display_current_buffer
+        @buffer = nil
+      end
+
+      # get current buffer that this window is rendering
+      def buffer
+        @buffer || Buffer.current
+      end
+
+      private
+
+      def resize
+        super
+        @mode_line.size = mode_line_size
+        @text_renderer.size = text_renderer_size
+      end
+
+      def text_renderer_size
+        Rect.new(
+          top: top,
+          left: left,
+          width: width,
+          height: height - 1
+        )
+      end
+
+      def mode_line_size
+        Rect.new(
+          top: top + height - 1,
+          left: left,
+          width: width,
+          height: 1
+        )
+      end
+    end
+  end
+end

data/lib/amun/windows/echo_area.rb

@@ -0,0 +1,34 @@
+require 'amun/windows/base'
+require 'amun/buffer'
+
+module Amun
+  module Windows
+    # a line that is rendered by default at the end on the screen
+    # takes the whole width of screen
+    # should be linked to \*messages\* memory buffer and display new messages
+    # in the buffer text
+    class EchoArea < Base
+      def initialize(size)
+        super(size)
+        @last_messages_size = 0
+      end
+
+      def render
+        curses_window.erase
+        curses_window << message
+        curses_window.refresh
+        update_last_messages_size
+      end
+
+      private
+
+      def message
+        Buffer.messages[@last_messages_size..-1].strip.lines.last
+      end
+
+      def update_last_messages_size
+        @last_messages_size = Buffer.messages.length
+      end
+    end
+  end
+end

data/lib/amun/windows/frame.rb

@@ -0,0 +1,92 @@
+require 'curses'
+require 'amun/event_manager'
+require 'amun/buffer'
+require 'amun/windows/base'
+require 'amun/windows/buffer_window'
+require 'amun/windows/echo_area'
+
+module Amun
+  module Windows
+    # a Frame fills all the space in terminal
+    # renders an echo area or mini buffer if it exists
+    # and an object that
+    # respond to #render and #trigger, like buffer,
+    # or another window or so
+    class Frame < Base
+      attr_accessor :mini_buffer, :window, :echo_area
+      attr_writer :screen
+
+      def initialize(size = default_size)
+        super(size)
+        @window = BufferWindow.new(top_window_size)
+        @echo_area = EchoArea.new(bottom_window_size)
+        bind(Curses::KEY_RESIZE, self, :set_size_to_terminal)
+      end
+
+      def trigger(event)
+        EventManager.join(event, self.events, echo_area, mini_buffer || window, EventManager)
+      rescue StandardError => error
+        handle_exception(error)
+      end
+
+      def render
+        render_window(window)
+        render_window(bottom_area)
+      end
+
+      def set_size_to_terminal(*)
+        self.size = default_size
+      end
+
+      private
+
+      def resize
+        super
+        window.size = top_window_size
+        echo_area.size = bottom_window_size
+      end
+
+      def bottom_area
+        mini_buffer || echo_area
+      end
+
+      def default_size
+        Rect.new(
+          top: 0,
+          left: 0,
+          width: Curses.stdscr.maxx,
+          height: Curses.stdscr.maxy
+        )
+      end
+
+      def top_window_size
+        Rect.new(
+          top: top,
+          left: left,
+          width: width,
+          height: height - 1
+        )
+      end
+
+      def bottom_window_size
+        Rect.new(
+          top: top + height - 1,
+          left: left,
+          width: width,
+          height: 1
+        )
+      end
+
+      def render_window(window)
+        window.render
+        mini_buffer.render if mini_buffer
+      rescue StandardError => error
+        handle_exception(error)
+      end
+
+      def handle_exception(e)
+        Buffer.messages << "#{e.message} (#{e.backtrace.first})\n"
+      end
+    end
+  end
+end

data/lib/amun/windows/mini_buffer_window.rb

@@ -0,0 +1,126 @@
+require 'amun/windows/base'
+require 'amun/buffer'
+require 'amun/windows/text_renderer'
+require 'amun/primitives/rect'
+
+module Amun
+  module Windows
+    # a minibuffer that when attached will replace the frame
+    # echo area and display one line with a label (buffer name)
+    # and the value typed by the user (buffer content)
+    # it will fire 2 events, done and cancel, you can listen
+    # on them to do stuff with the input data,
+    # also after both events the buffer will be cleared
+    # to allow you to reattach the same window again and reuse it,
+    # also it allow passing a block to the initializer to execute it
+    # when the user press enter (done event) so you can have a fast usage as such
+    #    MiniBufferWindow.new("Are you sure?[Y/N]", "Y") do |window|
+    #        exit if window.buffer.to_s.downcase == 'y'
+    #    end.attach(Amun::Application.frame)
+    # that will create a minibuffer and attach it to current active frame
+    # also will have a label asking the user "Are you sure?" and a default
+    # value "Y" so user can just press enter, or clear it and press any other character
+    # when user press enter the block will be executed with the window itself as a parameter
+    # so the block will exit amun if the answer to the question is "y"
+    class MiniBufferWindow < Base
+      attr_reader :buffer
+
+      def initialize(name, default_value = '', &block)
+        super(default_size)
+
+        @buffer = Buffer.new(name)
+        @buffer << default_value
+        @buffer.point = default_value.length
+        @done_block = block if block_given?
+        @text_renderer = TextRenderer.new(text_renderer_size)
+
+        bind "\e", self, :cancel
+        bind "\C-g", self, :cancel
+        bind "\n", self, :done
+        bind "done", self, :exec_done_block
+      end
+
+      # attach the mini buffer to a frame of your choice,
+      # that will make it replace the echo are in this frame
+      def attach(frame)
+        detach if attached?
+        self.size = Rect.new(
+          top: frame.top + frame.height - 1,
+          left: frame.left,
+          width: frame.width,
+          height: 1
+        )
+        @frame = frame
+        @frame.mini_buffer = self
+      end
+
+      # deatach the mini buffer from its frame
+      def detach
+        @frame.mini_buffer = nil
+        @frame = nil
+      end
+
+      # is the mini buffer currently attached to any frame?
+      def attached?
+        @frame && @frame.mini_buffer == self
+      end
+
+      def render
+        curses_window.erase
+        curses_window << buffer.name
+        curses_window.refresh
+        @text_renderer.render(buffer)
+      end
+
+      def trigger(event)
+        EventManager.join(
+          event,
+          events,
+          buffer
+        )
+      end
+
+      def cancel(*)
+        detach
+        trigger("cancel")
+        buffer.clear
+      end
+
+      def done(*)
+        detach
+        trigger("done")
+        buffer.clear
+      end
+
+      def exec_done_block(*)
+        return unless @done_block
+        @done_block.call(self)
+      end
+
+      private
+
+      def resize
+        super
+        @text_renderer.size = text_renderer_size
+      end
+
+      def text_renderer_size
+        Rect.new(
+          top: top,
+          left: left + buffer.name.length,
+          width: width - buffer.name.length,
+          height: height
+        )
+      end
+
+      def default_size
+        Rect.new(
+          top: 0,
+          left: 0,
+          width: Curses.stdscr.maxx,
+          height: Curses.stdscr.maxy
+        )
+      end
+    end
+  end
+end

data/lib/amun/windows/mode_line.rb

@@ -0,0 +1,50 @@
+require 'amun/windows/base'
+require 'amun/helpers/colors'
+require 'amun/mode_line_segments/major_mode'
+require 'amun/mode_line_segments/buffer_name'
+
+module Amun
+  module Windows
+    # a line of small segments that display
+    # information about the current window,
+    # like mode name, line number, buffer name...etc
+    class ModeLine < Base
+      attr_reader :left_segments, :right_segments
+
+      def initialize(size)
+        super(size)
+        @right_segments = []
+        @left_segments = [
+          ModeLineSegments::BufferName.new,
+          ModeLineSegments::MajorMode.new
+        ]
+
+        Helpers::Colors.register_default(:mode_line, 0, 255)
+      end
+
+      def render(buffer)
+        right_output = render_segments(right_segments, buffer)
+        left_output = render_segments(left_segments, buffer)
+        filler = empty_space(right_output, left_output)
+
+        curses_window.erase
+        Helpers::Colors.print(curses_window, *left_output, filler, *right_output)
+        curses_window.refresh
+      end
+
+      private
+
+      def empty_space(right_output, left_output)
+        text_size = (right_output + left_output).map(&:size).inject(0, :+)
+        empty_space = [0, width - text_size].max
+        (' ' * empty_space).colorize(:mode_line)
+      end
+
+      def render_segments(segments, buffer)
+        segments.map do |segment|
+          segment.render(buffer)
+        end.flatten
+      end
+    end
+  end
+end

data/lib/amun/windows/text_renderer.rb

@@ -0,0 +1,41 @@
+require 'amun/windows/base'
+
+module Amun
+  module Windows
+    # this class renders the buffer in a curses window
+    # makes sure the current character under point is highlighted
+    # highlight the space between point and mark
+    # and make sure to color text and other stuff
+    # consider it the rendering engine of the buffer
+    class TextRenderer < Base
+      def render(buffer)
+        curses_window.erase
+        curses_window.scrollok(true)
+        render_text(buffer)
+        curses_window.refresh
+      end
+
+      private
+
+      def render_text(buffer)
+        point = buffer.point
+        curses_window << buffer[0...point]
+        render_point(buffer)
+        curses_window << buffer[(point + 1)..-1]
+      end
+
+      def render_point(buffer)
+        curses_window.attron(Helpers::Colors::REVERSE)
+        curses_window << case buffer[buffer.point]
+                         when "\n"
+                           " \n"
+                         when nil
+                           " "
+                         else
+                           buffer[buffer.point]
+                         end
+        curses_window.attroff(Helpers::Colors::REVERSE)
+      end
+    end
+  end
+end