editor_core 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 368d94707fe992bf22535129bce424ae0dc6a88bc08a2a95fc61e316e3bf1951
-  data.tar.gz: ea02c89dd36ac8a9c8cc67846930d6bfb16af72a1af6f6ab8cb36e5ab9b55c00
+  metadata.gz: ec52d9db82e48638cbc82762edbfc019f825beda5eafa66475f18254c69e1f4e
+  data.tar.gz: 354a5ae6fb35b9bb195df0ace5c579a1643b61dbd0e8449ce7428c62b9fefd98
 SHA512:
-  metadata.gz: 9b8c159f7083783f53a5dc4ed149ff30998296da4b33a1dc3a86b733294f1a0fdbae1d2b7c6c8bbdf63744b38fe627b2d256117a34dac67b5796bb3d60558cd6
-  data.tar.gz: 2c66bb04281d89ef2b144b1fa5f08bcaa3add598db1cf833a635d8e32686687d224ee9ab0418fb3ceeaca7598ee1ba3a04625b59fd5b300e5354b3b6101522dd
+  metadata.gz: 1d65ef8b4ca8ca3138a67e0684bd3f315569423d715fc6fff022edb2d1c3b717db1efedfb4892711992107056c9afe29e30114beef2fb7c4d3c5350ea3ea8ba1
+  data.tar.gz: 483e3d2feb7dda1c78b5634612b92eb3f946c86921ae7898a81a3c73b665fd2d26c1edac0a724faed232b4ee190fcc1c3a1f37f72e979862132c95c400262775

data/.gitignore

@@ -6,6 +6,7 @@
 /pkg/
 /spec/reports/
 /tmp/
+*~
 
 # rspec failure tracking
 .rspec_status

data/README.md

