ellipses 0.0.0

data/lib/ellipses/client/commands/reject.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ellipses
+  module Client
+    module Commands
+      class Reject < Command
+        command 'reject', argc: 1
+
+        include Command::Mixins::SetupPattern
+
+        def call(input)
+          input.grep_v param.pattern
+        end
+      end
+    end
+  end
+end

data/lib/ellipses/client/commands/select.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ellipses
+  module Client
+    module Commands
+      class Select < Command
+        command 'select', argc: 1
+
+        include Command::Mixins::SetupPattern
+
+        def call(input)
+          input.grep param.pattern
+        end
+      end
+    end
+  end
+end

data/lib/ellipses/client/commands/substitute.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Ellipses
+  module Client
+    module Commands
+      class Substitute < Command
+        command 'sub', argc: 2
+
+        include Command::Mixins::SetupPattern
+
+        def setup
+          super
+
+          param.replace = argv.last
+        end
+
+        def call(input)
+          input.map { |line| line.gsub param.pattern, param.replace }
+        end
+      end
+    end
+  end
+end

data/lib/ellipses/client/commands/translate.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ellipses
+  module Client
+    module Commands
+      class Translate < Command
+        command 'tr', argc: 2
+
+        def call(input)
+          input.map { |line| line.tr(*argv) }
+        end
+      end
+    end
+  end
+end

data/lib/ellipses/client/config.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Ellipses
+  module Client
+    class Config
+      extend Forwardable
+
+      def_delegators :@config, *%i[paths]
+
+      def initialize(**options)
+        @config = build OpenStruct.new(options.compact)
+      end
+
+      private
+
+      def default_paths
+        environment = %w[ELLIPSES_PATH SRCPATH].find { |env| ENV.key? env }
+        paths       = environment ? ENV[environment].split(':') : []
+
+        ['.', *paths]
+      end
+
+      def build(config)
+        config.paths = default_paths if !config.paths || config.paths.empty?
+        config.paths.compact!
+
+        config
+      end
+    end
+  end
+end

data/lib/ellipses/client/directive.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Ellipses
+  module Client
+    class Directive
+      Error = Class.new Error
+
+      attr_reader :commands, :server
+
+      def initialize(lexemes, server)
+        @server   = server
+        @commands = build(lexemes)
+      end
+
+      def execute(**kwargs)
+        output = []
+        commands.each do |command|
+          output = command.call(input = output, **kwargs) || input
+        end
+        output
+      end
+
+      private
+
+      def build(lexemes)
+        lexemes.map do |lexeme|
+          name = lexeme.token
+
+          raise Error, "No such command available: #{name}" unless Commands.available?(name)
+
+          proto = Commands.proto(name)
+          raise Error, "Wrong number of arguments: #{lexeme.argv}" unless proto.valid?(lexeme.argv)
+
+          proto.klass.new(lexeme.argv, server)
+        end
+      end
+    end
+  end
+end

data/lib/ellipses/client/error.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Ellipses
+  module Client
+    Error = Class.new Ellipses::Error
+
+    AmbiguousError = Class.new Error
+    UnfoundError   = Class.new Error
+  end
+end

