mem_db 0.1.0

data/lib/mem_db/field/matching.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+class MemDB
+  module Field
+    module Matching
+      def match?(_query)
+        raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+      end
+    end
+  end
+end

data/lib/mem_db/field/may_missing.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "mem_db/field"
+require "mem_db/field/matching"
+
+class MemDB
+  module Field
+    class MayMissing
+      include MemDB::Field
+
+      class Any
+        include MemDB::Field::Matching
+
+        def match?(_query)
+          true
+        end
+      end
+
+      ANY_MATCHING = Any.new
+
+      def initialize(original)
+        @original = original
+      end
+
+      def field
+        @original.field
+      end
+
+      def query_field
+        @original.query_field
+      end
+
+      def new_matching(obj)
+        v = obj[field]
+
+        if v.nil?
+          ANY_MATCHING
+        else
+          @original.new_matching(obj)
+        end
+      end
+    end
+  end
+end

data/lib/mem_db/field/negative.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "mem_db/field"
+require "mem_db/field/matching"
+
+class MemDB
+  module Field
+    class Negative
+      include MemDB::Field
+
+      class NegativeMatching
+        include MemDB::Field::Matching
+
+        def initialize(original)
+          @original = original
+        end
+
+        def match?(query)
+          !@original.match?(query)
+        end
+      end
+
+      def initialize(original)
+        @original = original
+      end
+
+      def field
+        @original.field
+      end
+
+      def query_field
+        @original.query_field
+      end
+
+      def new_matching(obj)
+        NegativeMatching.new(@original.new_matching(obj))
+      end
+    end
+  end
+end

data/lib/mem_db/field/pattern.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+require "mem_db/field"
+require "mem_db/field/matching"
+
+class MemDB
+  module Field
+    class Pattern
+      include MemDB::Field
+
+      class Pattern
+        WILDCARD = "*"
+
+        class Rx
+          def initialize(source)
+            parts = source.split(WILDCARD, -1).map { |part| ::Regexp.quote(part) }
+            parts[0] = "\\A#{parts[0]}"
+            parts[-1] = "#{parts[-1]}\\z"
+            @rx = ::Regexp.new(parts.join(".*"), ::Regexp::MULTILINE)
+          end
+
+          def match?(str)
+            @rx.match?(str)
+          end
+        end
+
+        class Exact
+          def initialize(source)
+            @source = source
+          end
+
+          def match?(str)
+            @source == str
+          end
+        end
+
+        class Prefix
+          def initialize(prefix)
+            @prefix = prefix
+          end
+
+          def match?(str)
+            str.start_with?(@prefix)
+          end
+        end
+
+        class Suffix
+          def initialize(suffix)
+            @suffix = suffix
+          end
+
+          def match?(str)
+            str.end_with?(@suffix)
+          end
+        end
+
+        def initialize(source)
+          wildcard_count = source.count(WILDCARD)
+          @pat =
+            if wildcard_count.zero?
+              Exact.new(source)
+            elsif wildcard_count > 1
+              Rx.new(source)
+            elsif source.end_with?(WILDCARD)
+              Prefix.new(source[0..-2])
+            elsif source.start_with?(WILDCARD)
+              Suffix.new(source[1..-1])
+            else
+              Rx.new(source)
+            end
+        end
+
+        def match?(str)
+          @pat.match?(str)
+        end
+      end
+
+      class MultiMatching
+        include MemDB::Field::Matching
+
+        def initialize(f, arr)
+          @f = f
+          @patterns = arr.map { |source| Pattern.new(source) }
+        end
+
+        def match?(query)
+          @f.query_value(query).each do |str|
+            return true if @patterns.any? { |pat| pat.match?(str) }
+          end
+
+          false
+        end
+      end
+
+      class SingleMatching
+        include MemDB::Field::Matching
+
+        def initialize(f, el)
+          @f = f
+          @pat = Pattern.new(el)
+        end
+
+        def match?(query)
+          @f.query_value(query).any? { |str| @pat.match?(str) }
+        end
+      end
+
+      attr_reader :field
+
+      def initialize(field)
+        @field = field
+      end
+
+      def new_matching(obj)
+        val = obj[field]
+
+        if val.is_a?(Array)
+          MultiMatching.new(self, val)
+        else
+          SingleMatching.new(self, val)
+        end
+      end
+    end
+  end
+end

