ellipses 0.0.0

data/lib/ellipses/client/parser.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+require 'shellwords'
+
+module Ellipses
+  module Client
+    class Parser
+      PATTERN = /
+        ^
+        (?<prefix>\s*)
+        (?<directive>(?:[.]|>){3,}.*)
+      /x
+
+      Parsed = Struct.new :lexemes, :prefix, keyword_init: true do
+        def to_a
+          lexemes
+        end
+      end
+
+      Lexeme = Struct.new :token, :argv, keyword_init: true do
+        def self.from_strings(strings)
+          new token: strings.shift.downcase, argv: strings
+        end
+
+        def to_s
+          token
+        end
+      end
+
+      class << self
+        def parse(line)
+          return unless (match = line.match(PATTERN))
+
+          parser = new(match[:directive])
+
+          Parsed.new lexemes: parser.(), prefix: match[:prefix]
+        end
+
+        def match?(line)
+          !line.match(PATTERN).nil?
+        end
+
+        private_class_method :new
+      end
+
+      attr_reader :line
+
+      def initialize(line)
+        @line = line
+      end
+
+      def call
+        Shellwords.split(preprocess(line)).slice_after('|').map do |group|
+          group.pop if group.last == '|'
+          Lexeme.from_strings(group)
+        end
+      end
+
+      private
+
+      SUBSTITUTIONS = {
+        /^[.]{3,}/ => 'include',
+        /^>{3,}/   => ''
+      }.freeze
+
+      def preprocess(rawline)
+        rawline.strip.tap do |line|
+          SUBSTITUTIONS.each { |pattern, replace| line.gsub!(pattern, replace) }
+          line.strip!
+        end
+      end
+    end
+  end
+end

data/lib/ellipses/client/repository.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Ellipses
+  module Client
+    class Repository
+      File = Struct.new :path, :source, :digest, :registered, keyword_init: true do
+        def save(all: true)
+          return if !registered && !all
+          return if digest == (new_digest = Support.digest(*source.lines))
+
+          Support.writelines(path, source.lines)
+          Support::UI.notice(path)
+
+          self.digest = new_digest
+        end
+      end
+
+      private_constant :File
+
+      attr_reader :loader
+
+      def initialize(loader)
+        @loader = loader
+        @files  = {}
+        @memo   = {}
+      end
+
+      def [](path)
+        @files[memo(path)].source
+      end
+
+      def each_source
+        each { |_, file| yield(file.source) }
+      end
+
+      def load(loader)
+        Dir.chdir loader.directory do
+          loader.read.each { |meta| register_internal(meta.source, Source.from_file(meta.source, meta.series)) }
+        end
+      end
+
+      def save(all: true)
+        n = 0
+        each { |_, file| file.save(all: all) and (n += 1) }
+        n.positive?
+      end
+
+      def dump
+        meta = Meta.new []
+
+        each do |path, file|
+          next unless file.registered
+          next unless (source = file.source).series
+
+          meta << Meta::Source.new(source: path, series: source.series)
+        end
+
+        meta
+      end
+
+      def register(path, *args, **kwargs)
+        if @files.key?(key = memo(path))
+          return @files[key].tap { |file| file.registered = true }.source
+        end
+
+        register_internal(key, Source.from_file(path, *args, **kwargs))
+      end
+
+      def unregister(path)
+        return unless @files.key?(key = memo(path))
+
+        @files[key].tap { |file| file.registered = false }.source
+      end
+
+      def registered?(path)
+        return false unless @files.key?(key = memo(path))
+
+        @files[key].registered
+      end
+
+      private
+
+      def memo(path)
+        @memo[path] ||= Support.deflate_path(path, loader.directory)
+      end
+
+      def each(&block)
+        Dir.chdir(loader.directory) { @files.each(&block) }
+      end
+
+      def register_internal(key, source)
+        @files[key] = File.new path:       key,
+                               source:     source,
+                               digest:     Support.digest(*source.lines),
+                               registered: true
+
+        source
+      end
+    end
+  end
+end

data/lib/ellipses/client/source.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'ellipses/server'
+
+module Ellipses
+  module Client
+    class Source
+      attr_reader :series
+
+      def initialize(lines, series)
+        @lines        = lines
+        @series       = series || []
+      end
+
+      def lines
+        @lines.is_a?(Lines) ? @lines : (@lines = Lines.new @lines.to_a)
+      end
+
+      def decompile
+        return if series.empty?
+
+        while (lock = series.shift)
+          lines.substitute_uniq_like_chunk!(lock.insertion, lock.directive)
+        end
+      end
+
+      def compile(server)
+        new_lines = Lines[]
+
+        lines.each do |line|
+          new_lines.append(*(Parser.match?(line) ? execute_and_record(line, server) : line))
+        end
+
+        @lines = new_lines
+      end
+
+      def recompile(server)
+        decompile
+        compile(server)
+      end
+
+      private
+
+      def execute(line, server, **kwargs)
+        raise Error, "No directive found: #{line}" unless (parsed = Parser.parse(line))
+
+        directive = Directive.new(parsed.lexemes, server)
+
+        outlines = directive.execute(**kwargs)
+        outlines.map! { |outline| Support.prefixize_non_blank(outline, parsed.prefix, excludes: "\f\f\f") }
+
+        Lines[outlines]
+      end
+
+      def execute_and_record(line, server, **kwargs)
+        result = execute(line, server, **kwargs)
+        series << Meta::Lock.new(directive: line, insertion: result.insertion_by_entropy)
+        result
+      end
+
+      class << self
+        def from_file(file, series = nil)
+          lines = File.readlines(Support.file!(file, error: Error)).lazy
+          new lines, series
+        end
+      end
+    end
+  end
+end

