ellipses 0.0.0

data/lib/ellipses/server/meta.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Ellipses
+  module Server
+    class Meta
+      Error = Class.new Error
+
+      using Support::Refinements::Struct::FromHashWithoutBogusKeys
+
+      Global = Struct.new(:depends, :extension, :root, keyword_init: true) do
+        def self.from_hash(hash)
+          from_hash_without_bogus_keys!(hash, error: Error)
+        end
+      end
+
+      Symbol = Struct.new(:symbol, :description, :path, :depends, keyword_init: true) do
+        def to_s
+          symbol
+        end
+
+        def add_depends(*depends)
+          return if depends&.empty?
+
+          self.depends ||= []
+          depends.reverse_each { |member| self.depends.unshift(member) }
+        end
+
+        def self.from_hash(hash)
+          from_hash_without_bogus_keys!(hash, error: Error)
+        end
+
+        def self.from_hash_with_depends(hash, *depends)
+          from_hash_without_bogus_keys!(hash, error: Error).tap { |symbol| symbol.add_depends(*depends) }
+        end
+      end
+
+      class Symbols
+        extend Forwardable
+
+        def_delegators :@symbols, :each, :length
+
+        attr_reader :symbols
+
+        def initialize(symbols, *depends)
+          hash = {}
+
+          (symbols || []).each do |meta|
+            symbol = Symbol.from_hash_with_depends(meta, *depends)
+            hash[symbol.to_s] = symbol
+          end
+
+          @symbols = hash.values
+        end
+      end
+
+      attr_reader :symbols, :global
+
+      def initialize(hash)
+        symbols_array = hash.delete('symbols') || []
+        global_hash   = hash || {}
+
+        @global  = Global.from_hash(global_hash)
+        @symbols = Symbols.new(symbols_array, *(@global.depends || []))
+      end
+    end
+  end
+end

data/lib/ellipses/server/meta_file.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'tomlrb'
+
+module Ellipses
+  module Server
+    class MetaFile
+      FILE = 'src.toml'
+
+      Error = Class.new(Error)
+
+      attr_reader :directory
+
+      def initialize(directory)
+        @directory = Support.dir!(directory, error: Error)
+        @file      = Support.file!(FILE, base: @directory, error: Error)
+      end
+
+      def to_s
+        @file
+      end
+
+      def read
+        Meta.new Tomlrb.load_file(@file)
+      rescue StandardError => e
+        raise Error, "Error while loading meta file: #{file}: #{e.message}"
+      end
+
+      class << self
+        def valid?(directory)
+          new(directory)
+          true
+        rescue Error
+          false
+        end
+      end
+    end
+  end
+end

data/lib/ellipses/server/repository.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Ellipses
+  module Server
+    class Repository
+      Error = Class.new Error
+
+      attr_reader :symbols, :global, :root
+
+      def initialize(symbols:, global:, directory:)
+        @symbols   = symbols
+        @global    = global
+        @root      = global.root ? ::File.join(directory, global.root) : directory
+        @consumed  = Set.new
+      end
+
+      def [](string)
+        (chunks = []).tap do
+          symbols.resolve(string).each { |symbol| yield_symbol(chunks, symbol) }
+          next unless chunks.empty?
+
+          raise Error, "No chunks resolved for symbol: #{string}, which may already have been consumed"
+        end
+      end
+
+      private
+
+      def yield_symbol(chunks, symbol)
+        return if @consumed.include? symbol
+
+        @consumed << symbol
+        return if (lines = symbol.payload(root, global.extension)).empty?
+
+        chunks << lines
+      end
+
+      class << self
+        def load(directory)
+          meta = (meta_file = MetaFile.new(directory)).read
+          new symbols: Symbols.new(meta.symbols), global: meta.global, directory: meta_file.directory
+        end
+      end
+    end
+  end
+end

