amun 0.1.3 → 0.2.0

data/lib/amun/buffer.rb

@@ -0,0 +1,103 @@
+require 'set'
+require 'amun/object'
+require 'amun/event_manager'
+require 'amun/major_modes/fundamental'
+require 'forwardable'
+
+module Amun
+  # A buffer could present any kind of IO object (File, StringIO...etc)
+  # also it has a major mode responsible update lines and visual lines
+  class Buffer < Object
+    extend Forwardable
+    attr_accessor :name, :io, :major_mode, :minor_modes
+
+    def initialize(name, io = StringIO.new)
+      super()
+      self.io = io
+      self.name = name
+      self.point = 0
+      self.text = ''
+      self.major_mode = MajorModes::Fundamental.new(self)
+      self.minor_modes = Set.new
+    end
+
+    attr_writer :point
+    def point
+      return 0 if @point.negative?
+      return length if @point > length
+      @point
+    end
+
+    attr_writer :mark
+    def mark
+      return nil if @mark.nil?
+      return 0 if @mark.negative?
+      return length if @mark > length
+      @mark
+    end
+
+    def trigger(event)
+      EventManager.join(
+        event,
+        *([events] + minor_modes.to_a + [major_mode])
+      )
+    end
+
+    # buffer should wrap the inner @text
+    # and expose any reading method but
+    # control the writing methods
+
+    def_delegators :text,
+                   :length, :size, :[],
+                   :count, :index, :rindex,
+                   :empty?
+
+    def insert(index, other_str)
+      text.insert(index, other_str)
+    end
+
+    def slice!(start, length = 1)
+      text.slice!(start, length)
+    end
+
+    def <<(p1)
+      insert(length, p1)
+    end
+
+    def clear
+      slice!(0, length)
+    end
+
+    def to_s
+      text.dup
+    end
+
+    class << self
+      attr_writer :current, :instances
+
+      def instances
+        @instances ||= Set.new
+      end
+
+      def current
+        @current ||= scratch
+      end
+
+      def scratch
+        @scratch ||= new('*Scratch*')
+        instances << @scratch
+        @scratch
+      end
+
+      def messages
+        @messages ||= new('*Messages*')
+        instances << @messages
+        @messages
+      end
+    end
+
+    private
+
+    attr_accessor :text
+  end
+end

data/lib/amun/event_manager.rb

@@ -44,8 +44,8 @@ module Amun
         raise ArgumentError, "#{method} : is not a method for #{object}"
       end
 
-      add_chain(event)
-      @bindings[event].unshift(object: object, method: method)
+      add_chain(event.to_s)
+      @bindings[event.to_s].unshift(object: object, method: method)
     end
 
     # remove all occurence of *method* from the *event* stack
@@ -148,6 +148,15 @@ module Amun
         end
       end
 
+      # clear the globally bound events
+      # if you need to reset this class to
+      # its default state, this method
+      # should clear all events and its associated
+      # objects/methods
+      def clear
+        @instance = nil
+      end
+
       private
 
       def instance
@@ -172,7 +181,7 @@ module Amun
 
     def add_chain(event)
       return unless event.to_s.include?(' ')
-      event.to_s.split(" ").inject("") do |chain, evt|
+      event.to_s.split(" ")[0...-1].inject("") do |chain, evt|
         new_chain = (chain + " " + evt).strip
         @chains << new_chain
         new_chain

data/lib/amun/features/echo_event.rb

@@ -1,6 +1,9 @@
 require 'amun/event_manager'
+require 'amun/buffer'
 
 def log(event)
-  Amun::UI::Buffer.messages.text << "#{event}\n"
+  # log valid strings only no control characters
+  event = event.encode!('UTF-8', 'UTF-8', invalid: :replace)
+  Amun::Buffer.messages << "#{event}\n"
 end
 Amun::EventManager.bind_all nil, :log

data/lib/amun/features/files.rb

@@ -0,0 +1,26 @@
+require 'amun/event_manager'
+require 'amun/buffer'
+require 'amun/windows/mini_buffer_window'
+
+def find_file(*)
+  Amun::Windows::MiniBufferWindow.new('Open file: ', Dir.pwd) do |window|
+    file_path = window.buffer.to_s
+
+    file_buffer = Amun::Buffer.new(file_path, File.open(file_path, 'r+'))
+    Amun::Buffer.instances << file_buffer
+    Amun::Buffer.current = file_buffer
+  end.attach(Amun::Application.frame)
+
+  true
+end
+
+Amun::EventManager.bind "\C-x \C-f", nil, :find_file
+
+unless ARGV.empty?
+  ARGV.each do |file|
+    file_buffer = Amun::Buffer.new(file, File.open(file, 'r+'))
+    Amun::Buffer.instances << file_buffer
+    Amun::Buffer.current = file_buffer
+    Amun::Application.frame.render
+  end
+end

