text_editor 0.0.0

data/spec/text_editor/buffer_spec.rb

@@ -0,0 +1,181 @@
+require "spec_helper"
+
+RSpec.describe TextEditor::Buffer do
+  subject { described_class.new(lines) }
+
+  let(:lines) { %w(one two) }
+
+  describe "#delete_char" do
+    it "deletes char at line and column" do
+      actual = subject.delete_char(0, 0)
+      expect(actual.to_s).to eq("ne\ntwo")
+
+      actual = subject.delete_char(0, 1)
+      expect(actual.to_s).to eq("oe\ntwo")
+
+      actual = subject.delete_char(1, 0)
+      expect(actual.to_s).to eq("one\nwo")
+
+      actual = subject.delete_char(1, 1)
+      expect(actual.to_s).to eq("one\nto")
+    end
+
+    it "ignores columns out of bounds" do
+      actual = subject.delete_char(0, 10)
+      expect(actual.to_s).to eq("one\ntwo")
+    end
+
+    it "raises IndexError when line is out of bounds" do
+      expect { subject.delete_char(10, 0) }.to raise_error(IndexError)
+    end
+  end
+
+  describe "#delete_line" do
+    it "deletes line at index" do
+      actual = subject.delete_line(0)
+      expect(actual.to_s).to eq("two")
+
+      actual = subject.delete_line(1)
+      expect(actual.to_s).to eq("one")
+    end
+
+    it "ignores out of bound indexes" do
+      actual = subject.delete_line(3)
+      expect(actual.to_s).to eq("one\ntwo")
+    end
+
+    it "does not mutate the original buffer" do
+      subject.delete_line(0)
+      expect(subject.to_s).to eq("one\ntwo")
+    end
+  end
+
+  describe "#each_line" do
+    it "delegates to lines" do
+      expect(lines).to receive(:each)
+      subject.each_line { |line| line }
+    end
+  end
+
+  describe "#insert_char" do
+    it "inserts char at index" do
+      actual = subject.insert_char(0, 0, "x")
+      expect(actual.to_s).to eq("xone\ntwo")
+
+      actual = subject.insert_char(0, 1, "x")
+      expect(actual.to_s).to eq("oxne\ntwo")
+
+      actual = subject.insert_char(1, 0, "x")
+      expect(actual.to_s).to eq("one\nxtwo")
+
+      actual = subject.insert_char(1, 1, "x")
+      expect(actual.to_s).to eq("one\ntxwo")
+    end
+
+    it "raises IndexError when line is out of bounds" do
+      expect { subject.insert_char(10, 0, "x") }.to raise_error(IndexError)
+    end
+
+    it "raises IndexError when column is out of bounds" do
+      expect { subject.insert_char(0, 10, "x") }.to raise_error(IndexError)
+    end
+  end
+
+  describe "#insert_line" do
+    it "inserts line at index" do
+      actual = subject.insert_line(0)
+      expect(actual.to_s).to eq("\none\ntwo")
+
+      actual = subject.insert_line(1)
+      expect(actual.to_s).to eq("one\n\ntwo")
+
+      actual = subject.insert_line(2)
+      expect(actual.to_s).to eq("one\ntwo\n")
+    end
+
+    it "optionally accepts content" do
+      actual = subject.insert_line(1, "test")
+      expect(actual.to_s).to eq("one\ntest\ntwo")
+    end
+
+    it "inserts at tail when index is out of bounds" do
+      actual = subject.insert_line(5)
+      expect(actual.to_s).to eq("one\ntwo\n")
+    end
+  end
+
+  describe "#line" do
+    it "returns line by index" do
+      actual = subject.line(0)
+      expect(actual).to eq("one")
+
+      actual = subject.line(1)
+      expect(actual).to eq("two")
+    end
+
+    it "returns empty string otherwise" do
+      actual = subject.line(2)
+      expect(actual).to eq("")
+    end
+
+    it "returns a copy of the line" do
+      first_id = subject.line(0).object_id
+      second_id = subject.line(0).object_id
+      expect(first_id).not_to eq(second_id)
+    end
+  end
+
+  context "#replace_char" do
+    it "replace char at index" do
+      actual = subject.replace_char(0, 0, "x")
+      expect(actual.to_s).to eq("xne\ntwo")
+
+      actual = subject.replace_char(0, 1, "x")
+      expect(actual.to_s).to eq("oxe\ntwo")
+
+      actual = subject.replace_char(1, 0, "x")
+      expect(actual.to_s).to eq("one\nxwo")
+
+      actual = subject.replace_char(1, 1, "x")
+      expect(actual.to_s).to eq("one\ntxo")
+    end
+
+    it "raises IndexError when line is out of bounds" do
+      expect { subject.replace_char(10, 0, "x") }.to raise_error(IndexError)
+    end
+
+    it "raises IndexError when column is out of bounds" do
+      expect { subject.replace_char(0, 10, "x") }.to raise_error(IndexError)
+    end
+  end
+
+  context "#replace_line" do
+    it "replaces line at index" do
+      actual = subject.replace_line(0, "test")
+      expect(actual.to_s).to eq("test\ntwo")
+
+      actual = subject.replace_line(1, "test")
+      expect(actual.to_s).to eq("one\ntest")
+    end
+
+    it "replaces line with empty string by default" do
+      actual = subject.replace_line(0)
+      expect(actual.to_s).to eq("\ntwo")
+    end
+
+    it "raises IndexError when line is out of bounds" do
+      expect { subject.replace_line(10, "test") }.to raise_error(IndexError)
+    end
+  end
+
+  describe "#to_s" do
+    it "joins lines with a newline" do
+      expect(subject.to_s).to eq("one\ntwo")
+    end
+
+    it "returns an empty string if lines are empty" do
+      lines.clear
+      expect(subject.to_s).to eq("")
+    end
+  end
+end