data/lib/ellipses/error.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Ellipses
+  Error = Class.new StandardError
+end

data/lib/ellipses/server.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'ellipses'
+
+require_relative 'server/error'
+require_relative 'server/meta'
+require_relative 'server/meta_file'
+require_relative 'server/symbols'
+require_relative 'server/repository'
+require_relative 'server/application'

data/lib/ellipses/server/application.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Ellipses
+  module Server
+    class Application
+      DEFAULT_PORT = 0
+
+      Instance = Struct.new :uri, :repository, :port, keyword_init: true do
+        def to_s
+          self.class.ident(uri, port)
+        end
+
+        class << self
+          def ident(uri, port)
+            "#{uri}:#{port || DEFAULT_PORT}"
+          end
+        end
+      end
+
+      attr_reader :paths, :intersperse
+
+      def initialize(paths, intersperse: "\n")
+        @paths       = setup_paths(paths)
+        @intersperse = intersperse
+        @instances   = {}
+      end
+
+      def out(uri:, symbols:, port: nil)
+        [].tap { |chunks| symbols.each { |symbol| chunks.append(*instance(uri, port).repository[symbol]) } }
+      end
+
+      def dump(uri:, symbols:, port: nil)
+        Support.intersperse_arrays(out(uri: uri, symbols: symbols, port: port), intersperse).flatten
+      end
+
+      def validate(uri)
+        raise NotImplementedError
+      end
+
+      def available?(uri)
+        !scan(uri).nil?
+      end
+
+      def available!(uri)
+        return if available?(uri)
+
+        raise Error, "Repository not found in path: #{uri}"
+      end
+
+      private
+
+      def instance(uri, port = nil)
+        ident = Instance.ident(uri, port)
+        return @instances[ident] if @instances.key? ident
+
+        directory = scan(uri)
+        raise Error, "No repository instance found: #{uri}" unless directory
+
+        instance = Instance.new uri: uri, repository: Repository.load(directory), port: port
+        @instances[ident] = instance
+      end
+
+      def setup_paths(paths)
+        paths = paths.filter_map { |path| Support.dir(path) }.uniq
+        raise Error, 'No valid path found' if paths.empty?
+
+        paths
+      end
+
+      def scan(uri)
+        paths.map { |path| ::File.join(path, uri) }.find { |path| MetaFile.valid?(path) }
+      end
+
+      class << self
+        def dump(path, *symbols, **kwargs)
+          new([Support.dir!(path, error: Error)], **kwargs).dump(uri: '.', symbols: symbols)
+        end
+
+        def validate(path, **kwargs)
+          new([Support.dir!(path, error: Error)], **kwargs).validate('.')
+        end
+      end
+    end
+  end
+end

data/lib/ellipses/server/cli.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+
+require 'ellipses/server'
+
+module Ellipses
+  module Server
+    module CLI
+      module Commands
+        extend Dry::CLI::Registry
+
+        Dir[File.join(__dir__, 'cli/*.rb')].each { |command| require command }
+
+        register 'version',  Version, aliases: ['v', '-v', '--version']
+        register 'dump',     Dump
+        register 'validate', Validate
+      end
+    end
+  end
+end

data/lib/ellipses/server/cli/dump.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Ellipses
+  module Server
+    module CLI
+      module Commands
+        class Dump < Dry::CLI::Command
+          desc 'Dump symbols'
+
+          argument :path,    type: :string, required: true,  desc: 'Repository path'
+          argument :symbols, type: :array,  required: false, desc: 'Symbols'
+
+          def call(path:, symbols: [], **)
+            puts Ellipses::Server::Application.dump path, *symbols
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ellipses/server/cli/validate.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'dry/cli'
+
+module Ellipses
+  module Server
+    module CLI
+      module Commands
+        class Validate < Dry::CLI::Command
+          desc 'Validate repository'
+
+          argument :path, type: :string, required: true, desc: 'Repository path'
+
+          def call(path:)
+            Ellipses::Server::Application.validate path
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ellipses/server/cli/version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ellipses
+  module Server
+    module CLI
+      module Commands
+        class Version < Dry::CLI::Command
+          desc 'Print version'
+
+          def call(*)
+            puts '1.0.0'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ellipses/server/error.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ellipses
+  module Server
+    Error = Class.new Ellipses::Error
+  end
+end