simple-redis-orm 0.1.0

data/lib/simple-redis-orm/entry.rb

@@ -0,0 +1,71 @@
+module SimpleRedisOrm
+  class NotConnected < StandardError; end
+
+  class Entry < Dry::Struct
+    include Helpers::CoreCommands
+    extend Helpers::CoreCommands::ClassMethods
+
+    attribute :key, Types::String
+
+    def id
+      self.class.without_redis_key_prefix(key)
+    end
+
+    class << self
+      def new(id:, **attributes)
+        attrs_with_defaults = fill_in_missing_keys(**attributes)
+        super(key: id, **attrs_with_defaults)
+      end
+
+      def create(id:, **attributes)
+        new(id: id, **attributes).save
+      end
+
+      def find(id)
+        value = read_by(id)
+        return if value.nil?
+
+        new(id: id, **value)
+      end
+
+      def redis
+        @redis || raise(NotConnected, "#{name}.redis not set to a Redis.new connection pool")
+      end
+
+      def redis=(conn)
+        @redis = ConnectionPoolProxy.proxy_if_needed(conn)
+      end
+
+      def without_redis_key_prefix(id)
+        return if id.nil?
+
+        id.gsub(/^(.*):/, '')
+      end
+
+      private
+
+      def fill_in_missing_keys(**attributes)
+        keys = attribute_names - [:key]
+        missing_keys = keys - attributes.keys
+        return attributes if missing_keys.empty?
+
+        missing_hash = missing_keys.to_h { |x| [x, nil] }
+        missing_hash.merge(attributes)
+      end
+    end
+
+    def attributes
+      super.except(:key)
+    end
+
+    def redis
+      Entry.redis
+    end
+
+    def save
+      set_hash(attributes.except(:key))
+
+      self
+    end
+  end
+end

data/lib/simple-redis-orm/helpers/core_commands.rb

@@ -0,0 +1,96 @@
+module SimpleRedisOrm
+  module Helpers
+    module CoreCommands
+      include Serializer
+
+      module ClassMethods
+        include Serializer
+
+        def read_by(key)
+          type = redis.type key
+          return if type.nil? || type == 'none'
+          return read_hash(key) if type == 'hash'
+
+          read_value(key)
+        end
+
+        def read_hash(key)
+          value = redis.hgetall(key)
+          deserialize_value(value)
+        end
+
+        def read_value(key)
+          value = redis.get(key)
+          return if value.nil?
+
+          deserialize_value(value)
+        end
+      end
+
+      def read
+        type = redis.type key
+        return if type.nil?
+
+        return read_hash if type == 'hash'
+
+        read_value
+      end
+
+      def read_hash
+        value = redis.hgetall(key)
+
+        deserialize_value(value)
+      end
+
+      def read_value
+        value = redis.get(key)
+        deserialize_value(value)
+      end
+
+      def set(value)
+        return set_hash(value) if value.is_a?(Hash)
+
+        redis.set key, serialize_value(value)
+        nil
+      end
+
+      # rubocop:disable Naming/AccessorMethodName
+      def set_hash(hash)
+        raise ArgumentError, "'hash_value' must be a hash, found type: #{hash_value.class.name}" unless hash.is_a?(Hash)
+
+        hash.each_pair { |sub_key, value| set_subhash(sub_key, value) }
+        nil
+      end
+      # rubocop:enable Naming/AccessorMethodName
+
+      def exists
+        redis.exists key
+      end
+
+      def exists?
+        redis.exists? key
+      end
+
+      def expire(seconds)
+        redis.expire key, seconds
+      end
+
+      def ttl
+        redis.ttl(key)
+      end
+
+      def read_subhash(field)
+        value = redis.hget(key, field)
+        return if value.nil?
+
+        deserialize_value(value)
+      end
+
+      def set_subhash(field, value)
+        redis.hset(key, field, serialize_value(value))
+
+        nil
+      end
+    end
+  end
+end

data/lib/simple-redis-orm/helpers/serializer.rb

@@ -0,0 +1,45 @@
+module SimpleRedisOrm
+  module Helpers
+    module Serializer
+      def serialize_value(value)
+        return value if value.nil?
+
+        MessagePack.pack(value)
+      end
+
+      def deserialize_value(value)
+        return if value.nil?
+
+        return deserialize_hash_value(value) if value.is_a?(Hash)
+
+        MessagePack.unpack(value)
+      end
+
+      # rubocop:disable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+      def deserialize_hash_value(hash)
+        return if hash.nil?
+
+        hash.transform_values do |v|
+          next v if v.nil?
+          next v unless v.is_a?(String)
+          next v unless v.encoding == Encoding::ASCII_8BIT
+
+          v.strip.empty? ? v : MessagePack.unpack(v)
+        rescue StandardError => e
+          next without_invalid_characters(v) if e.instance_of?(ArgumentError)
+
+          raise e
+        end.deep_symbolize_keys
+      end
+      # rubocop:enable Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity
+
+      private
+
+      def without_invalid_characters(text)
+        return text unless text.is_a?(String)
+
+        text.chars.select(&:valid_encoding?).join
+      end
+    end
+  end
+end