data/spec/text_editor/clipboard_spec.rb

@@ -0,0 +1,28 @@
+require "spec_helper"
+
+RSpec.describe TextEditor::Clipboard do
+  subject { described_class.new(editor) }
+
+  let(:editor) { double("editor") }
+
+  describe "#clear" do
+    it "delegates to adapter.clear" do
+      expect(subject).to receive_message_chain(:adapter, :clear)
+      subject.clear
+    end
+  end
+
+  describe "#copy" do
+    it "delegates to adapter.copy" do
+      expect(subject).to receive_message_chain(:adapter, :copy)
+      subject.copy
+    end
+  end
+
+  describe "#paste" do
+    it "delegates to adapter.paste" do
+      expect(subject).to receive_message_chain(:adapter, :paste)
+      subject.paste
+    end
+  end
+end

data/spec/text_editor/command/quit_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+
+RSpec.describe TextEditor::Command::Quit do
+  subject { described_class.new(editor) }
+
+  let(:editor) { double("editor") }
+
+  describe "#run" do
+    it "delegates to editor.reactor.stop" do
+      expect(subject).to receive_message_chain(:editor, :reactor, :stop)
+      subject.run
+    end
+  end
+end

data/spec/text_editor/command/resolver_spec.rb

@@ -0,0 +1,56 @@
+require "spec_helper"
+
+RSpec.describe TextEditor::Command::Resolver do
+  subject { described_class.new(editor) }
+
+  let(:editor) { double("editor") }
+  let(:fake) { Class.new(namespace) }
+  let(:namespace) { TextEditor::Command }
+
+  before { namespace.const_set(:FakeCommand, fake) }
+  after { namespace.send(:remove_const, :FakeCommand) }
+
+  describe "#method_missing" do
+    it "runs a command instance" do
+      expect { subject.fake_command }.to raise_error(NotImplementedError)
+    end
+
+    it "returns self" do
+      fake.send(:define_method, :run) { true }
+      expect(subject.fake_command).to eq(subject)
+    end
+
+    it "raises NoMethodError for invalid commands" do
+      expect { subject.invalid_command }.to raise_error(NoMethodError)
+      expect { subject.invalid_command! }.to raise_error(NoMethodError)
+      expect { subject.invalid_command? }.to raise_error(NoMethodError)
+    end
+  end
+
+  describe "#resolve" do
+    it "finds existing string commands" do
+      actual = subject.resolve("fake_command")
+      expect(actual).to be_a(fake)
+    end
+
+    it "finds existing symbol commands" do
+      actual = subject.resolve(:fake_command)
+      expect(actual).to be_a(fake)
+    end
+
+    it "returns nil for missing commands" do
+      actual = subject.resolve(:invalid)
+      expect(actual).to be_nil
+    end
+  end
+
+  describe "#respond_to?" do
+    it "only returns true for defined commands" do
+      actual = subject.respond_to?(:fake_command)
+      expect(actual).to eq(true)
+
+      actual = subject.respond_to?(:invalid_command)
+      expect(actual).to eq(false)
+    end
+  end
+end

data/spec/text_editor/command_spec.rb

