squared 0.4.36 → 0.5.0

data/lib/squared/common/class.rb

@@ -1,186 +0,0 @@
-# frozen_string_literal: true
-
-require 'set'
-require 'forwardable'
-
-module Squared
-  module Common
-    class SymSet
-      extend Forwardable
-
-      def self.to_s
-        super[/[^:]+\z/, 0]
-      end
-
-      def_delegators :@data, :+, :each, :each_with_index, :entries, :merge, :include?
-
-      def initialize(data = [])
-        @data = Set.new(data)
-      end
-
-      def add(val)
-        @data.add(val.to_sym)
-      end
-
-      def to_a
-        @data.to_a.freeze
-      end
-
-      def to_s
-        @data.to_s.sub('Set', SymSet.to_s)
-      end
-
-      alias inspect to_s
-    end
-
-    class JoinSet < Set
-      def self.to_s
-        super[/[^:]+\z/, 0]
-      end
-
-      alias to_ary to_a
-
-      attr_reader :delim, :extras
-
-      def initialize(data = [], delim: ' ', partition: '--', uniq: /\A--?[^=\s-][^=\s]*(?:=|\s+)\S/)
-        @delim = delim
-        @partition = partition
-        @uniq = uniq
-        @extras = []
-        super(data.compact)
-      end
-
-      def compact
-        to_ary.map!(&:to_s).reject(&:empty?)
-      end
-
-      def last(val, pat)
-        (@last ||= []).push([val, pat, $1]) if val =~ pat
-        self << val
-      end
-
-      def pass(&blk)
-        ret = compact
-        @last&.each do |val, pat, key|
-          i = []
-          j = nil
-          ret.each_with_index do |opt, index|
-            if opt == val
-              j = index
-            elsif j && opt[pat, 1] == key
-              i << index
-            end
-          end
-          next unless j && !i.empty?
-
-          val = ret[j]
-          cur = j
-          i.each do |k|
-            ret[cur] = ret[k]
-            cur = k
-          end
-          ret[i.last] = val
-        end
-        ret.concat(extras.map(&:to_s).reject(&:empty?)) unless extras.empty?
-        block_given? ? ret.reject(&blk) : ret
-      end
-
-      def and(*args)
-        self << '&&'
-        merge(args)
-      end
-
-      def or(*args)
-        self << '||'
-        merge(args)
-      end
-
-      def with(*args, &blk)
-        temp('&&', *args, &blk)
-      end
-
-      def temp(*args, &blk)
-        args.compact!
-        pass(&blk)
-          .concat(args)
-          .join(@delim)
-      end
-
-      def done
-        ret = to_s
-        clear
-        ret
-      end
-
-      def merge(enum)
-        if !extras.empty?
-          extras.concat(enum.to_a)
-          self
-        elsif (n = enum.find_index { |val| extras?(val) })
-          data = enum.to_a
-          @extras = if n == 0
-                      data
-                    else
-                      super(data[0...n])
-                      data[n..-1]
-                    end
-          self
-        else
-          super
-        end
-      end
-
-      def <<(obj)
-        extras!(obj) || super
-      end
-
-      def size
-        super + extras.size
-      end
-
-      def include?(obj)
-        return true if super
-        return extras.include?(obj) unless (n = extras.index(@partition))
-
-        extras[0..n].include?(obj)
-      end
-
-      def to_a
-        pass
-      end
-
-      def to_s
-        to_a.join(@delim)
-      end
-
-      def to_enum(*args)
-        to_a.to_enum(*args)
-      end
-
-      def to_json(*args)
-        to_a.to_json(*args)
-      end
-
-      def to_yaml(*args)
-        to_a.to_yaml(*args)
-      end
-
-      alias add :<<
-      alias add? :<<
-      alias member? include?
-
-      private
-
-      def extras!(obj)
-        return if extras.empty? && !extras?(obj)
-
-        extras << obj unless !extras.include?(@partition) && include?(obj) && @uniq.match?(obj.to_s)
-        self
-      end
-
-      def extras?(obj)
-        obj == @partition || (include?(obj) && !@uniq.match?(obj.to_s))
-      end
-    end
-  end
-end

data/lib/squared/workspace/support/base.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module Squared
-  module Workspace
-    module Support
-      class << self
-        def hashobj
-          Hash.new { |data, key| data[key] = {} }
-        end
-
-        def hashlist
-          Hash.new { |data, key| data[key] = [] }
-        end
-
-        def hashdup(data, pass: {})
-          ret = {}
-          data.each do |key, val|
-            ret[key] = case val
-                       when Hash
-                         pass[val] ||= hashdup(val, pass: pass)
-                       when Proc, Method
-                         val
-                       else
-                         val.dup
-                       end
-          end
-          ret
-        end
-      end
-    end
-  end
-end