data/lib/ellipses/server/symbols.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Ellipses
+  module Server
+    class Symbols
+      CircularReferenceError = Class.new Error
+      MissingSymbolError     = Class.new Error
+      BogusLeafError         = Class.new Error
+      EmptyPayloadError      = Class.new Error
+
+      class Symbol
+        attr_reader :depends
+
+        def initialize(meta)
+          @meta    = meta
+          @depends = []
+        end
+
+        def build(symbols)
+          return if @meta.depends.nil?
+
+          # To avoid a circular reference, skip dependency if it is this symbol
+          @meta.depends.uniq.reject { |depend| depend == to_s }.each { |depend| depends << symbols.register(depend) }
+        end
+
+        def to_s
+          @meta.to_s
+        end
+
+        def leaf?
+          depends.empty?
+        end
+
+        def path
+          @path ||= @meta.path
+        end
+
+        def payload(rootdir, extension = nil)
+          unless (file = where(rootdir, extension)) && !::File.directory?(file)
+            raise BogusLeafError, "No source found for leaf symbol: #{self}" if leaf?
+
+            return []
+          end
+
+          ::File.readlines(file).tap do |lines|
+            raise EmptyPayloadError, "Empty source for symbol: #{self}" if lines.empty?
+          end
+        end
+
+        private
+
+        def where(rootdir, extension = nil)
+          return ::File.exist?(path) ? ::File.join(rootdir, path) : nil if path
+
+          paths = [base = ::File.join(rootdir, to_s)]
+          paths.prepend("#{base}#{extension}") if extension
+
+          paths.find { |path| ::File.exist?(path) }
+        end
+
+        class << self
+          def from_string(string)
+            new Meta::Symbol.from_hash symbol: string
+          end
+
+          def from_meta(meta)
+            new meta
+          end
+        end
+
+        private_class_method :new
+      end
+
+      private_constant :Symbol
+
+      def initialize(meta)
+        @meta     = meta
+        @registry = {}
+
+        build
+      end
+
+      def [](string)
+        raise MissingSymbolError, "Missing symbol: #{string}" unless @registry.key? string
+
+        @registry[string]
+      end
+
+      def resolve(string)
+        resolved = []
+        walk(self[string]) { |symbol| resolved << symbol }
+        resolved
+      end
+
+      def register(string)
+        _register Symbol.from_string(string)
+      end
+
+      def walk(symbol, &block)
+        _walk(symbol, Set[symbol], &block)
+      end
+
+      private
+
+      def build
+        @meta.each { |symbol_meta| _register_by_meta(symbol_meta) }
+        @registry.dup.each_value { |symbol| symbol.build(self) }
+
+        sanitize
+      end
+
+      def _walk(symbol, stack, &block)
+        return if symbol.depends.nil?
+
+        symbol.depends.each do |depend|
+          raise CircularReferenceError, "Circular reference from #{symbol} to #{depend}" if stack.first == depend
+
+          next if stack.include? depend
+
+          stack << depend
+          _walk(depend, stack, &block)
+        rescue ::StopIteration
+          return nil
+        end
+
+        yield(symbol) if block
+      end
+
+      def _register(symbol)
+        @registry[symbol.to_s] || (@registry[symbol.to_s] = symbol)
+      end
+
+      def _register_by_meta(symbol_meta)
+        _register Symbol.from_meta(symbol_meta)
+      end
+
+      def sanitize
+        tap do
+          @registry.each_value { |symbol| walk(symbol) }
+        end
+      end
+    end
+  end
+end

data/lib/ellipses/support.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+Dir[File.join(__dir__, 'support', '*.rb')].each { |support| require support }

data/lib/ellipses/support/deflate_path.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Ellipses
+  module Support
+    module_function
+
+    def deflate_path(path, rootdir = nil)
+      base = Pathname.new(rootdir || '.').expand_path
+      Pathname.new(path).cleanpath.expand_path.relative_path_from(base).to_s
+    end
+  end
+end

data/lib/ellipses/support/digest.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module Ellipses
+  module Support
+    module_function
+
+    def digest(*args)
+      ::Digest::SHA256.hexdigest args.map(&:to_s).join
+    end
+  end
+end

data/lib/ellipses/support/entropy.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ellipses
+  module Support
+    module_function
+
+    # https://rosettacode.org/wiki/Entropy#Ruby
+    def entropy(string)
+      string
+        .each_char
+        .group_by(&:to_s)
+        .values
+        .map { |x| x.length / string.length.to_f }
+        .reduce(0) { |e, x| e - x * Math.log2(x) }
+    end
+  end
+end