data/lib/amun/helpers/colors.rb

@@ -2,6 +2,7 @@ require 'curses'
 
 module Amun
   module Helpers
+    class ColorLimitExceeded < StandardError; end
     ##
     # Colors is responsible for registering new colors
     # pairs (foreground and background)
@@ -52,8 +53,8 @@ module Amun
       # foreground(Number):: foreground color in current terminal color schema
       # background(Number):: background color in current terminal color schema
       def register(name, foreground, background)
-        if COLORS.size >= Curses.color_pairs - 1
-          raise "Can't register color: #{name}, max: #{Curses.color_pairs}"
+        if !COLORS.key?(name) && COLORS.size >= Curses.color_pairs - 1
+          raise ColorLimitExceeded, "Can't register color: #{name}, max: #{Curses.color_pairs}"
         end
 
         Curses.init_pair(COLORS[name], foreground, background)
@@ -79,16 +80,16 @@ module Amun
       # type(Colors::Constant):: a text style constant
       # defined in Colors, that manipulate the text style
       # (Bold, Underline, Invert colors)
-      def use(window, name, type = NORMAL)
+      def use(curses_window, name, type = NORMAL)
         index = COLORS.key?(name) ? COLORS[name] : 0
-        window.attron(Curses.color_pair(index) | type)
+        curses_window.attron(Curses.color_pair(index) | type)
       end
 
       # print string in Curses window in the choosen color and style
-      def print(window, *strings)
+      def print(curses_window, *strings)
         strings.each do |string|
-          use(window, string.color || DEFAULT_COLOR, string.style || NORMAL)
-          window << string
+          use(curses_window, string.color || DEFAULT_COLOR, string.style || NORMAL)
+          curses_window << string
         end
       end
     end

data/lib/amun/helpers/keyboard.rb

@@ -2,27 +2,44 @@ require 'curses'
 
 module Amun
   module Helpers
+    # a module to deal with the keyboard
+    # a complementary module to curses
+    # doesn't intend to replace it
+    # it was created to overcome the shorcoming
+    # of getting a character + meta from the keyboard
+    # in the first place.
     module Keyboard
       module_function
 
       TIMEOUT = 100
 
+      # get a character from the keyboard
+      # and make sure you detect the meta combination
       def char
         ch = Curses.stdscr.get_char
-        Curses.stdscr.timeout = TIMEOUT
-        modified_char = Curses.stdscr.get_char if ch == "\e"
-        Curses.stdscr.timeout = -1
+        modified_character = modified_char if ch == "\e"
 
-        return ch if modified_char.nil?
-        return "#{ch} #{modified_char}" if modified_char.is_a? Numeric
-        return "#{ch} #{modified_char}" if modified_char.size > 1
+        return ch.to_s if modified_character.nil?
+        return "#{ch} #{modified_character}" if modified_character.is_a? Numeric
+        return "#{ch} #{modified_character}" if modified_character.length > 1
 
         begin
-          eval "?\\M-#{modified_char}"
+          eval "?\\M-#{modified_character}"
         rescue SyntaxError
-          return "#{ch} #{modified_char}"
+          return "#{ch} #{modified_character}"
         end
       end
+
+      private
+
+      module_function
+
+      def modified_char
+        Curses.stdscr.timeout = TIMEOUT
+        char = Curses.stdscr.get_char
+        Curses.stdscr.timeout = -1
+        char
+      end
     end
   end
 end

data/lib/amun/major_modes/fundamental.rb

@@ -1,51 +1,19 @@
+require 'amun/object'
 require 'amun/helpers/colors'
 require 'amun/behaviours/emacs'
 
 module Amun
   module MajorModes
-    # Basic mode that show any IO
-    class Fundamental
+    # Basic mode with emacs defaults
+    class Fundamental < Object
       include Behaviours::Emacs
 
       def initialize(buffer)
-        @buffer = buffer
+        super()
+        self.buffer = buffer
 