@@ -0,0 +1,85 @@
+require "spec_helper"
+
+RSpec.describe TextEditor::Command do
+  subject { described_class.new(editor) }
+
+  let(:editor) { double("editor") }
+
+  describe ".call" do
+    it "delegates to new instance" do
+      args = [1, 2, 3]
+      block = proc { true }
+      command = double("command")
+      expect(command).to receive(:run).with(*args, &block)
+      expect(described_class).to receive(:new).with(editor).and_return(command)
+      described_class.call(editor, *args, &block)
+    end
+  end
+
+  describe "#buffer" do
+    it "delegates to editor.window" do
+      expect(editor).to receive_message_chain(:window, :buffer)
+      subject.buffer
+    end
+  end
+
+  describe "#column" do
+    it "delegates to editor.window.cursor" do
+      expect(editor).to receive_message_chain(:window, :cursor, :column)
+      subject.column
+    end
+  end
+
+  describe "#command" do
+    let(:resolver) { described_class::Resolver }
+
+    it "returns a command resolver" do
+      expect(subject.command).to be_a(resolver)
+    end
+  end
+
+  describe "#content" do
+    it "returns buffer content for the current line" do
+      line = "test"
+      buffer = double("buffer")
+      expect(buffer).to receive(:line).with(line)
+      expect(subject).to receive(:line).and_return(line)
+      expect(subject).to receive(:buffer).and_return(buffer)
+      subject.content
+    end
+  end
+
+  describe "#cursor" do
+    it "delegates to editor.window" do
+      expect(editor).to receive_message_chain(:window, :cursor)
+      subject.cursor
+    end
+  end
+
+  describe "#line" do
+    it "delegates to editor.window.line" do
+      expect(editor).to receive_message_chain(:window, :cursor, :line)
+      subject.line
+    end
+  end
+
+  describe "#run" do
+    it "must be implemented" do
+      expect { subject.run }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe "#state" do
+    it "delegates to editor.window" do
+      expect(editor).to receive_message_chain(:window, :state)
+      subject.state
+    end
+  end
+
+  describe "#window" do
+    it "delegates to editor" do
+      expect(editor).to receive(:window)
+      subject.window
+    end
+  end
+end

data/spec/text_editor/component_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+RSpec.describe TextEditor::Component do
+  subject { constant.new(editor) }
+
+  let(:editor) { double("editor") }
+
+  let(:constant) do
+    Class.new.instance_exec(described_class) do |mod|
+      include mod
+    end
+  end
+
+  describe "#config" do
+    it "delegates to editor.config" do
+      expect(subject).to receive_message_chain(:editor, :config)
+      subject.config
+    end
+  end
+
+  describe "#editor" do
+    it "returns initialized editor" do
+      expect(subject.editor).to eq(editor)
+    end
+  end
+
+  describe "#logger" do
+    it "delegates to editor.logger" do
+      expect(subject).to receive_message_chain(:editor, :logger)
+      subject.logger
+    end
+  end
+
+  describe "#terminal" do
+    it "delegates to editor.terminal" do
+      expect(subject).to receive_message_chain(:editor, :terminal)
+      subject.terminal
+    end
+  end
+end

data/spec/text_editor/configuration_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+RSpec.describe TextEditor::Configuration do
+  subject { described_class.new(editor) }
+
+  let(:editor) { double("editor") }
+
+  describe "#files" do
+    it "is an accessor" do
+      expect(subject.files).to be_nil
+
+      subject.files = "test"
+      expect(subject.files).to eq("test")
+    end
+  end
+
+  describe "#log" do
+    it "is an accessor" do
+      expect(subject.log).to be_nil
+
+      subject.log = "test"
+      expect(subject.log).to eq("test")
+    end
+  end
+end

data/spec/text_editor/cursor_spec.rb

@@ -0,0 +1,93 @@
+require "spec_helper"
+
+RSpec.describe TextEditor::Cursor do
+  subject { described_class.new(line, column) }
+
+  let(:line) { 1 }
+  let(:column) { 2 }
+
+  describe "#column" do
+    it "returns current column" do
+      expect(subject.column).to eq(2)
+    end
+  end
+
+  describe "#down" do
+    it "moves cursor down" do
+      actual = subject.down
+      expect(actual.position).to eq([2, 2])
+
+      actual = subject.down(2)
+      expect(actual.position).to eq([3, 2])
+    end
+  end
+
+  describe "#initialize" do
+    it "sets line and column to 0 by default" do
+      expect(described_class.new.position).to eq([0, 0])
+    end
+  end
+
+  describe "#left" do
+    it "moves cursor left" do
+      actual = subject.left
+      expect(actual.position).to eq([1, 1])
+
+      actual = subject.left(2)
+      expect(actual.position).to eq([1, 0])
+
+      actual = subject.left(3)
+      expect(actual.position).to eq([1, 0])
+    end
+  end
+
+  describe "#line" do
+    it "returns current line" do
+      expect(subject.line).to eq(1)
+    end
+  end
+
+  describe "#move" do
+    it "moves cursor" do
+      actual = subject.move(4, 5)
+      expect(actual.position).to eq([4, 5])
+    end
+
+    it "does not allow negative values" do
+      actual = subject.move(-4, 5)
+      expect(actual.position).to eq([0, 5])
+
+      actual = subject.move(5, -4)
+      expect(actual.position).to eq([5, 0])
+    end
+  end
+
+  describe "#position" do
+    let(:line) { 1 }
+    let(:column) { 2 }
+
+    it "returns an array with the line and column" do
+      expect(subject.position).to eq([1, 2])
+    end
+  end
+
+  describe "#right" do
+    it "moves cursor right" do
+      actual = subject.right
+      expect(actual.position).to eq([1, 3])
+
+      actual = subject.right(2)
+      expect(actual.position).to eq([1, 4])
+    end
+  end
+
+  describe "#up" do
+    it "moves cursor up" do
+      actual = subject.up
+      expect(actual.position).to eq([0, 2])
+
+      actual = subject.up(2)
+      expect(actual.position).to eq([0, 2])
+    end
+  end
+end