data/lib/ellipses/support/expand_path.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'pathname'
+
+module Ellipses
+  module Support
+    module_function
+
+    def expand_path(path, rootdir = nil)
+      Pathname.new(::File.join(rootdir || '.', path)).cleanpath.to_s
+    end
+  end
+end

data/lib/ellipses/support/intersperse_arrays.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Ellipses
+  module Support
+    module_function
+
+    def intersperse_arrays(arrays, intersperse)
+      [].tap do |interspersed|
+        arrays.each { |array| interspersed.append(array, intersperse) }
+        interspersed.pop
+      end
+    end
+  end
+end

data/lib/ellipses/support/prefixize_non_blank.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Ellipses
+  module Support
+    module_function
+
+    def prefixize_non_blank(string, prefix, excludes: nil)
+      stripped = string.strip
+
+      return string if prefix.empty? || stripped.empty?
+      return string if excludes && [*excludes].include?(stripped)
+
+      "#{prefix}#{string}"
+    end
+  end
+end

data/lib/ellipses/support/refinements.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Ellipses
+  module Support
+    module Refinements
+      module Struct
+        module FromHashWithoutBogusKeys
+          refine ::Struct.singleton_class do
+            def from_hash_without_bogus_keys!(hash, error:)
+              bogus = (hash = hash.transform_keys(&:to_sym)).keys.reject { |key| members.include?(key) }
+              raise error, "Bogus keys found: #{bogus}" unless bogus.empty?
+
+              new hash.slice(*members)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ellipses/support/sanitize_path.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Ellipses
+  module Support
+    module SanitizePath
+      class Sanitizer
+        def self.sanitize(*args, **kwargs)
+          new(*args, **kwargs).sanitize
+        end
+
+        class Error < StandardError
+          def initialize(path)
+            super("#{kind}: #{path}")
+          end
+
+          def self.kind(message)
+            Class.new self do
+              define_method(:kind) { message }
+            end
+          end
+        end
+
+        MissingBase   = Error.kind 'Directory not found'
+        WrongBase     = Error.kind 'Not a directory'
+        MissingPath   = Error.kind 'File or directory not found'
+        NotFile       = Error.kind 'Not a file'
+        NotDir        = Error.kind 'Not a directory'
+        NotExecutable = Error.kind 'Not an executable'
+
+        attr_reader :path, :base, :fullpath
+
+        def initialize(path:, base: nil)
+          @path     = ::File.join(*path)
+          @base     = ::File.join(*base) if base
+          @fullpath = ::File.expand_path(@path, @base)
+        end
+
+        def sanitize
+          if base
+            raise MissingBase, base unless ::File.exist?(base)
+            raise WrongBase,   base unless ::File.directory?(base)
+          end
+
+          raise MissingPath, fullpath unless ::File.exist?(fullpath)
+
+          call
+
+          fullpath
+        end
+
+        class Dir < Sanitizer
+          def call
+            raise NotDir, fullpath unless ::File.directory?(fullpath)
+          end
+        end
+
+        private_constant :Dir
+
+        class File < Sanitizer
+          def call
+            raise NotFile, fullpath unless ::File.file?(fullpath)
+          end
+        end
+
+        private_constant :File
+
+        class Executable < Sanitizer
+          def call
+            raise NotExecutable, fullpath unless ::File.file?(fullpath) || ::File.executable?(fullpath)
+          end
+        end
+
+        private_constant :Executable
+      end
+
+      private_constant :Sanitizer
+
+      def self.extended(consumer) # rubocop:disable Metrics/MethodLength
+        super
+
+        %i[file dir executable].each do |meth|
+          klass = Sanitizer.const_get meth.capitalize
+
+          consumer.define_singleton_method(meth) do |path, base: nil|
+            klass.sanitize(path: path, base: base)
+          rescue Sanitizer::Error
+            nil
+          end
+
+          consumer.define_singleton_method("#{meth}!") do |path, error: nil, base: nil|
+            klass.sanitize(path: path, base: base)
+          rescue Sanitizer::Error => e
+            error ? raise(error, e.message) : raise
+          end
+        end
+      end
+    end
+
+    extend SanitizePath
+  end
+end