@@ -1,8 +1,8 @@
 # EditorCore
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/editor_core`. To experiment with that code, run `bin/console` for an interactive prompt.
+Very basic core concepts for an editor. Used in the next iteration of
+[Re](https://github.com/vidarh/re)
 
-TODO: Delete this and the text above, and describe your gem
 
 ## Installation
 
@@ -32,7 +32,8 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/editor_core.
+Bug reports and pull requests are welcome on GitHub at
+https://github.com/vidarh/editor_core.
 
 
 ## License

data/lib/editor_core/buffer.rb

@@ -0,0 +1,133 @@
+require 'drb/observer'
+require 'date'
+
+require_relative 'history'
+
+module EditorCore
+  class Buffer
+
+    include DRb::DRbObservable
+
+    attr_reader :name, :created_at, :history
+    attr_accessor :buffer_id
+    attr_writer :created_at
+
+    def initialize(id,name, lines, created_at = 0)
+      @buffer_id   = id  # An id for this buffer unique for this session
+      @name = name
+      @history = History.new
+      @lines   = lines
+      @created_at = case created_at
+        when Numeric
+          Time.at(created_at)
+        when Time
+          created_at
+        when String
+          DateTime.parse(created_at)
+        else
+          raise "Unknown time format: #{created_at}"
+      end
+    end
+
+    def as_json(options = { })
+      {
+        "json_class" => self.class.name,
+        "data" => {
+          "id"    => @buffer_id,
+          "name"  => @name,
+          "lines" => @lines,
+          "created_at" => Time.at(created_at.to_i)
+        }
+      }
+    end
+
+    def to_json(*a)
+      as_json.to_json(*a)
+    end
+
+    def self.json_create(o)
+      d = o["data"]
+      new(d["id"], d["name"], d["lines"], (d["created_at"] || d["modified_at"] || 0))
+    end
+
+    def lines_count
+      @lines.size
+    end
+
+    def line_length(row)
+      @lines[row]&.size || 0
+    end
+
+    def replace_contents(cursor,new_contents)
+      modify(cursor, 0..-1) {|l| new_contents }
+    end
+
+    def insert(cursor, char)
+      modify(cursor, cursor.row) {|l| l.insert(cursor.col,char) }
+    end
+
+    def delete(cursor, from, to =nil)
+      to ||= from
+      modify(cursor, cursor.row) {|l| l[from..to] = ''; l }
+    end
+
+    def break_line(cursor)
+      modify(cursor, cursor.row..cursor.row) do |l|
+        [l[0][0...cursor.col], l[0][cursor.col..-1]]
+      end
+    end
+
+    def join_lines(cursor,offset=0)
+      row=cursor.row+offset
+      modify(cursor, row..row+1) {|l| l.join }
+    end
+
+    def indent(cursor, row, pos)
+      modify(cursor,row) do |line|
+        (" "*pos)+line.lstrip
+      end
+    end
+
+    def lines(r)
+      @lines[r]
+    end
+
+    def can_undo?
+      @history.can_undo?
+    end
+
+    def can_redo?
+      @history.can_redo?
+    end
+
+    def undo(old_cursor)
+      cursor, rowrange, rows = @history.undo_snapshot
+      store_snapshot(old_cursor,rowrange, false)
+      cursor, rowrange, rows = @history.undo
+      @lines[rowrange] = rows
+      cursor
+    end
+
+    def redo
+      cursor, rowrange, rows = @history.redo
+      @lines[rowrange] = rows
+      cursor
+    end
+
+    private
+
+    def store_snapshot(cursor, rowrange, advance = true)
+      @history.save([cursor, rowrange, @lines[rowrange]], advance)
+    end
+
+    def modify(cursor, rowrange)
+      lines = @lines[rowrange].dup
+      lines ||= ""
+      new_lines = yield(lines)
+      store_snapshot(cursor, rowrange, true)
+      @lines[rowrange] = new_lines
+      changed
+      notify_observers(self)
+    end
+  end
+end

data/lib/editor_core/core.rb

@@ -0,0 +1,189 @@
+#
+# # Core
+#
+# Generic editor functionality that only depends on `Buffer`, `Cursor`
+# and bare minimum of `View`
+#
+# Functionality that goes here should *only* be "objective" behaviours.
+# E.g. what it means to move a cursor to the right is mostly objective.
+# What should happen on enter probably isn't (may or may not include
+# indenting the next line, may or may not involve stripping trailing
+# whitespace, etc.). Methods for the objective, constituent parts of
+# subjective/opinionated operations *can* be added here (e.g. an "enter"
+# method which defers the subjective parts to a block or some hook
+# mechanism could.
+#
+# Knows nothing of configuration or "fancier" options, which should
+# generally be handled in a subclass
+#
+# `@view` must support `#top`/`#top=` and `#height` to control the
+# viewable portion.
+#
+module EditorCore
+  class Core
+    attr_accessor :cursor, :buffer, :view
+
+    # ## Basic cursor movement ##
+
+    def move(row, col); @cursor = cursor.move(buffer, row.to_i, col.to_i) end
+    def right(off=1);   @cursor = cursor.right(buffer,off.to_i) end
+    def left(off=1);    @cursor = cursor.left(buffer,off.to_i) end
+    def up(off=1);      @cursor = cursor.up(buffer,off.to_i) end
+    def down(off=1);    @cursor = cursor.down(buffer,off.to_i) end
+
+    def line_home;      @cursor = cursor.line_home end
+    def line_end;       @cursor = cursor.line_end(buffer) end
+
+    # ## Querying ##
+
+    def current_line
+      @buffer.lines(cursor.row)
+    end
+
+    def get_after
+      @buffer.lines(cursor.row)[@cursor.col..-1]
+    end
+
+    ### View-relative cursor movement ##
+
+    def buffer_home
+      view_home
+      @cursor = cursor.move(buffer, 0, cursor.col)
+    end
+
+    def buffer_end
+      view_end
+      @cursor = cursor.move(buffer, buffer.lines_count, cursor.col)
+    end
+
+    def page_down
+      lines = view_down(view.height-1)
+      @cursor = cursor.down(buffer, lines)
+    end
+
+    def page_up
+      @cursor = cursor.up(buffer, view_up(view.height-1))
+    end
+
+    # View movement
+    def view_up(offset = 1)
+      oldtop = view.top
+      view.top -= offset
+      view.top = 0 if view.top < 0
+      oldtop - view.top
+    end
+
+    def view_down(offset = 1)
+      oldtop = view.top
+      view.top += offset
+      if view.top > buffer.lines_count
+        view.top = buffer.lines_count
+      end
+      view.top - oldtop
+    end
+
+    def view_home
+      view.top = 0
+    end
+
+    def view_end
+      view.top = buffer.lines_count - view.height
+    end
+
+    # ## Complex navigation ##
+    def next_word
+      line = current_line
+      c = cursor.col
+      m = line.length
+      while c<m && line[c]&.match(/[^a-zA-Z]/)
+        c += 1
+      end
+      if c >= m
+        # FIXME: Pathological cases can cause stack issue here.
+        @cursor = Cursor.new(cursor.row,m)
+        right
+        return next_word
+      end
+
+      if run = line[c..-1]&.match(/([a-zA-Z]+)/)
+        c += run[0].length
+        #pry([line,c,run])
+      end
+      off = c - cursor.col
+      right(off)
+      off
+    end
+
+
+    def prev_word
+      return if cursor.col == 0
+      line = current_line
+      c = cursor.col
+      if c > 0
+        c -= 1
+      end
+      while c > 0 && line[c] && line[c].match(/[ \t]/)
+        c -= 1
+      end
+      while c > 0 && !(line[c-1].match(/[ \t\-]/))
+        c -= 1
+      end
+      off = cursor.col - c
+      @cursor = Cursor.new(cursor.row, c)
+      off
+    end
+
+    # ## Mutation ##
+
+    def delete_before
+      buffer.delete(cursor, 0, cursor.col)
+      line_home
+    end
+
+    def delete_after
+      buffer.delete(cursor, cursor.col,-1)
+    end
+
+    def delete
+      return if cursor.end_of_file?(buffer)
+
+      if cursor.end_of_line?(buffer)
+        buffer.join_lines(cursor)
+      else
+        buffer.delete(cursor, cursor.col)
+      end
+    end
+
+    def join_line
+      buffer.join_lines(cursor)
+    end
+
+    def backspace
+      return if cursor.beginning_of_file?
+
+      if cursor.col == 0
+        cursor_left = buffer.lines(cursor.row).size + 1
+        buffer.join_lines(cursor,-1)
+        cursor_left.times { left }
+      else
+        buffer.delete(cursor, cursor.col - 1)
+        left
+      end
+    end
+
+
+    def rstrip_line
+      line = current_line
+      stripped = current_line.rstrip
+      return if line.length == stripped.length
+      col = cursor.col
+      oldc = cursor
+      move(cursor.row, stripped.length)
+      delete_after
+      if col < stripped.length
+        @cursor = oldc
+      end
+    end
+
+  end
+end