data/lib/mem_db/field/regexp.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+require "mem_db/field"
+require "mem_db/field/matching"
+
+class MemDB
+  module Field
+    class Regexp
+      include MemDB::Field
+
+      class Rx
+        def initialize(source)
+          @rx = ::Regexp.new(source, ::Regexp::MULTILINE)
+        end
+
+        def match?(str)
+          @rx.match?(str)
+        end
+      end
+
+      class MultiMatching
+        include MemDB::Field::Matching
+
+        def initialize(field, arr)
+          @field = field
+          @patterns = arr.map { |source| Rx.new(source) }
+        end
+
+        def match?(query)
+          @field.query_value(query).each do |str|
+            return true if @patterns.any? { |pat| pat.match?(str) }
+          end
+
+          false
+        end
+      end
+
+      class SingleMatching
+        include MemDB::Field::Matching
+
+        def initialize(field, el)
+          @field = field
+          @pat = Rx.new(el)
+        end
+
+        def match?(query)
+          @field.query_value(query).any? { |str| @pat.match?(str) }
+        end
+      end
+
+      attr_reader :field
+
+      def initialize(field)
+        @field = field
+      end
+
+      def new_matching(obj)
+        val = obj[field]
+
+        if val.is_a?(Array)
+          MultiMatching.new(self, val)
+        else
+          SingleMatching.new(self, val)
+        end
+      end
+    end
+  end
+end

data/lib/mem_db/fields.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+class MemDB
+  class Fields
+    class Matching
+      def initialize(fields, obj)
+        @matchings = fields.map { |field| field.new_matching(obj) }.reject! do |matching|
+          matching == MemDB::Field::MayMissing::ANY_MATCHING
+        end
+      end
+
+      def match?(query)
+        @matchings.all? { |matching| matching.match?(query) }
+      end
+    end
+
+    def initialize(fields)
+      @fields = fields
+    end
+
+    def new_matching(obj)
+      Matching.new(@fields, obj)
+    end
+  end
+end

data/lib/mem_db/idx.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+class MemDB
+  module Idx
+    ANY = Object.new
+
+    def default(default)
+      MemDB::Idx::Default.new(self, default)
+    end
+
+    def default_any
+      default(MemDB::Idx::ANY)
+    end
+
+    def field
+      raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+    end
+
+    def map_value(_obj)
+      raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+    end
+
+    def map_query(_obj)
+      raise NotImplementedError, "#{self.class} has not implemented method '#{__method__}'"
+    end
+
+    def value(obj)
+      v = obj[field]
+
+      if v == ANY
+        v
+      else
+        v.map { |e| map_value(e) }
+      end
+    end
+
+    def prepare_query(query)
+      query[field].map { |v| map_query(v) }
+    end
+  end
+end

data/lib/mem_db/idx/bytes.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "mem_db/idx"
+
+class MemDB
+  module Idx
+    class Bytes
+      include MemDB::Idx
+
+      attr_reader :field
+
+      def initialize(field)
+        @field = field
+      end
+
+      def map_value(raw)
+        raw.bytes
+      end
+
+      def map_query(text)
+        text.bytes
+      end
+    end
+  end
+end

data/lib/mem_db/idx/chars.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "mem_db/idx"
+
+class MemDB
+  module Idx
+    class Chars
+      include MemDB::Idx
+
+      attr_reader :field
+
+      class Chars
+        include Enumerable
+
+        def initialize(str)
+          @str = str
+          @length = str.length
+        end
+
+        def [](pos)
+          @str[pos]
+        end
+
+        attr_reader :length
+
+        def reverse
+          ReversedChars.new(@str)
+        end
+
+        def each
+          return to_enum unless block_given?
+
+          i = 0
+          while i < @length
+            yield @str[i]
+            i += 1
+          end
+        end
+      end
+
+      class ReversedChars
+        include Enumerable
+
+        def initialize(str)
+          @str = str
+          @length = str.length
+        end
+
+        def [](pos)
+          @str[@str.length - pos - 1]
+        end
+
+        def length
+          @str.length
+        end
+
+        def reverse
+          Chars.new(@str)
+        end
+
+        def each
+          return to_enum unless block_given?
+
+          i = @length - 1
+          while i >= 0
+            yield @str[i]
+            i -= 1
+          end
+        end
+      end
+
+      def initialize(field)
+        @field = field
+      end
+
+      def map_value(raw)
+        raw.chars
+      end
+
+      def map_query(text)
+        Chars.new(text)
+      end
+    end
+  end
+end