data/lib/simple-redis-orm/types.rb

@@ -0,0 +1,5 @@
+module SimpleRedisOrm
+  module Types
+    include Dry.Types
+  end
+end

data/lib/simple-redis-orm/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SimpleRedisOrm
+  VERSION = "0.1.0"
+end

data/lib/simple-redis-orm.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+require 'active_support/core_ext/hash'
+require 'active_support/core_ext/string'
+
+require "simple-redis-orm/version"
+require "simple-redis-orm/types"
+require "simple-redis-orm/helpers/serializer"
+require "simple-redis-orm/helpers/core_commands"
+require "simple-redis-orm/entry"
+require "simple-redis-orm/application_entry"
+
+module SimpleRedisOrm; end

data/sig/simple-redis-orm.rbs

@@ -0,0 +1,4 @@
+module SimpleRedisOrm
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

data/simple-redis-orm.gemspec

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require File.expand_path('../lib/simple-redis-orm/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors = ["Desmond O'Leary"]
+  gem.email = ["desoleary@gmail.com"]
+  gem.description = %q{Simple ORM backed with redis store}
+  gem.summary = %q{Simple ORM backed with redis store}
+  gem.homepage = "https://github.com/omnitech-solutions/simple-redis-orm"
+  gem.license = "MIT"
+
+  gem.files = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^exe/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(spec|features)/})
+  gem.name = "simple-redis-orm"
+  gem.require_paths = ["lib"]
+  gem.version = SimpleRedisOrm::VERSION
+  gem.required_ruby_version = ">= 2.6.0"
+
+  gem.metadata["homepage_uri"] = gem.homepage
+  gem.metadata["source_code_uri"] = gem.homepage
+  gem.metadata["changelog_uri"] = "#{gem.homepage}/CHANGELOG.md"
+
+  gem.add_runtime_dependency 'activesupport', '~> 6.1', '>= 6.1.7.2'
+  gem.add_runtime_dependency 'redis', '~> 4.0', '>= 4.0'
+  gem.add_runtime_dependency 'dry-struct', '~> 1.6'
+  gem.add_runtime_dependency 'msgpack', '~> 1.6', '>= 1.6'
+  gem.add_runtime_dependency 'connection_pool', '~> 2.3', '>= 2.3'
+
+  gem.add_development_dependency "rake", "~> 13.0.6"
+  gem.add_development_dependency "rspec", "~> 3.12.0"
+  gem.add_development_dependency "simplecov", "~> 0.21.2"
+  gem.add_development_dependency "codecov", "~> 0.6.0"
+  gem.add_development_dependency "mock_redis", "~> 0.36.0"
+end

data/spec/coverage_helper.rb

@@ -0,0 +1,12 @@
+if ENV['RUN_COVERAGE_REPORT']
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter 'vendor/'
+    add_filter %r{^/spec/}
+  end
+  SimpleCov.minimum_coverage_by_file 90
+
+  require 'codecov'
+  SimpleCov.formatter = SimpleCov::Formatter::Codecov
+end

data/spec/redis_spec_helper.rb

@@ -0,0 +1,9 @@
+RSpec.configure do |config|
+  config.before(:suite) do
+    SimpleRedisOrm::Entry.redis = MockRedis.new
+  end
+
+  config.before do
+    SimpleRedisOrm::Entry.redis.flushdb
+  end
+end

data/spec/simple-redis-orm/application_entry_spec.rb

@@ -0,0 +1,55 @@
+# rubocop:disable RSpec/FilePath
+#
+module SimpleRedisOrm
+  RSpec.describe ApplicationEntry do
+    let(:subject_class) do
+      Class.new(ApplicationEntry) do
+        attribute :email, Types::String.optional
+
+        class << self
+          def new(id:, **attributes)
+            super(id: id, **attributes.merge(email: without_redis_key_prefix(id)))
+          end
+
+          def create(email:)
+            attrs = { email: email }
+
+            new(id: email, **attrs).save
+          end
+
+          def name
+            'SomeModel'
+          end
+
+          def redis
+            Entry.redis
+          end
+        end
+      end
+    end
+
+    describe '.new' do
+      it 'add redis entry' do
+        user = subject_class.new(id: 'desoleary@gmail.com')
+        user.save
+
+        actual = subject_class.find('desoleary@gmail.com')
+        expect(actual.attributes).to eql({ email: 'desoleary@gmail.com' })
+      end
+    end
+
+    describe '.create' do
+      let(:email) { 'email@domain.com' }
+
+      it 'add redis entry' do
+        subject_class.create(email: email)
+
+        user = subject_class.find(email)
+        expect(user.key).to eql("some_model:#{email}")
+        expect(user.id).to eql(email)
+        expect(user.email).to eql(email)
+      end
+    end
+  end
+end
+# rubocop:enable RSpec/FilePath

