amun 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6430d19551a385610563d0305e205315fb57afd3
-  data.tar.gz: d17d801b580e7cb7207713e43f7b635167aa159d
+  metadata.gz: 10726ce656cbf6445cbee3177cda26541982d3b7
+  data.tar.gz: 0da415d031b8e63ff1fb5fb4b92537117ed1ad4f
 SHA512:
-  metadata.gz: 33457f2a5eb0d21f8aefee6277673e9473661c78e8c471ff4627a2c3b36676a822a1af8e1d53f70918ff94ee8346c659d65baaaef8d958742a14e83e9ba11585
-  data.tar.gz: b7f75bb84a7875b23be10d43a3513158c1da27dccd82944a620f1ebd5b715ce852b7712b5024ca8509ad84532049ea52d652cef473498c5d924ef6f90f3b6ee9
+  metadata.gz: a6eef223a7d0a123259da8edea864b7a701b8d8d048fdef6ff0dc1002a187b4008c4ed0b967e1db95fb5345156c611063ef4525e67550efbe7da2017c925d486
+  data.tar.gz: b475175d8acf045f52ac748be2243c7b46d1a4576334a768d671a42295bcf899f8cdd0e8bbf12152135b1bf22ce7537f8fb9ac38b8481a75be651a2e63f88d7b

data/.rubocop.yml

@@ -0,0 +1,11 @@
+AllCops:
+  Exclude:
+    - 'test/**/*'
+    - '*.gemspec'
+  DisplayCopNames: true
+Style/FrozenStringLiteralComment:
+  Enabled: false
+Style/StringLiterals:
+  Enabled: false
+Style/WordArray:
+  Enabled: false

data/.travis.yml

@@ -1,5 +1,8 @@
 sudo: false
 language: ruby
-rvm:
-  - 2.4.0
 before_install: gem install bundler -v 1.14.4
+addons:
+    code_climate:
+        repo_token: 9aa20c762ad050635e6c5c5cc13e6edb28d79b12e6929f101f23590273dcda3e
+after_success:
+  - bundle exec codeclimate-test-reporter

data/README.md

@@ -1,25 +1,62 @@
 # Amun (Work in progress)
 