data/lib/editor_core/cursor.rb

@@ -0,0 +1,72 @@
+
+module EditorCore
+  class Cursor
+    attr_reader :row, :col
+
+    def initialize(row = 0, col = 0)
+      @row = row
+      @col = col
+      freeze
+    end
+
+    def move(buffer,row,col); self.class.new(row,col).clamp(buffer); end
+    def up(buffer,   offset = 1); move(buffer, row-offset,col); end
+    def down(buffer, offset = 1); move(buffer, row+offset,col); end
+
+    def left(buffer, offset = 1)
+      return Cursor.new(row, col - offset) if offset <= col
+      return self if beginning_of_file?
+      return move(buffer,row-1,buffer.line_length(row-1))
+    end
+
+    def right(buffer, offset = 1)
+      #buffer.right(self,offset)
+      return Cursor.new(row, col + offset).clamp(buffer) unless end_of_line?(buffer)
+      return self if final_line?(buffer)
+      Cursor.new(row + 1, 0)
+    end
+
+    def clamp(buffer)
+      row = @row.clamp(0, buffer.lines_count - 1)
+      # FIXME: Is this `buffer.lines` check needed? It ought not to be.
+      if !buffer.lines(row)
+        col = 0
+      else
+        col = @col.clamp(0, buffer.line_length(row))
+      end
+      Cursor.new(row,col)
+    end
+
+    def enter(buffer)
+      down(buffer).line_home
+    end
+
+    def line_home
+      Cursor.new(row, 0)
+    end
+
+    def line_end(buffer)
+      Cursor.new(row, buffer.line_length(row))
+    end
+
+    def end_of_line?(buffer)
+      if buffer.lines(row)
+        col == buffer.line_length(row)
+      else
+        true
+      end
+    end
+
+    def final_line?(buffer)
+      row == buffer.lines_count - 1
+    end
+
+    def end_of_file?(buffer)
+      final_line?(buffer) && end_of_line?(buffer)
+    end
+
+    def beginning_of_file?
+      row == 0 && col == 0
+    end
+  end
+end

data/lib/editor_core/history.rb

@@ -0,0 +1,42 @@
+
+module EditorCore
+class History
+  def initialize
+    @snapshots = []
+    @current = -1
+  end
+
+  def save(data, advance = true)
+    snapshots[@current+1] = data
+    @current += 1 if advance
+  end
+
+  def can_undo?
+    !undo_snapshot.nil?
+  end
+
+  def undo
+    undo_snapshot.tap { @current -= 1 }
+  end
+
+  def can_redo?
+    !redo_snapshot.nil?
+  end
+
+  def redo
+    redo_snapshot.tap { @current += 1 }
+  end
+
+  def undo_snapshot
+    snapshots[current] if current >= 0
+  end
+
+  private
+
+  attr_reader :snapshots, :current
+
+  def redo_snapshot
+    snapshots[current + 2]
+  end
+end
+end

data/lib/editor_core/version.rb

@@ -1,3 +1,3 @@
 module EditorCore
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: editor_core
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Vidar Hokstad
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2021-11-25 00:00:00.000000000 Z
+date: 2021-11-26 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -28,6 +28,10 @@ files:
 - bin/setup
 - editor_core.gemspec
 - lib/editor_core.rb
+- lib/editor_core/buffer.rb
+- lib/editor_core/core.rb
+- lib/editor_core/cursor.rb
+- lib/editor_core/history.rb
 - lib/editor_core/version.rb
 homepage: https://github.com/vidarh/editor_core
 licenses: