search_enjoy 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: ddd4395bd6c040811e98b5b0a5870074e37278996c998060b5ddc3180c58f0d0
+  data.tar.gz: fb15c8b3a45ff5b06979ed74ae7b4cbcbabd0edba92774bb1ed71eb03c1fd967
+SHA512:
+  metadata.gz: 38fd91eaf7198951e487308c490c87d207253e34fd34e3d2837885c82de61a070146f5820fa7f13da71bd277a803bb28e236fc7fcebe1bf0bdb01a23149798b6
+  data.tar.gz: c41f44e7ef552e65f24174ad9cd17f00ea168551ce8cd98d815571f3ec6675318c94008cb8c65467ef544b3e273c075155e4154d6cbf990f605932d08c51d473

data/lib/search_enjoy.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative 'search_enjoy/schema'
+require_relative 'search_enjoy/indexing'
+require_relative 'search_enjoy/searching'
+require_relative 'search_enjoy/aggregation'
+require_relative 'search_enjoy/query'
+require_relative 'search_enjoy/configuration'
+require_relative 'search_enjoy/dumping'
+require_relative 'search_enjoy/search_index'
+require 'dry-schema'
+
+module SearchEnjoy
+  def self.included(base)
+    base.class_eval do
+      include SearchEnjoy::Schema
+      include SearchEnjoy::Indexing
+      include SearchEnjoy::Searching
+      include SearchEnjoy::Aggregation
+      include SearchEnjoy::Configuration
+      include SearchEnjoy::Dumping
+    end
+  end
+end

data/lib/search_enjoy/aggregation.rb

@@ -0,0 +1,44 @@
+module SearchEnjoy
+  module Aggregation
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+        extend ClassMethods
+      end
+    end
+
+    module InstanceMethods
+
+    end
+
+    module ClassMethods
+      def aggregate(*args)
+        values = @search_index.values.map { |object| args.map { |key| object[key] } }
+        values_per_keys = values.transpose.map(&:uniq).zip(args)
+
+        aggregations = []
+
+        values_per_keys.each do |key_values|
+          key = key_values.last
+
+          hash = { field: key, data: [] }
+
+          key_values.first.each do |value|
+            count = search(key => value).size
+
+            data_hash = {
+                value: value,
+                count: count
+            }
+
+            hash[:data] << data_hash
+          end
+
+          aggregations << hash
+        end
+
+        aggregations
+      end
+    end
+  end
+end

data/lib/search_enjoy/configuration.rb

@@ -0,0 +1,26 @@
+module SearchEnjoy
+  module Configuration
+    def self.included(base)
+      base.class_eval do
+        @@index_configuration = Configuration.new(base)
+
+        def self.index_configuration(&block)
+          return @@index_configuration unless block_given?
+
+          yield @@index_configuration
+        end
+      end
+    end
+
+    class Configuration
+      attr_accessor :dump_dir_path, :dump_frequency, :dump_enable, :dump_filename
+
+      def initialize(indexing_class)
+        @dump_dir_path = "./data/search_enjoy"
+        @dump_filename = "#{indexing_class}_#{Time.now.strftime('%Y%m%d%H%M%S')}"
+        @dump_frequency = 100
+        @dump_enable = true
+      end
+    end
+  end
+end

data/lib/search_enjoy/dumping.rb

@@ -0,0 +1,51 @@
+module SearchEnjoy
+  module Dumping
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    class DumpException < RuntimeError; end
+
+    module ClassMethods
+      attr_reader :search_index_state
+
+      def dump_index_to_file
+        path = index_configuration.dump_dir_path
+        filename = index_configuration.dump_filename
+
+        FileUtils.mkdir_p(path) unless File.exist? path
+
+        File.open("#{path}/#{filename}", 'w') do |file|
+          file.write(@search_index.to_json)
+        end
+      end
+
+      def load_index_from_file
+        path = index_configuration.dump_dir_path
+        filename = index_configuration.dump_filename
+
+        File.open("#{path}/#{filename}", 'r') do |file|
+          search_index.load_json(file.read)
+        end
+      end
+
+      def initialize_dump_counter
+        @search_index_state[:dump_counter] = 0
+      end
+
+      def increase_dump_counter
+        @search_index_state[:dump_counter] += 1
+      end
+
+      def need_dump?
+        raise DumpException, "Index doesn't exist" if @search_index.nil?
+
+        @search_index_state[:dump_counter] >= index_configuration.dump_frequency && index_configuration.dump_enable
+      rescue StandardError => e
+        e.message
+      end
+    end
+  end
+end

data/lib/search_enjoy/indexing.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+require 'json'
+
+module SearchEnjoy
+  # Module responsible for indexing elements in collection
+  module Indexing
+    def self.included(base)
+      base.class_eval do
+        include InstanceMethods
+        extend ClassMethods
+      end
+    end
+
+    class IndexException < RuntimeError; end
+
+    # Class methods and variables for indexing
+    module ClassMethods
+      attr_accessor :search_index
+
+      def create_index!
+        raise IndexException, 'Index already exist' unless @search_index.nil?
+
+        @search_index = SearchIndex.new(index_schema: @index_schema)
+        @search_index_state = {}
+
+        initialize_dump_counter
+      rescue StandardError => e
+        e.message
+      end
+
+      def delete_index!
+        raise IndexException, "Index doesn't exist" if @search_index.nil?
+
+        @search_index = nil
+      rescue StandardError => e
+        e.message
+      end
+
+      def recreate_index!
+        delete_index!
+        create_index!
+      end
+
+    end
+
+    module InstanceMethods
+      # For default execute methods with attributes name
+      def as_indexed_json
+        schema = self.class.index_schema
+
+        hash = {}
+
+        schema.key_map.each do |key|
+          hash[key.name.to_sym] = send(key.name)
+        end
+
+        hash
+      end
+
+      def index_object
+        raise IndexException, 'Index doesnt exist' if self.class.search_index.nil?
+
+        indexed_object = self.class.index_schema.call(as_indexed_json)
+
+        return if indexed_object.errors.messages.size > 0
+
+        self.class.search_index[id.to_s.to_sym] = indexed_object
+
+        Thread.new do
+          self.class.increase_dump_counter
+
+          self.class.dump_index_to_file if self.class.need_dump?
+        end.join
+
+        indexed_object
+      rescue StandardError => e
+        e.message
+      end
+    end
+  end
+end

data/lib/search_enjoy/query.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module SearchEnjoy
+  class QueryResult < Array
+    attr_writer :parent_class
+
+    def initialize(parent_class, *args)
+      super(*args)
+
+      @parent_class = parent_class
+    end
+
+    private def method_missing(symbol, *args)
+      @parent_class.send(symbol, *(args << self))
+    end
+
+    def respond_to_missing?(symbol, *_args)
+      @parent_class.respond_to? symbol
+    end
+  end
+
+  class Query
+    attr_reader :default_options, :query_hash
+
+    def initialize(hash, **opts)
+      @default_options = {}
+
+      @default_options = opts
+
+      @parent_query = nil
+
+      @default_options[:must] ||= false
+      @default_options[:inverse] ||= false
+
+      @query_hash = to_query_hash(hash)
+    end
+
+    def to_query_hash(hash, **opts)
+      result = {}
+
+      hash.each_pair do |key, value|
+        value = to_query_hash(value, opts) if value.instance_of? Hash
+
+        result[key] = { value: value }.merge(@default_options).merge(opts)
+      end
+
+      result
+    end
+
+    def inverse!(hash = nil)
+      result = {}
+
+      hash ||= @query_hash
+
+      hash.each_pair do |key, value|
+        value = inverse(value) if value.instance_of? Hash
+
+        result[key] = { value: value, must: !hash[:must], inverse: !hash[:inverse] }
+      end
+
+      @query_hash = result if hash == @query_hash
+
+      result
+    end
+
+    # build_query do
+    #   must(:attr1).be_in []
+    #   must(:attr2).eq_to value
+    #
+    #   describe :attr3 do
+    #     must(:key_1).be_in
+    #     must.not(:key_2).eq_to value
+    #   end
+    # end
+    def self.build_query(&block)
+      query = new({})
+
+      query.instance_eval(&block)
+
+      query
+    end
+
+    def add_statements(&block)
+      instance_eval(&block)
+    end
+
+    def must(attribute = nil)
+      query = if attribute.nil?
+                Query.new({}, must: true)
+              else
+                Query.new({attribute => nil}, must: true)
+              end
+
+      query.send('parent_query=', self)
+
+
+      query
+    end
+
+    def should(attribute = nil)
+      query = if attribute.nil?
+                Query.new({}, must: false)
+              else
+                Query.new({attribute => nil}, must: false)
+              end
+
+      query.send('parent_query=', self)
+
+      query
+    end
+
+    def not(attribute)
+      @default_options[:inverse] = true
+
+      @query_hash = to_query_hash({attribute => nil})
+
+      self
+    end
+
+    def be(value)
+      key = @query_hash.keys.first
+
+      @query_hash[key][:value] = value
+
+      merge_to_parent!
+    end
+
+    def describe(attribute, &block)
+      query = Query.new({})
+
+      query.instance_eval(&block)
+
+      puts query.inspect
+
+      @query_hash.merge!({attribute => query.query_hash})
+    end
+
+    private
+
+    def parent_query=(query)
+      @parent_query = query
+    end
+
+    def merge_to_parent!
+      @parent_query.query_hash.merge!(@query_hash)
+    end
+  end
+end

data/lib/search_enjoy/schema.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module SearchEnjoy
+  # Module responsible for defining index schema
+  module Schema
+    def self.included(base)
+      base.class_eval do
+        extend ClassMethods
+      end
+    end
+
+    # class responsible for creating hash schema due to schema DSL
+    class Mapping
+      attr_reader :mapping
+
+      FILLED_FIELDS = %i[
+        integer
+        string
+        float
+        date
+      ].freeze
+
+      NESTED_FIELDS = %i[array hash].freeze
+      def initialize
+        @mapping = {}
+      end
+
+      def respond_to_missing?; end
+
+      private
+
+      # @todo
+      # Think about other DSL
+      #
+      # attr1(:array).of :integer
+      # attr2(:hash).with do
+      #  key(:key_1).of :integer
+      # end
+      def hash_key(key, value_type, &block)
+        @mapping[key] = if block_given?
+                          nested_mapping = Mapping.new
+                          nested_mapping.instance_eval(&block)
+
+                          nested_mapping.mapping
+                        else
+                          value_type
+                        end
+      end
+
+      def array_type(type, &block)
+        # @mapping[:array] = if block_given?
+        #                     nested_mapping = Mapping.new
+        #                     nested_mapping.instance_eval(&block)
+        #
+        #                     nested_mapping.mapping
+        #                   else
+        #                     type
+        #                   end
+
+        hash_key(:array, type, &block)
+      end
+
+      def method_missing(method, *args, &block)
+        type = args.first
+
+        @mapping[method] = type if FILLED_FIELDS.include? type
+
+        if NESTED_FIELDS.include? type
+          nested_mapping = Mapping.new
+          nested_mapping.instance_eval(&block)
+
+          @mapping[method] = nested_mapping.mapping
+        end
+
+        @mapping[method]
+      end
+    end
+
+    # Class methods and variables
+    module ClassMethods
+      attr_reader :index_schema
+
+      # define_json_schema do
+      #   attr1 :value_type
+      #
+      #   attr2 :array do
+      #     type :value_type
+      #   end
+      #
+      #   attr3 :hash do
+      #     key :key, :value_type
+      #   end
+      # end
+      def define_json_schema(&block)
+        mapping = Mapping.new
+
+        mapping.instance_eval(&block)
+
+        @index_schema = create_schema(mapping.mapping)
+      end
+
+      private
+
+      # define a method for required(key) in Dry::Schema.Params
+      def dry_schema_method(value)
+        if value.instance_of?(Hash)
+          value.key?(:array) ? :array : :hash
+        elsif value.instance_of?(Symbol)
+          :filled
+        end
+      end
+
+      # define a arguments for required(key) in Dry::Schema.Params
+      def dry_schema_args(method, value)
+        if method == :filled
+          value
+        elsif method == :array
+          value[:array].instance_of?(Hash) ? create_schema(value[:array]) : value[:array]
+        elsif method == :hash
+          create_schema(value)
+        end
+      end
+
+      def create_schema(mapping)
+        schema = self
+        Dry::Schema.Params do
+          mapping.each_pair do |key, value|
+            method = schema.send('dry_schema_method', value)
+
+            args = schema.send('dry_schema_args', method, value)
+
+            required(key).send(method, args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/search_enjoy/search_index.rb

@@ -0,0 +1,39 @@
+module SearchEnjoy
+  class SearchIndex < Hash
+    def initialize(*several_variants, index_schema: nil)
+      super
+      @index_schema = index_schema
+    end
+
+    class SearchIndexException < RuntimeError; end
+
+    def to_json
+      hash = {}
+
+      each_pair do |id, object|
+        object_hash = {}
+
+        @index_schema.key_map.each do |key|
+          object_hash[key.name.to_sym] = object[key.name.to_sym]
+        end
+
+        hash[id] = object_hash
+      end
+
+      JSON.generate(hash)
+    rescue StandardError => e
+      e.message
+    end
+
+    def load_json(json)
+      hash = JSON.parse(json)
+      hash.each_pair do |id, object|
+        indexed_object = @index_schema.call(object)
+        self[id] = indexed_object
+      end
+    rescue StandardError => e
+      e.message
+    end
+
+  end
+end

data/lib/search_enjoy/searching.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative './query'
+
+module SearchEnjoy
+  module Searching
+    def self.included(base)
+      base.class_eval do
+        # include InstanceMethods
+        extend ClassMethods
+      end
+    end
+
+    class Comparator
+      def initialize(conditions)
+        if conditions.instance_of? Query
+          conditions = conditions.to_hash
+        end
+
+        @conditions = conditions
+      end
+
+      def compare(subject, conditions = @conditions)
+        return false unless check_must_conditions(subject, conditions)
+        return false unless check_should_conditions(subject, conditions)
+
+        true
+      end
+
+      def check_must_conditions(subject, conditions)
+        conditions.each_pair do |attr, condition|
+          next unless condition[:must]
+
+          result = check_condition(subject[attr], condition[:value])
+
+          result = !result if condition[:inverse]
+
+          return false unless result
+        end
+
+        true
+      end
+
+      def check_should_conditions(subject, conditions)
+        conditions.each_pair do |attr, condition|
+          next if condition[:must]
+
+          result = check_condition(subject[attr], condition[:value])
+
+          result = !result if condition[:inverse]
+
+          return true if result
+        end
+
+        false
+      end
+
+      def check_condition(condition_subject, condition_body)
+        if condition_body.instance_of? Hash
+          compare(condition_subject, condition_body)
+        elsif condition_body.instance_of? Array
+          condition_body.include? condition_subject
+        else
+          condition_subject == condition_body
+        end
+      end
+    end
+
+    class SearchException < RuntimeError; end
+
+    module ClassMethods
+      def search(*args)
+        conditions = if args.first.instance_of? Query
+                       args.first.query_hash
+                     else
+                       Query.new({**args.first}).query_hash
+                     end
+
+        previous_result = args.last if args.last.instance_of? QueryResult
+
+        comparator = Comparator.new(conditions)
+
+        source = previous_result.nil? ? search_index.values : previous_result
+
+        result = source.select { |object| comparator.compare(object) }
+
+        QueryResult.new(self, result)
+      end
+
+      def search_not(*args)
+        query = if args.first.instance_of? Query
+                  args.first.inverse!
+                else
+                  Query.new(args.first, must: true, inverse: true)
+                end
+
+        result = search(query, args[1..])
+
+        QueryResult.new(self, result)
+      end
+
+      def search_must(*args)
+        raise SearchException, 'Forbidden use Query in search_must' if args.first.instance_of? Query
+
+        query = Query.new(args.first, must: true)
+
+        result = search(query, args[1..])
+
+        QueryResult.new(self, result)
+      rescue StandardError => e
+        e.message
+      end
+
+      def search_must_not(*args)
+        raise SearchException, 'Forbidden use Query in search_must_not' if args.first.instance_of? Query
+
+        query = Query.new(args.first, inverse: true)
+
+        result = search(query, args[1..])
+
+        QueryResult.new(self, result)
+      rescue StandardError => e
+        e.message
+      end
+    end
+  end
+end

data/lib/search_enjoy/version.rb

@@ -0,0 +1,3 @@
+module SearchEnjoy
+  VERSION = '0.1.1'
+end

data/lib/temp.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'search_enjoy'
+
+class DummyIndexingModel
+  include SearchEnjoy
+
+  attr_accessor :id, :attr1, :attr2, :attr3,
+                :attr4, :attr5, :attr6, :attr7, :attr8
+
+  define_json_schema do
+    attr1 :integer
+    attr4 :float
+    attr5 :integer
+    attr6 :array do
+      array_type :integer
+    end
+
+    attr7 :string
+
+    attr8 :hash do
+      key_1 :integer
+      key_2 :float
+    end
+
+    attr2 :array do
+      array_type :string
+    end
+
+    attr3 :hash do
+      hash_key :key_1, :string
+      hash_key :key_2, :array do
+        array_type :string
+      end
+    end
+  end
+
+  def initialize(id, attr1, attr2, attr3)
+    @id = id
+    @attr1 = attr1
+    @attr2 = attr2
+    @attr3 = attr3
+    @attr4 = (attr1 + 2).to_f / 3
+    @attr5 = attr1 * 4
+    @attr6 = [attr1, @attr5, @attr5 - attr1]
+    @attr7 = "test_#{@attr5}"
+    @attr8 = { key_1: attr1 - 4, key_2: @attr5 * 0.22 }
+  end
+end
+
+DummyIndexingModel.create_index!
+
+test_collection = []
+
+1.upto 1000 do |i|
+  arr = [i.to_s, (i + 1).to_s, (i * 2).to_s]
+  hash = { key_1: (i % 3).to_s, key_2: arr }
+  test_collection << DummyIndexingModel.new(i, i % 2, arr, hash)
+end
+
+test_collection.each(&:index_object)
+def test_search
+  DummyIndexingModel.search
+end

metadata

@@ -0,0 +1,53 @@
+--- !ruby/object:Gem::Specification
+name: search_enjoy
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Shmorgun Egor
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-12-02 00:00:00.000000000 Z
+dependencies: []
+description: Search with Enjoy
+email: egor@shmorgun.ru
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/search_enjoy.rb
+- lib/search_enjoy/aggregation.rb
+- lib/search_enjoy/configuration.rb
+- lib/search_enjoy/dumping.rb
+- lib/search_enjoy/indexing.rb
+- lib/search_enjoy/query.rb
+- lib/search_enjoy/schema.rb
+- lib/search_enjoy/search_index.rb
+- lib/search_enjoy/searching.rb
+- lib/search_enjoy/version.rb
+- lib/temp.rb
+homepage: https://github.com/LarsWl/SearchEnjoy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.4
+signing_key: 
+specification_version: 4
+summary: Search with Enjoy!
+test_files: []