data/lib/ellipses/client/lines.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module Ellipses
+  module Client
+    class Lines < SimpleDelegator
+      Surround = Struct.new :before, :after, keyword_init: true do
+        def range(i)
+          Range.new(i - before, i + after)
+        end
+
+        def center
+          before
+        end
+
+        def sensible?(i)
+          before <= i || after >= i
+        end
+
+        def sensible!(i)
+          return true if sensible?(i)
+
+          raise ArgumentError, "Insensible index #{i} for surround: #{before}, #{after}"
+        end
+
+        def length
+          @length ||= before + after + 1
+        end
+      end
+
+      private_constant :Surround
+
+      class Chunk
+        attr_reader :content, :center, :origin
+
+        def initialize(content, center:, origin:)
+          @content = content
+          @center  = center
+          @origin  = origin
+
+          raise ArgumentError, "Invalid center of array: #{center}" unless center < content.length
+        end
+
+        def insertion
+          @insertion ||= Meta::Insertion.new before:    center,
+                                             after:     content.length - center - 1,
+                                             signature: content[center],
+                                             digest:    Support.digest(*content)
+        end
+
+        def size
+          content.size
+        end
+
+        def origin_range
+          (origin...(origin + size))
+        end
+
+        def to_a
+          content
+        end
+      end
+
+      private_constant :Chunk
+
+      def initialize(array_of_lines)
+        super
+
+        @delegate_sd_obj = array_of_lines
+      end
+
+      def surrounding_chunk(i, before: 0, after: 0)
+        return unless i < length
+
+        range = (surround = Surround.new(before: before, after: after)).range(i)
+        Chunk.new self[range], center: surround.center, origin: range.begin
+      end
+
+      def insertion_by_surround(i, before: 0, after: 0)
+        return unless i < length
+
+        signature = self[i]
+        digest    = Support.digest(*self[Surround.new(before: before, after: after).range(i)])
+
+        Meta::Insertion.new before: before, after: after, signature: signature, digest: digest
+      end
+
+      def insertion_by_entropy
+        return if empty?
+
+        signature = self[center = index_of_maximum_entropy]
+        before    = center
+        after     = length - center - 1
+        digest    = Support.digest(*self)
+
+        Meta::Insertion.new before: before, after: after, signature: signature, digest: digest
+      end
+
+      def likes(insertion)
+        likes = []
+
+        each_with_index do |line, i|
+          next unless line == insertion.signature
+          next unless (chunk = surrounding_chunk(i, before: insertion.before, after: insertion.after))
+          next unless chunk.insertion == insertion
+
+          likes << chunk
+        end
+
+        likes
+      end
+
+      def uniq_like_chunk!(insertion)
+        raise UnfoundError,   "No chunks found like: #{insertion}"       if likes(insertion).empty?
+        raise AmbiguousError, "Multiple chunks found like: #{insertion}" unless (likes = likes(insertion)).size == 1
+
+        likes.first
+      end
+
+      def substitute_uniq_like_chunk!(insertion, *lines)
+        uniq_like_chunk!(insertion).tap do |chunk|
+          substitute_within(chunk.origin_range, *lines)
+        end
+      end
+
+      private
+
+      def index_of_maximum_entropy
+        each_index.max_by { |i| Support.entropy(self[i]) }
+      end
+
+      def substitute_at(index, *lines)
+        slice!(index).tap { insert(index, *lines) }
+      end
+
+      def substitute_within(index_or_range, *lines)
+        slice!(range = Support.to_range(index_or_range)).tap { insert(range.begin, *lines) }
+      end
+
+      class << self
+        def [](object = nil)
+          case object
+          when self       then object
+          when Array      then new(object)
+          when Enumerator then new(object.to_a)
+          when NilClass   then new([])
+          else                 new([*object])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ellipses/client/meta.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'delegate'
+
+module Ellipses
+  module Client
+    class Meta < SimpleDelegator
+      Error = Class.new Error
+
+      using Support::Refinements::Struct::FromHashWithoutBogusKeys
+
+      Source = Struct.new :source, :series, keyword_init: true do
+        def to_json(*args)
+          to_h.to_json(*args)
+        end
+
+        def self.from_hash(hash)
+          new source: hash[:source], series: Series.from_array(hash[:series])
+        end
+      end
+
+      class Series < SimpleDelegator
+        def initialize(array_of_locks)
+          super
+
+          @delegate_sd_obj = array_of_locks
+        end
+
+        def to_json(*args)
+          to_a.to_json(*args)
+        end
+
+        def self.from_array(array_of_hashes)
+          array_of_locks = array_of_hashes.map { |hash| Lock.from_hash hash }
+          new array_of_locks
+        end
+      end
+
+      Lock = Struct.new :directive, :insertion, keyword_init: true do
+        def to_json(*args)
+          to_h.to_json(*args)
+        end
+
+        def self.from_hash(hash)
+          new directive: hash[:directive], insertion: Insertion.from_hash(hash[:insertion])
+        end
+      end
+
+      Insertion = Struct.new :before, :after, :signature, :digest, keyword_init: true do
+        def to_s
+          signature
+        end
+
+        def to_json(*args)
+          to_h.to_json(*args)
+        end
+
+        def self.from_hash(hash)
+          new(**hash)
+        end
+      end
+
+      def initialize(array_of_sources)
+        super
+
+        @delegate_sd_obj = array_of_sources
+      end
+
+      def to_json(*args)
+        to_a.to_json(*args)
+      end
+
+      def self.from_array(array_of_hashes)
+        array_of_sources = array_of_hashes.map { |hash| Source.from_hash(hash) }
+        new array_of_sources
+      end
+    end
+  end
+end

data/lib/ellipses/client/meta_file.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Ellipses
+  module Client
+    class MetaFile
+      FILES = %w[.local/var/src.lock src.lock .src.lock].freeze
+      EMPTY = "[]\n"
+
+      def self.create(directory)
+        Support.dir!(directory)
+
+        selected = FILES.find { |path| ::Dir.exist? File.join(directory, ::File.dirname(path)) }
+        file     = ::File.join(directory, selected)
+
+        ::File.write(file, EMPTY) unless ::File.exist? file
+
+        new
+      end
+
+      attr_reader :directory, :alternatives
+
+      def initialize
+        @directory, @file = Support.search_path FILES
+      end
+
+      def file
+        loaded!
+        @file
+      end
+
+      def loaded?
+        @file && ::File.exist?(@file)
+      end
+
+      def loaded!
+        raise 'Lockfile not located' if @file.nil?
+
+        raise "Lockfile not found: #{@file}" unless ::File.exist? @file
+      end
+
+      def read
+        Meta.from_array JSON.load_file(file, symbolize_names: true)
+      end
+
+      def write(meta)
+        Support.updatelines(file, meta.empty? ? EMPTY : JSON.pretty_generate(meta))
+      end
+
+      def to_s
+        file
+      end
+    end
+  end
+end