data/spec/simple-redis-orm/entry_spec.rb

@@ -0,0 +1,59 @@
+# rubocop:disable RSpec/FilePath
+
+module SimpleRedisOrm
+  RSpec.describe Entry do
+    let(:subject_class) do
+      Class.new(Entry) do
+        attribute :password, Types::String.optional
+
+        def self.redis
+          Entry.redis
+        end
+      end
+    end
+
+    let(:id) { 'some-key' }
+    let(:attributes) { { password: 'some-password' } }
+    let(:instance) { subject_class.new(id: 'desoleary@gmail.com', **attributes) }
+
+    subject(:entry) { instance.save }
+
+    describe '.new' do
+      it 'initializes instance' do
+        instance = subject_class.new(id: id, **attributes)
+
+        expect(instance.id).to eql(id)
+        expect(instance.read).to be_nil
+      end
+    end
+
+    describe '.save' do
+      it 'initializes instance' do
+        instance.save
+
+        expect(instance.read).to eql(attributes)
+      end
+    end
+
+    describe '.create' do
+      it 'stores record' do
+        actual = subject_class.create(id: id, **attributes)
+
+        expect(actual.id).to eql(id)
+
+        entry = subject_class.find(id)
+        expect(entry.attributes).to eql(attributes)
+      end
+    end
+
+    describe '.find' do
+      it 'stores hash data into redis store' do
+        entry
+
+        actual = subject_class.find('desoleary@gmail.com')
+        expect(actual.attributes).to eql(attributes)
+      end
+    end
+  end
+end
+# rubocop:enable RSpec/FilePath

data/spec/simple-redis-orm/helpers/class_methods_spec.rb

@@ -0,0 +1,4 @@
+module SimpleRedisOrm
+  module Helpers
+  end
+end

data/spec/simple-redis-orm/helpers/core_commands_spec.rb

@@ -0,0 +1,73 @@
+# rubocop:disable RSpec/FilePath
+module SimpleRedisOrm
+  module Helpers
+    RSpec.describe CoreCommands do
+      let(:subject_class) do
+        Class.new(Dry::Struct) do
+          include CoreCommands
+          extend CoreCommands::ClassMethods
+
+          attribute :key, Types::String
+
+          def redis
+            self.class.redis
+          end
+
+          class << self
+            def redis
+              @redis ||= MockRedis.new
+            end
+          end
+        end
+      end
+
+      let(:key) { 'some-key' }
+      let(:field) { :field }
+      let(:field_value) { 'some-value' }
+      let(:hash_value) { { field => field_value } }
+      let(:other_field) { :other_field }
+      let(:other_value) { 'other_value' }
+      let(:instance) { subject_class.new(key: key) }
+
+      subject(:redis_command) do
+        instance.set_hash(hash_value)
+        instance
+      end
+
+      describe 'ClassMethods' do
+        describe '.read_value' do
+          before { instance.set(other_value) }
+
+          it 'returns set simple value' do
+            actual = subject_class.read_value(key)
+
+            expect(actual).to eql(other_value)
+          end
+        end
+
+        describe '.read_hash' do
+          it 'returns original hash value' do
+            redis_command
+
+            expect(subject_class.read_hash(key)).to eql(hash_value)
+          end
+        end
+
+        describe '.read_by' do
+          it 'returns original hash value' do
+            redis_command
+
+            expect(subject_class.read_by(key)).to eql(hash_value)
+          end
+
+          context 'with unexpected key' do
+            it 'returns original hash value' do
+              expect(subject_class.read_by('some-other-key')).to be_nil
+            end
+          end
+        end
+      end
+    end
+  end
+end
+# rubocop:enable RSpec/FilePath

data/spec/simple_redis_orm_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe SimpleRedisOrm do
+  it "has a version number" do
+    expect(SimpleRedisOrm::VERSION).not_to be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require File.join(__dir__, "..", 'dev', 'setup')
+
+require 'redis_spec_helper'
+require 'coverage_helper'
+
+RSpec.configure do |config|
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end