data/spec/text_editor/operating_system_spec.rb

@@ -0,0 +1,55 @@
+require "spec_helper"
+
+RSpec.describe TextEditor::OperatingSystem do
+  subject { described_class.new(version) }
+
+  describe "#type" do
+    context "cygwin" do
+      let(:version) { "some-cygwin-version" }
+
+      it "parses correct type" do
+        expect(subject.type).to eq(:Cygwin)
+      end
+    end
+
+    context "linux" do
+      let(:version) { "i686-linux" }
+
+      it "parses correct type" do
+        expect(subject.type).to eq(:Linux)
+      end
+    end
+
+    context "mac" do
+      let(:version) { "x86_64-darwin14" }
+
+      it "parses correct type" do
+        expect(subject.type).to eq(:Mac)
+      end
+    end
+
+    context "unknown" do
+      let(:version) { "some-other-version" }
+
+      it "parses correct type" do
+        expect(subject.type).to eq(:Unknown)
+      end
+    end
+
+    context "windows" do
+      let(:version) { "some-mswin-version" }
+
+      it "parses correct type" do
+        expect(subject.type).to eq(:Windows)
+      end
+    end
+  end
+
+  describe "#version" do
+    let(:version) { "example" }
+
+    it "returns initialized version" do
+      expect(subject.version).to eq(version)
+    end
+  end
+end

data/spec/text_editor/reactor_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+RSpec.describe TextEditor::Reactor do
+  subject { described_class.new(editor) }
+
+  let(:editor) { double("editor") }
+
+  describe "#start" do
+    it "starts running" do
+      expect(subject).to receive(:render)
+      expect(subject).to receive(:listen)
+
+      expect(subject).not_to be_running
+      subject.start
+      expect(subject).to be_running
+    end
+  end
+
+  describe "#stop" do
+    it "stops running" do
+      subject.instance_variable_set("@running", true)
+      expect(subject).to be_running
+
+      subject.stop
+      expect(subject).not_to be_running
+    end
+  end
+
+  describe "#running?" do
+    it "is not running by default" do
+      expect(subject).not_to be_running
+    end
+  end
+end

data/spec/text_editor/state_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+RSpec.describe TextEditor::State do
+  subject { described_class.new(buffer, cursor) }
+
+  let(:buffer) { double("buffer") }
+  let(:cursor) { double("cursor") }
+
+  describe "#buffer" do
+    it "returns initialized buffer" do
+      expect(subject.buffer).to eq(buffer)
+    end
+  end
+
+  describe "#cursor" do
+    it "returns initialized cursor" do
+      expect(subject.cursor).to eq(cursor)
+    end
+  end
+end

data/text_editor.gemspec

@@ -0,0 +1,18 @@
+Gem::Specification.new do |s|
+  s.authors               = "Sean Huber"
+  s.email                 = "sean@shuber.io"
+  s.extra_rdoc_files      = %w(LICENSE)
+  s.files                 = `git ls-files`.split("\n")
+  s.homepage              = "https://github.com/shuber/text_editor"
+  s.license               = "MIT"
+  s.name                  = "text_editor"
+  s.required_ruby_version = ">= 2.0.0"
+  s.rdoc_options          = %w(--charset=UTF-8 --inline-source --line-numbers --main README.org)
+  s.summary               = "Text editor"
+  s.test_files            = `git ls-files -- spec/*`.split("\n")
+  s.version               = "0.0.0"
+
+  s.executables << "te"
+
+  s.add_dependency "curses", "1.0.2"
+end