-        @events = EventManager.new
-        @events.bind_all self, :event_handler
-        emacs_behaviour_initialize(@events)
-
-        read_io if buffer.text.nil?
-      end
-
-      def trigger(event)
-        EventManager.join(event, @events)
-      end
-
-      def render(window)
-        window.clear
-        point = buffer.point
-
-        window << buffer.text[0...point]
-        window.attron(Helpers::Colors::REVERSE)
-
-        at_point = buffer.text[point]
-        window << (at_point == "\n" || at_point.nil? ? " \n" : at_point)
-        window.attroff(Helpers::Colors::REVERSE)
-        window << buffer.text[(point + 1)..-1]
-      end
-
-      def event_handler(event)
-        return true unless event.is_a? String
-        return true unless event.length == 1
-        return true unless event.valid_encoding?
-
-        case event
-        when /[^[:print:]\n\t]/
-          true
-        else
-          buffer.text.insert(buffer.point, event)
-          buffer.point += 1
-        end
+        emacs_behaviour_initialize
+        read_io if buffer.empty?
       end
 
       private
@@ -53,7 +21,7 @@ module Amun
       attr_accessor :buffer
 
       def read_io
-        buffer.text = buffer.io.read
+        buffer << buffer.io.read
       end
     end
   end

data/lib/amun/major_modes/irb.rb

@@ -0,0 +1,40 @@
+require 'amun/object'
+require 'amun/helpers/colors'
+require 'amun/behaviours/emacs'
+
+module Amun
+  module MajorModes
+    #  mode that executes the last line in
+    # the current environment and print the output
+    class IRB < Object
+      include Behaviours::Emacs
+
+      def initialize(buffer)
+        super()
+        self.buffer = buffer
+
+        emacs_behaviour_initialize
+        bind "\n", self, :execute_last_line
+        read_io if buffer.empty?
+      end
+
+      def execute_last_line(*)
+        last_line = buffer.lines.last
+        result = eval(last_line)
+        buffer << "\n#{result}"
+      rescue StandardError, SyntaxError => error
+        buffer << "\n#{error.inspect}\n#{error.backtrace}"
+      ensure
+        buffer.point = buffer.length
+      end
+
+      private
+
+      attr_accessor :buffer
+
+      def read_io
+        buffer << buffer.io.read
+      end
+    end
+  end
+end

data/lib/amun/mode_line_segments/buffer_name.rb

@@ -0,0 +1,10 @@
+module Amun
+  module ModeLineSegments
+    # display buffer name in modeline
+    class BufferName
+      def render(buffer)
+        " #{buffer.name} ".colorize(:mode_line)
+      end
+    end
+  end
+end

data/lib/amun/mode_line_segments/major_mode.rb

@@ -0,0 +1,11 @@
+module Amun
+  module ModeLineSegments
+    # display major mode name in mode line
+    class MajorMode
+      def render(buffer)
+        mode = buffer.major_mode.class.name.split('::').last
+        " (#{mode}) ".colorize(:mode_line)
+      end
+    end
+  end
+end

data/lib/amun/object.rb

@@ -0,0 +1,21 @@
+require 'amun/event_manager'
+require 'forwardable'
+
+module Amun
+  # an object wrapping event manager inside it
+  # and exposing every method to the public
+  # this way you can have this object and switch
+  # behavior and states by switching internal event manager
+  # instances, for example you can have a mode that switch between
+  # normal and insert mode (ahem ahmed VIM style)
+  class Object
+    extend Forwardable
+
+    attr_accessor :events
+    def_delegators :events, :bind, :bind_all, :unbind, :unbind_all, :trigger
+
+    def initialize
+      @events = EventManager.new
+    end
+  end
+end

data/lib/amun/primitives/rect.rb

@@ -0,0 +1,15 @@
+# a primitive class that incapsulate
+# a rectangle on screen, with position
+# (top, left) and size (width, height)
+class Rect
+  attr_reader :top, :left, :width, :height
+
+  # create a rectangle with top, left, width and height
+  # opts(Hash):: a hash with keys (top, left, width, height)
+  def initialize(opts = {})
+    @top = opts[:top]
+    @left = opts[:left]
+    @width = opts[:width]
+    @height = opts[:height]
+  end
+end

data/lib/amun/version.rb

@@ -1,3 +1,3 @@
 module Amun
-  VERSION = '0.1.3'.freeze
+  VERSION = '0.2.0'.freeze
 end