+## "King of the gods and god of the wind"
+[![Gem Version](https://badge.fury.io/rb/amun.svg)](http://badge.fury.io/rb/amun)
+[![Build Status](https://travis-ci.org/blazeeboy/amun.svg?branch=master)](https://travis-ci.org/blazeeboy/amun)
+[![Code Climate](https://codeclimate.com/github/blazeeboy/amun/badges/gpa.svg)](https://codeclimate.com/github/blazeeboy/amun)
+[![Test Coverage](https://codeclimate.com/github/blazeeboy/amun/badges/coverage.svg)](https://codeclimate.com/github/blazeeboy/amun)
+
 A minimal CLI text editor, built on Ruby, looking for Emacs as it's father and idol.
 
 As developing packages for Emacs with Elisp wasn't always a fun or easy task, Starting a project that leverage ruby ability for fast development will be a good move towards
 an open, easy to extend editor.
 
-When I started this project I had 2 options, taking the VIM way or emacs way, looking in the current state of the two editors, It's obvious that emacs abbroach has a better
+When I started this project I had 2 options, taking the VIM way or emacs way, looking in the current state of the two editors, It's obvious that emacs approach has a better
 extensibility over VIM, emacs customizability is far superior to VIM, so building this project as a minimal and emacs-like would open the door for vim users to have their own
 bindings as a package like emacs Evil mode, but doing the other way around won't help emacs users.
 
+## Advantages of building an editor in ruby
+
+* We can use ruby gems as package management
+* we already have bundler to fix dependencies, upgrade, downgrade gems (plugins in this case), you can even add sources for gems or get a gem from github or company inhouse gems.
+* you can reflect on the runtime and autocomplete commands
+* plugins can mutate all parts of the runtime application classes/objects included
+* ruby is easy to learn so it'll be easier to build gems that is specifically for this editor
+* lots of gems already exists and could be loaded into the editor environment
+* you can use it locally or remotly as it's terminal based
+* documentation included, rdoc is already there to be used
+
 ## Installation
 
     $ gem install amun
 
 ## Usage
 
-amun install an executable to your path, so executing `amun` from your commandline should launch amun
+amun install an executable to your path, so executing `amun` from your command-line should launch amun
+
+## Structure
+
+
+### Helpers
+
+Helpers are modules that any class can use to do side tasks, think of it like Ruby on rails helpers.
+
+* Only modules no classes
+* doesn't depend on each other
+* depends on the project dependencies only like "Curses"
+
+### MajorModes
+
+Classes that are responsible the following for a buffer object:
+
+* event handling
+* manipulating IO
+* Rendering IO into a curses window
+
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
 ## Contributing
 

data/Rakefile

@@ -7,4 +7,4 @@ Rake::TestTask.new(:test) do |t|
   t.test_files = FileList['test/**/*_test.rb']
 end
 
-task :default => :test
+task default: :test

data/amun.gemspec

@@ -28,4 +28,6 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pry"
   spec.add_development_dependency "guard"
   spec.add_development_dependency "guard-minitest"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "codeclimate-test-reporter", "~> 1.0.0"
 end

data/lib/amun/application.rb

@@ -0,0 +1,51 @@
+require 'curses'
+require 'singleton'
+require 'amun/ui/windows/frame'
+require 'amun/event_manager'
+require 'amun/features_loader'
+require 'amun/helpers/keyboard'
+
+module Amun
+  # singleton Amun application, it initialize curses,
+  # have the frame and handles keyboard
+  class Application
+    include Singleton
+
+    attr_writer :frame
+
+    def frame
+      @frame ||= UI::Windows::Frame.new
+    end
+
+    def run
+      init_curses
+      frame.render
+      FeaturesLoader.load
+      keyboard_thread.join
+    end
+
+    private
+
+    def init_curses
+      Curses.init_screen
+      Curses.curs_set 0
+      Curses.raw
+      Curses.noecho
+      Curses.start_color
+      Curses.stdscr.keypad = true
+      Curses.ESCDELAY = 0
+    end
+
+    def keyboard_thread
+      Thread.new do
+        chain = []
+        while (ch = Helpers::Keyboard.char)
+          chain << ch
+          if EventManager.join(chain.join(' '), frame) != EventManager::CHAINED
+            chain.clear
+          end
+        end
+      end
+    end
+  end
+end

data/lib/amun/behaviours/emacs.rb

@@ -0,0 +1,131 @@
+require 'amun/ui/buffer'
+require 'curses'
+
+module Amun
+  module Behaviours
+    module Emacs
+      def emacs_behaviour_initialize(event_manager)
+        event_manager.bind "\C-f", self, :forward_char
+        event_manager.bind Curses::KEY_RIGHT.to_s, self, :forward_char
+
+        event_manager.bind "\C-b", self, :backward_char
+        event_manager.bind Curses::KEY_LEFT.to_s, self, :backward_char
+
+        event_manager.bind "\C-n", self, :next_line
+        event_manager.bind Curses::KEY_DOWN.to_s, self, :next_line
+
+        event_manager.bind "\C-p", self, :previous_line
+        event_manager.bind Curses::KEY_UP.to_s, self, :previous_line
+
+        event_manager.bind "\C-a", self, :beginning_of_line
+        event_manager.bind Curses::KEY_HOME.to_s, self, :beginning_of_line
+
+        event_manager.bind "\C-e", self, :end_of_line
+        event_manager.bind Curses::KEY_END.to_s, self, :end_of_line
+
+        event_manager.bind "\C-d", self, :delete_char
+        event_manager.bind Curses::Key::BACKSPACE.to_s, self, :backward_delete_char # this doesn't work, check linux
+        event_manager.bind "\C-?", self, :backward_delete_char # C-? is backspace on mac terminal for some reason
+
+        event_manager.bind Curses::Key::DC.to_s, self, :forward_delete_char
+
+        event_manager.bind "\C-k", self, :kill_line
+        event_manager.bind "\M-d", self, :kill_word
+      end
+
+      def forward_char(*)
+        buffer.point += 1
+        true
+      end
+
+      def backward_char(*)
+        buffer.point -= 1
+        true
+      end
+
+      def next_line(*)
+        line_begin = buffer.text.rindex("\n", buffer.point) || 0
+        line_end = buffer.text.index("\n", buffer.point + 1) || buffer.text.size + 1
+        next_line_end = buffer.text.index("\n", line_end + 1) || buffer.text.size + 1
+        point_offset = buffer.point - line_begin
+        buffer.point = [line_end + point_offset, next_line_end].min
+        true
+      end
+
+      def previous_line(*)
+        line_begin = buffer.text.rindex("\n", buffer.point) || 0
+        previous_line_begin = buffer.text.rindex("\n", line_begin - 1) || 0
+        point_offset = buffer.point - line_begin
+        buffer.point = [previous_line_begin + point_offset, line_begin - 1].min
+        true
+      end
+
+      def beginning_of_line(*)
+        point = buffer.point
+        return true if point.zero?
+        return true if buffer.text[point - 1] == "\n"
+
+        line_start = buffer.text.rindex("\n", point - 1)
+        buffer.point = line_start.nil? ? 0 : line_start + 1
+        true
+      end
+
+      def end_of_line(*)
+        point = buffer.point
+        return true if buffer.text[point] == "\n"
+
+        line_end = buffer.text.index("\n", point)
+        buffer.point = line_end || buffer.text.length
+        true
+      end
+
+      def delete_char(*)
+        buffer.text.slice!(buffer.point)
+        true
+      end
+
+      def backward_delete_char(*)
+        return true if buffer.point.zero?
+
+        buffer.point -= 1
+        buffer.text.slice!(buffer.point)
+        true
+      end
+
+      def forward_delete_char(*)
+        delete_char
+      end
+
+      # TODO should move text to kill ring
+      def kill_line(*)
+        if buffer.text[buffer.point] == "\n"
+          buffer.text.slice!(buffer.point)
+          return true
+        end
+
+        line_end = buffer.text.index(/$/, buffer.point)
+        buffer.text.slice!(buffer.point...line_end)
+        true
+      end
+
+      # TODO should move text to kill ring
+      def kill_word(*)
+        first_non_letter = buffer.text.index(/\P{L}/, buffer.point) || buffer.text.size
+        word_beginning = buffer.text.index(/\p{L}/, first_non_letter) || buffer.text.size
+        buffer.text.slice!(buffer.point...word_beginning)
+        true
+      end
+
+      # This should be bound to \M-BACKSPACE or \M-DEL but I think the terminal doesn't send it
+      # So the implementation will remain there until we find a way to catch this key
+      #
+      # TODO should move text to kill ring
+      def backward_kill_word(*)
+        first_letter_backward = buffer.text.rindex(/\p{L}/, buffer.point) || 0
+        first_non_letter_before_word = buffer.text.rindex(/\P{L}/, first_letter_backward) || -1
+        buffer.text.slice!(first_non_letter_before_word + 1 .. buffer.point)
+        true
+      end
+    end
+  end
+end

data/lib/amun/event_manager.rb

@@ -1,3 +1,6 @@
+require 'forwardable'
+require 'set'
+
 module Amun
   # = Event manager
   # Stores a stack of methods to call for each event,
@@ -17,20 +20,31 @@ module Amun
   # when the *Buffer* module saves a file it should trigger
   # that event, which executed the *update_title*.
   class EventManager
+    # Event is interrupted and no need to continue
+    INTERRUPTED = :interrupted
+    # Event is to be continued
+    CONTINUE = :continue
+    # Event needs to be chained, will wait for next event
+    CHAINED = :chained
+
     def initialize
       @bindings = Hash.new { |h, k| h[k] = [] }
+      @chains = Set.new
     end
 
-    # register an *objects*' *method* to be executed when the *event* is triggered
+    # register an *objects*' *method* to be executed
+    # when the *event* is triggered
     #
     # event(String):: and event to bind the method to
     # object(Object):: an object or class, that respond to +method+
-    # method(Symbol):: a method name that should be executed when the event is triggered
+    # method(Symbol):: a method name that should be executed when the event
+    # is triggered
     def bind(event, object, method)
-      unless object.respond_to? method
+      if !object.nil? && !object.respond_to?(method)
         raise ArgumentError, "#{method} : is not a method for #{object}"
       end
 
+      add_chain(event)
       @bindings[event].unshift(object: object, method: method)
     end
 
@@ -43,6 +57,8 @@ module Amun
       @bindings[event].delete_if do |binding|
         binding[:object] == object && binding[:method] == method
       end
+      @bindings.delete(event) if @bindings[event].empty?
+      update_chains
     end
 
     # bind an object method to be executed when any event is triggered
@@ -50,7 +66,7 @@ module Amun
     # be executed after the event specific stack is executed and didn't
     # stop execution
     def bind_all(object, method)
-      bind :all, object, method
+      bind "all", object, method
     end
 
     # remove the *method* from executing after every event,
@@ -58,7 +74,7 @@ module Amun
     #
     # this won't remove the method if it was registered with #bind
     def unbind_all(object, method)
-      unbind :all, object, method
+      unbind "all", object, method
     end
 
     # execute *event* stack of methods in Last-In-First-Out,
@@ -66,8 +82,77 @@ module Amun
     # to be executed after all events with #bind_all method
     # if any method in this chain returned false, it will stop the rest
     # of the stack.
+    #
+    # a chained event is an event that contain a space
+    # between 2 or more events lie "\C-c \C-x" so this event
+    # should be executed when these 2 events occure after
+    # each other,
+    # if you tried to trigger the first part \C-c the
+    # trigger method will return CHAINED, assuming that \C-c
+    # is not handled and also if handled the handle execution
+    # didn't return false to interrupt the execution
     def trigger(event)
-      trigger_for_event(event, event) && trigger_for_event(:all, event)
+      return INTERRUPTED unless trigger_for_event(event, event) &&
+                                trigger_for_event("all", event)
+      return CHAINED if chained?(event)
+      CONTINUE
+    end
+
+    # class will have the same methods as the EventManager
+    # instance, so you can attack events and trigger it globally
+    # like if you have a global instance if EventManager and
+    # you're attaching and triggering events from it instead
+    # if talking to a specific instance, this global trigger
+    # will be handled by one of the editor toplevel components
+    # and it should be the lowest priority, if every thing else
+    # can't handle the event it should ask this class if anyone
+    # registered something globally to handle this event.
+    #
+    # if you want to handle events in your major mode, minor modes
+    # or anything that the application will ask it to trigger event
+    # you need to instanciate an object, if you need your action to
+    # the default and should be handled globally, like exiting the application
+    # or changing theme, or changing some global variable, update packages
+    # or any similar global actions, then using the class methods will
+    # make sense here.
+    class << self
+      extend Forwardable
+
+      def_delegators :instance, :bind, :unbind, :bind_all, :unbind_all, :trigger
+
+      # trigger an array of event_managers with an event
+      # and return one of the 3 statuses (INTERRUPTED, CHAINED, CONTINUE)
+      #
+      # if any manager returned false or INTERRUPTED will
+      # not execute further and return INTERRUPTED,
+      #
+      # if it faced an event that wants to chain the event
+      # it will return CHAINED if all next managers returned
+      # CONTINUE or also CHAINED
+      #
+      # will return CONTINUE if all manangers returned continue
+      #
+      # event(Symbol):: an event to trigger on all provided managers
+      # *event_managers(*Array):: you can pass as many event managers as
+      # you like as parameters to this method, it will be triggered in order
+      def join(event, *event_managers)
+        event_managers.inject(CONTINUE) do |result, manager|
+          case manager.trigger(event)
+          when INTERRUPTED, false
+            break INTERRUPTED
+          when CHAINED
+            CHAINED
+          else
+            result
+          end
+        end
+      end
+
+      private
+
+      def instance
+        @instance ||= new
+      end
     end
 
     private
@@ -77,5 +162,25 @@ module Amun
         binding[:object].send binding[:method], event
       end
     end
+
+    def update_chains
+      @chains = Set.new
+      @bindings.each do |event|
+        add_chain(event)
+      end
+    end
+
+    def add_chain(event)
+      return unless event.to_s.include?(' ')
+      event.to_s.split(" ").inject("") do |chain, evt|
+        new_chain = (chain + " " + evt).strip
+        @chains << new_chain
+        new_chain
+      end
+    end
+
+    def chained?(event)
+      @chains.include? event
+    end
   end
 end

data/lib/amun/features/echo_event.rb

@@ -0,0 +1,6 @@
+require 'amun/event_manager'
+
+def log(event)
+  Amun::UI::Buffer.messages.text << "#{event}\n"
+end
+Amun::EventManager.bind_all nil, :log

data/lib/amun/features/quit.rb

@@ -0,0 +1,6 @@
+require 'amun/event_manager'
+
+def kill_amun(*)
+  exit 0
+end
+Amun::EventManager.bind("\C-x \C-c", nil, :kill_amun)

data/lib/amun/features_loader.rb

@@ -0,0 +1,14 @@
+module Amun
+  # load all files in the features directory
+  module FeaturesLoader
+    module_function
+
+    def load
+      path = File.expand_path('../features', __FILE__)
+      features = Dir.glob(File.join(path, '**/*'))
+      features.each do |feature|
+        require feature
+      end
+    end
+  end
+end

data/lib/amun/helpers/colors.rb

@@ -3,13 +3,18 @@ require 'curses'
 module Amun
   module Helpers
     ##
-    # Colors is responsible for registering new colors pairs (foreground and background)
-    # associate the pair with a name, then #use that pair for the next text printed
-    # on screen, also contains styles constants could be passed to #use to print bold
+    # Colors is responsible for registering new colors
+    # pairs (foreground and background)
+    # associate the pair with a name, then #use that pair
+    # for the next text printed
+    # on screen, also contains styles constants could be
+    # passed to #use to print bold
     # or underline text for example
     #
-    # it's important to understand that the number of pairs that coul'd be registered
-    # is limited to a number the current terminal specify, so registering, more color
+    # it's important to understand that the number of pairs
+    # that coul'd be registered
+    # is limited to a number the current terminal specify,
+    # so registering, more color
     # pairs than allowed will result in a RuntimeError.
     #
     # color values could be taken from the xterm-256 color schema from here:
@@ -37,6 +42,7 @@ module Amun
       RIGHT = Curses::A_RIGHT
 
       COLORS = Hash.new { |h, k| h[k] = h.length + 1 }
+      DEFAULT_COLOR = :default
       private_constant :COLORS
 
       # register or update a color pair with *foreground* and *background*
@@ -47,19 +53,57 @@ module Amun
       # 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} as the colors exceeded the limit #{Curses.color_pairs}"
+          raise "Can't register color: #{name}, max: #{Curses.color_pairs}"
         end
 
         Curses.init_pair(COLORS[name], foreground, background)
       end
 
+      # check if a color pair is registered or not, returns true if registered
+      def registered?(name)
+        COLORS.key? name
+      end
+
+      # works like #register but doesn't override your color if it's already
+      # registered, this is a better method for any
+      # module to use to define colors
+      # #register should be used for redefining a color pair values
+      def register_default(name, foreground, background)
+        return if registered? name
+        register(name, foreground, background)
+      end
+
       # use color pair for the next printed text
+      # window(Curses Window):: that we need to change it's colors
       # name(Symbol):: a color pair name registered before with #register
-      # type(Colors::Constant):: a text style constant defined in Colors, that manipulate the text style (Bold, Underline, Invert colors)
-      def use(name, type = NORMAL)
+      # 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)
         index = COLORS.key?(name) ? COLORS[name] : 0
-        Curses.attron(Curses.color_pair(index)| type)
+        window.attron(Curses.color_pair(index) | type)
+      end
+
+      # print string in Curses window in the choosen color and style
+      def print(window, *strings)
+        strings.each do |string|
+          use(window, string.color || DEFAULT_COLOR, string.style || NORMAL)
+          window << string
+        end
       end
     end
   end
 end
+
+# for easier printing of colored string on the screen
+# we can add color property to any string and then
+# use it to print the string on the screen
+class String
+  attr_accessor :color, :style
+
+  def colorize(color, style = Amun::Helpers::Colors::NORMAL)
+    self.color = color
+    self.style = style
+    self
+  end
+end

data/lib/amun/helpers/keyboard.rb

@@ -0,0 +1,28 @@
+require 'curses'
+
+module Amun
+  module Helpers
+    module Keyboard
+      module_function
+
+      TIMEOUT = 100
+
+      def char
+        ch = Curses.stdscr.get_char
+        Curses.stdscr.timeout = TIMEOUT
+        modified_char = Curses.stdscr.get_char if ch == "\e"
+        Curses.stdscr.timeout = -1
+
+        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
+
+        begin
+          eval "?\\M-#{modified_char}"
+        rescue SyntaxError
+          return "#{ch} #{modified_char}"
+        end
+      end
+    end
+  end
+end

data/lib/amun/major_modes/fundamental.rb

@@ -0,0 +1,60 @@
+require 'amun/helpers/colors'
+require 'amun/behaviours/emacs'
+
+module Amun
+  module MajorModes
+    # Basic mode that show any IO
+    class Fundamental
+      include Behaviours::Emacs
+
+      def initialize(buffer)
+        @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
+      end
+
+      private
+
+      attr_accessor :buffer
+
+      def read_io
+        buffer.text = buffer.io.read
+      end
+    end
+  end
+end

data/lib/amun/ui/buffer.rb

@@ -0,0 +1,90 @@
+require 'set'
+require 'amun/event_manager'
+require 'amun/major_modes/fundamental'
+require 'amun/ui/mode_line'
+
+module Amun
+  module UI
+    # 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
+      attr_accessor :name, :io, :text
+      attr_writer :major_mode, :minor_modes, :mode_line, :point, :mark
+
+      def initialize(name, io = StringIO.new)
+        self.io = io
+        self.name = name
+        self.point = 0
+      end
+
+      def major_mode
+        @major_mode ||= MajorModes::Fundamental.new(self)
+      end
+
+      def mode_line
+        @mode_line ||= UI::ModeLine.new(self)
+      end
+
+      def minor_modes
+        @minor_modes ||= Set.new
+      end
+
+      def point
+        return 0 if @point < 0
+        max = text.size
+        return max if @point > max
+        @point
+      end
+
+      def mark
+        return 0 if @mark < 0
+        max = text.size
+        return max if @mark > max
+        @mark
+      end
+
+      def trigger(event)
+        EventManager.join(
+          event,
+          *(minor_modes + [major_mode])
+        )
+      end
+
+      def render(window)
+        major_mode_window = window.subwin(window.maxy - 1, window.maxx, 0, 0)
+        mode_line_window = window.subwin(1, window.maxx, window.maxy - 1, 0)
+
+        major_mode.render(major_mode_window)
+        mode_line.render(mode_line_window)
+      ensure
+        major_mode_window.close
+        mode_line_window.close
+      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.text = '' if @messages.text.nil?
+          @messages
+        end
+      end
+    end
+  end
+end

data/lib/amun/ui/echo_area.rb

@@ -1,25 +1,41 @@
-require 'curses'
+require 'amun/ui/buffer'
 
 module Amun
   module UI
     # a line that is rendered by default at the end on the screen
     # takes one line height and extends to take the whole width of screen
-    # should be linked to \*messages\* memory buffer and each time the #log
-    # is called it will display the message next time #render is called
+    # should be linked to \*messages\* memory buffer and display new messages
+    # in the buffer text
     class EchoArea
+      attr_writer :events
+
+      def events
+        @events ||= EventManager.new
+      end
+
       def initialize
-        @window = Curses::Window.new(1, Curses.cols, Curses.lines - 1, 0)
+        @last_messages_size = 0
       end
 
-      # display a *message* in the echo area
-      def echo(message)
-        @window << message
+      def trigger(event)
+        EventManager.join(event, events)
       end
 
       # render the echo area window
-      def refresh
-        @window.noutrefresh
-        @window.clear
+      def render(window)
+        window.clear
+        window << message
+        update_last_messages_size
+      end
+
+      private
+
+      def message
+        Buffer.messages.text[@last_messages_size..-1]
+      end
+
+      def update_last_messages_size
+        @last_messages_size = Buffer.messages.text.size
       end
     end
   end

data/lib/amun/ui/mode_line.rb

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

data/lib/amun/ui/mode_line_segments/buffer_name.rb

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

data/lib/amun/ui/mode_line_segments/major_mode.rb

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

data/lib/amun/ui/windows/buffer_window.rb

@@ -0,0 +1,40 @@
+require 'amun/ui/buffer'
+
+module Amun
+  module UI
+    module Windows
+      # a window to display any buffer
+      # or the current buffer
+      class BufferWindow
+        def initialize(buffer = nil)
+          @buffer = 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
+
+        # render buffer
+        def render(window)
+          buffer.render(window)
+        end
+
+        # trigger the event in buffer
+        def trigger(event)
+          buffer.trigger(event)
+        end
+      end
+    end
+  end
+end

data/lib/amun/ui/windows/frame.rb

@@ -0,0 +1,75 @@
+require 'curses'
+require 'amun/event_manager'
+require 'amun/ui/windows/buffer_window'
+require 'amun/ui/echo_area'
+
+module Amun
+  module UI
+    module Windows
+      # a Frame fills all the space in terminal
+      # renders an echo area and an object that
+      # respond to #render and #trigger, like buffer,
+      # or another window or so
+      class Frame
+        attr_writer :screen, :echo_area, :window
+
+        def window
+          @window ||= BufferWindow.new
+        end
+
+        def echo_area
+          @echo_area ||= EchoArea.new
+        end
+
+        def trigger(event)
+          EventManager.join(event, echo_area, window, EventManager)
+        rescue StandardError => e
+          handle_exception(e)
+        ensure
+          render
+        end
+
+        def render
+          render_content
+          render_echo_area
+        end
+
+        private
+
+        def screen
+          @screen ||= Curses.stdscr
+        end
+
+        def content_window
+          @content_window ||= screen.subwin(screen.maxy - 1, screen.maxx, 0, 0)
+        end
+
+        def echo_window
+          @echo_window ||= screen.subwin(1, screen.maxx, screen.maxy - 1, 0)
+        end
+
+        def render_content
+          begin
+            window.render(content_window)
+          rescue StandardError => e
+            handle_exception(e)
+          end
+          content_window.refresh
+        end
+
+        def render_echo_area
+          begin
+            echo_area.render(echo_window)
+          rescue StandardError => e
+            handle_exception(e)
+          end
+          echo_window.refresh
+        end
+
+        def handle_exception(e)
+          Buffer.messages.text << "#{e.message} (#{e.backtrace.first})\n"
+        end
+      end
+    end
+  end
+end

data/lib/amun/version.rb

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

data/lib/amun.rb

@@ -1,65 +1,6 @@
 require 'amun/version'
-require 'amun/event_manager'
-require 'amun/ui/echo_area'
-require 'curses'
+require 'amun/application'
 
+# King of the gods and god of the wind
 module Amun
-  module_function
-
-  class Application
-    attr_accessor :keyboard, :events, :echo_area
-
-    def self.instance
-      @instance ||= new
-    end
-
-    def quit(_event)
-      exit 0
-    end
-
-    def write_char(char)
-      screen.addstr(char.to_s)
-    end
-
-    def run
-      init_curses
-      init_ui
-
-      echo_area.echo 'Press ESC to exit.'
-
-      Thread.new do
-        while ch = screen.get_char
-          keyboard.trigger(ch)
-          echo_area.refresh
-        end
-      end.join
-    end
-
-    def screen
-      @screen ||= Curses.stdscr
-    end
-
-    private
-
-    def initialize(keyboard = EventManager.new, events: EventManager.new)
-      self.keyboard = keyboard
-      self.events = events
-
-      keyboard.bind "\e", self, :quit
-      keyboard.bind_all self, :write_char
-    end
-
-    def init_curses
-      Curses.init_screen
-      Curses.raw
-      Curses.noecho
-      Curses.start_color
-      Curses.stdscr.keypad(true)
-      Curses.ESCDELAY = 0
-    end
-
-    def init_ui
-      self.echo_area = Amun::UI::EchoArea.new
-    end
-  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: amun
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - Emad Elsaid
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-12 00:00:00.000000000 Z
+date: 2017-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: curses
@@ -108,6 +108,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
 description: A CLI editor built to have an Emacs similar development environment,
   with ruby in the heart of it instead of Elisp, that will make developing plugins
   and extensions faster and more enjoyable, this editor is kept to the minimum, anything
@@ -120,6 +148,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - ".ruby-version"
 - ".travis.yml"
 - Gemfile
@@ -129,12 +158,24 @@ files:
 - Rakefile
 - amun.gemspec
 - bin/console
-- bin/setup
 - exe/amun
 - lib/amun.rb
+- lib/amun/application.rb
+- lib/amun/behaviours/emacs.rb
 - lib/amun/event_manager.rb
+- lib/amun/features/echo_event.rb
+- lib/amun/features/quit.rb
+- lib/amun/features_loader.rb
 - lib/amun/helpers/colors.rb
+- lib/amun/helpers/keyboard.rb
+- lib/amun/major_modes/fundamental.rb
+- lib/amun/ui/buffer.rb
 - lib/amun/ui/echo_area.rb
+- lib/amun/ui/mode_line.rb
+- lib/amun/ui/mode_line_segments/buffer_name.rb
+- lib/amun/ui/mode_line_segments/major_mode.rb
+- lib/amun/ui/windows/buffer_window.rb
+- lib/amun/ui/windows/frame.rb
 - lib/amun/version.rb
 homepage: http://www.github.com/blazeeboy/amun
 licenses:

data/bin/setup

@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-set -euo pipefail
-IFS=$'\n\t'
-set -vx
-
-bundle install