redis-carpenter 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 36fa517aa7da760815bbab42b65fba356ea4eaf3c910cb9e87747a37d41dad5f
+  data.tar.gz: 30abb4f3d5d5931bef970cb8b3d427aa194a1ad73b5b15579fad1c68c9638202
+SHA512:
+  metadata.gz: 74856cb76b3a2bc12342d3c49c03ad6117ab5679c0dd68f7623cc6e41b761225f07cf4e0aaacb5fcb76e04cbebce13ba26eb6e7f8723d7391270b784424d9943
+  data.tar.gz: 89d5b4dd357f0d9bc7163ed7d34956e5eb8f7cb83b10d8e935436dbd4520f55a2e98beecb4e71a93967e39094c8190a49ed31750371572e4bca72ffc4d684d2a

data/README.md

@@ -0,0 +1,170 @@
+# Usage
+
+Include `Carpenter::Model` to your class and define any params and fields you need.
+
+```ruby
+class Example
+  include Carpenter::Model
+
+  param :id
+
+  field :first, :integer
+  field :second
+end
+```
+
+After this, you can get and set values in redis via the model.
+
+```ruby
+Example[1].first # => nil
+Example[1].first = 10
+Example[1].first # => 10
+Example[2].first # => nil
+```
+
+`field` can be one of:
+- string
+- integer
+- float
+- array
+- json
+- redis_list
+
+When defining `field` you can pass some options:
+- default (default: nil)  
+Use this to define a default value when getting if such a key does not exist in redis.
+
+```ruby
+class Example
+  include Carpenter::Model
+
+  param :id
+
+  field :first, :integer, default: 100
+  field :second
+end
+
+Example[1].first # => 100
+Example[1].first = 10
+Example[1].first # => 10
+Example[2].first # => 100
+
+```
+
+- store (default: false)  
+Use this to toggle automatic updating of stored value ​​when getting. 
+
+```ruby
+class Example
+  include Carpenter::Model
+
+  param :id
+
+  field :first, :integer, store: true
+  field :second
+end
+
+ex = Example[1]
+ex.first # => nil
+ex.first = 10
+ex.first # => 10
+ex.first = 20
+ex.first # => 10
+ex.first.reload
+ex.first # => 20
+
+```
+
+
+# Processing pipeline
+
+## Step 1. Class definition
+1. Collect all params
+2. Define class key (use defined params)
+3. Collect all fields (use class key)
+
+### Class definition example:
+
+```ruby
+class Example
+  include Carpenter::Model
+
+  param :id
+  param :id2
+
+  field :first
+  field :second
+end
+```
+
+### After definition, we have:
+1. Params list of `[:id, :id2]`
+2. Key `Example` with params stab like `Example-{id}-{id2}`
+3. Fields list of `[:first, :second]`. They contain class key and look like `Example-{id}-{id2}:first`
+
+## Step 2. Object initializing
+1. Save given params
+2. Define object key (use class key and apply saved params)
+3. Transfer class fields to object (update present fields key to object key) 
+
+### For past example:
+
+```ruby
+Example[id: 1, id2: 5]
+```
+
+### After initializing, we have:
+1. Saved Params: `{ id: 1, id2: 5 }`
+2. Object Key with saved params: `Example-1-5`
+3. Cloned Fields list (`[:first, :second]`) with updated keys: `Example-1-5:first`
+
+### We can initialize Model with empty params:
+
+```ruby
+Example[id2: 10] #=> This creates key like "Example-@-10"
+```
+
+#### *Any empty params will be replaced to `@`
+
+### We also can initialize Model with positional arguments:
+```ruby
+Example[1, 5] #=> "Example-1-5"
+# OR
+Example[nil, 10] #=> "Example-@-10"
+# OR
+Example[8] #=> "Example-8-@"
+```
+
+#### In this case, params will be filled in order at definition
+
+
+
+## Type `redis_list` examples
+```ruby
+
+  class Example
+    include Carpenter::Model
+
+    param :id
+
+    field :redis_list, :redis_list
+  end
+
+  Example[1].redis_list #=> []
+  Example[1].redis_list.get #=> []
+
+  Example[1].redis_list = [1, 2, 3]
+  Example[1].redis_list.get #=> [1, 2, 3]
+  Example[1].redis_list[1] #=> 2
+  Example[1].redis_list[1..2] #=> [2, 3]
+  Example[1].redis_list[1...2] #=> [2]
+
+  Example[1].redis_list[1] = 10
+  Example[1].redis_list.get #=> [1, 10, 3]
+
+  Example[1].redis_list << 200
+  Example[1].redis_list.get #=> [1, 10, 3, 200]
+
+  Example[1].redis_list << { email: 'example@mail.ru' }
+  Example[1].redis_list.get #=> [1, 10, 3, 200, { email: 'example@mail.ru' }]
+```

data/lib/carpenter/model/accessor.rb

@@ -0,0 +1,26 @@
+module Carpenter::Model::Accessor
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.prepend(PrependMethods)
+  end
+
+  module ClassMethods
+    def [](*args, **params)
+      instance = new(carpenter_initializing: true)
+      instance.initialize_params(*args, **params)
+      instance.initialize_key
+      instance.initialize_fields
+      instance
+    end
+  end
+
+  module PrependMethods
+    def initialize(*args, **params, &block)
+      raise 'Default initialize not accessed' unless params[:carpenter_initializing]
+
+      params.delete(:carpenter_initializing)
+      super(*args, **params, &block)
+    end
+  end
+
+end

data/lib/carpenter/model/attributes_container.rb

@@ -0,0 +1,29 @@
+class Carpenter::Model::AttributesContainer
+
+  def initialize(container = nil)
+    @attributes = {}
+    return if container.nil?
+
+    container.values.each do |value|
+      add_attribute(value.dup)
+    end
+  end
+
+  def [](name)
+    raise "Attribute with name #{name} not exists" unless @attributes[name]
+
+    @attributes[name]
+  end
+
+  def add_attribute(attribute)
+    name = attribute.name
+    raise "Attribute with name #{name} already exists" if @attributes[name]
+
+    @attributes[name] = attribute
+    attribute
+  end
+
+  def <<(attribute) = add_attribute(attribute)
+  def values = @attributes.values
+  def dup = self.class.new(self)
+end

data/lib/carpenter/model/field.rb

@@ -0,0 +1,22 @@
+require 'carpenter/model/type_caster'
+require 'carpenter/model/strategy'
+
+class Carpenter::Model::Field
+  attr_reader :name, :options, :key, :type
+
+  def initialize(field_definition, key)
+    @name = field_definition.name
+    @type = field_definition.type
+    @type_caster = Carpenter::Model::TypeCaster[@type]
+    @key = [key, @name].join(':')
+    @definition = field_definition
+
+    options = field_definition.options
+    @force = options[:force].nil? ? false : options[:force]
+    @store = options[:store].nil? ? false : options[:store]
+    @default = options[:default]
+    @options = options
+
+    extend Carpenter::Model::Strategy[@type]
+  end
+end

data/lib/carpenter/model/field_definition.rb

@@ -0,0 +1,17 @@
+require 'carpenter/model/type_caster'
+
+class Carpenter::Model::FieldDefinition
+  attr_reader :name, :options, :type
+
+  def initialize(name, type, **options)
+    @name = name
+    @type = type
+    @options = options
+  end
+
+  def dup = self.class.new(name, type, **options)
+  def to_s = @name.to_s
+  def inspect = @name.inspect
+
+  def create_instance(key) = Carpenter::Model::Field.new(self, key)
+end

data/lib/carpenter/model/modules/fields.rb

@@ -0,0 +1,48 @@
+require 'carpenter/model/attributes_container'
+
+module Carpenter::Model::Modules::Fields
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def fields = @carpenter__model__fields.values
+
+  def initialize_fields
+    @carpenter__model__fields = Carpenter::Model::AttributesContainer.new
+
+    self.class.fields.each do |field_definition|
+      @carpenter__model__fields << field_definition.create_instance(key)
+    end
+  end
+
+  module ClassMethods
+    def self.extended(base)
+      base.instance_variable_set(:@carpenter__model__fields, Carpenter::Model::AttributesContainer.new)
+    end
+
+    def fields = @carpenter__model__fields.values
+
+    def inherited(klass)
+      klass.instance_variable_set(:@carpenter__model__fields, @carpenter__model__fields.dup)
+      super
+    end
+
+    def field(name, type = :string, **options)
+      carpenter__model__create_field(name, type, **options)
+      carpenter__model__define_field_getter(name)
+      carpenter__model__define_field_setter(name)
+    end
+
+    def carpenter__model__create_field(name, type, **options)
+      @carpenter__model__fields << Carpenter::Model::FieldDefinition.new(name, type, **options)
+    end
+
+    def carpenter__model__define_field_getter(name)
+      define_method(name) { @carpenter__model__fields[name] }
+    end
+
+    def carpenter__model__define_field_setter(name)
+      define_method("#{name}=") { |value| @carpenter__model__fields[name].set(value) }
+    end
+  end
+end

data/lib/carpenter/model/modules/key.rb

@@ -0,0 +1,30 @@
+module Carpenter::Model::Modules::Key
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def key = @carpenter__model__key
+
+  def initialize_key
+    @carpenter__model__raw_key = self.class.key.dup
+
+    key = @carpenter__model__raw_key
+    @carpenter__model__params.values.each do |v|
+      key = key.gsub("{#{v.name}}", v.value.nil? ? '@' : v.value.to_s)
+    end
+    @carpenter__model__key = key
+  end
+
+  module ClassMethods
+    def self.extended(base)
+      base.instance_variable_set(:@carpenter__model__raw_key, base.name)
+    end
+
+    def key = @carpenter__model__key ||= [@carpenter__model__raw_key, @carpenter__model__params.keys.map { |param| "{#{param}}" } ].join('-')
+
+    def inherited(klass)
+      klass.instance_variable_set(:@carpenter__model__raw_key, klass.name)
+      super
+    end
+  end
+end

data/lib/carpenter/model/modules/params.rb

@@ -0,0 +1,53 @@
+module Carpenter::Model::Modules::Params
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  def params = @carpenter__model__params.values
+
+  def initialize_params(*args, **params)
+    raise 'Ambiguous attributes' if args.any? && params.any?
+
+    @carpenter__model__params = {}
+    params = self.class.instance_variable_get(:@carpenter__model__params).keys.zip(args).to_h if params.empty?
+
+    self.class.instance_variable_get(:@carpenter__model__params).each do |param_name, param_value|
+      param = param_value.dup
+      param.value = params[param_name]
+      raise "Invalid param" unless param.valid?
+
+      @carpenter__model__params[param_name] = param
+    end
+  end
+
+  module ClassMethods
+    def self.extended(base)
+      base.instance_variable_set(:@carpenter__model__params, {})
+    end
+
+    def params = @carpenter__model__params.values
+
+    def inherited(klass)
+      klass.instance_variable_set(:@carpenter__model__params, @carpenter__model__params.dup)
+      super
+    end
+
+    def param(name, **options)
+      carpenter__model__create_param(name, **options)
+      carpenter__model__define_param_getter(name)
+      carpenter__model__define_param_setter(name)
+    end
+
+    def carpenter__model__create_param(name, **options)
+      @carpenter__model__params[name] = Carpenter::Model::Param.new(name, nil, **options)
+    end
+
+    def carpenter__model__define_param_getter(name)
+      define_method(name) { @carpenter__model__params[name] }
+    end
+
+    def carpenter__model__define_param_setter(name)
+      define_method("#{name}=") { |value| @carpenter__model__params[name].set(value) }
+    end
+  end
+end

data/lib/carpenter/model/modules.rb

@@ -0,0 +1,5 @@
+require 'carpenter/model/modules/key'
+require 'carpenter/model/modules/params'
+require 'carpenter/model/modules/fields'
+
+module Carpenter::Model::Modules; end

data/lib/carpenter/model/param.rb

@@ -0,0 +1,20 @@
+class Carpenter::Model::Param
+  attr_reader :name, :options
+  attr_accessor :value
+
+  def initialize(name, value, **options)
+    @name = name
+    @value = value
+    @options = options
+  end
+
+  def dup
+    self.class.new(name, value, **options)
+  end
+
+  def valid?
+    return false if @options[:force] && @value.nil?
+
+    true
+  end
+end

data/lib/carpenter/model/strategy/array.rb

@@ -0,0 +1,22 @@
+module Carpenter::Model::Strategy::Array
+  include Carpenter::Model::Strategy::Base
+  
+  def [](index)
+    data = get
+    data[index]
+  end
+
+  def []=(index, value)
+    data = get
+    data[index] = value
+    set(data)
+    value
+  end
+
+  def <<(value)
+    data = get
+    data << value
+    set(data)
+    value
+  end
+end

data/lib/carpenter/model/strategy/base.rb

@@ -0,0 +1,27 @@
+module Carpenter::Model::Strategy::Base
+  
+  def value
+    if @store
+      @value ||= casted_value
+    else
+      casted_value
+    end
+  end
+
+  def raw_value = Carpenter::REDIS&.get(@key)
+  def casted_value = @type_caster.cast(raw_value) || @default
+
+  def reload = (@value = casted_value if @store)
+
+  def get = value
+
+  def set(value)
+    Carpenter::REDIS&.set(@key, @type_caster.stringify(value))
+  end
+
+  def dup = self.class.new(@definition, @key)
+  def empty? = (value = get) ? value.empty? : true
+  def to_s = get.to_s
+  def inspect = get.inspect
+  def coerce(other) = [other, get]
+end

data/lib/carpenter/model/strategy/json.rb

@@ -0,0 +1,15 @@
+module Carpenter::Model::Strategy::JSON
+  include Carpenter::Model::Strategy::Base
+  
+  def [](key)
+    data = get
+    data[key]
+  end
+
+  def []=(key, value)
+    data = get
+    data[key] = value
+    set(data)
+    value
+  end
+end

data/lib/carpenter/model/strategy/redis_list.rb

@@ -0,0 +1,50 @@
+module Carpenter::Model::Strategy::RedisList
+  
+  def value(first, last)
+    if @store
+      @value ||= casted_value(first, last)
+    else
+      casted_value(first, last)
+    end
+  end
+
+  def raw_value(first, last) = Carpenter::REDIS&.lrange(@key, first, last)
+  def casted_value(first, last) = raw_value(first, last).map { |v| @type_caster.cast(v) } || @default
+
+  def reload(first = 0, last = -1) = (@value = casted_value(first, last) if @store)
+
+  def get(first = 0, last = -1) = value(first, last)
+
+  def [](range)
+    case range
+    when Integer
+      get(range, range).first
+    when Range
+      first = range.begin
+      offset = range.exclude_end? ? 1 : 0
+      last = range.end
+      last = last - offset if last
+      get(first, last)
+    else
+      raise "Unexpected type: #{range.class}"
+    end
+  end
+
+  def []=(index, value)
+    Carpenter::REDIS&.lset(@key, index, @type_caster.stringify(value))
+  end
+
+  def set(value)
+    value = value.is_a?(Array) ? value.map { |v| @type_caster.stringify(v) } : @type_caster.stringify(value)
+
+    Carpenter::REDIS&.del(@key)
+    Carpenter::REDIS&.rpush(@key, value)
+  end
+  
+  def <<(value) = Carpenter::REDIS&.rpush(@key, @type_caster.stringify(value))
+  def dup = self.class.new(@definition, @key)
+  def empty? = (value = get) ? value.empty? : true
+  def to_s = get.to_s
+  def inspect = get.inspect
+  def coerce(other) = [other, get]
+end

data/lib/carpenter/model/strategy.rb

@@ -0,0 +1,27 @@
+# require 'carpenter/model/strategy/string'
+# require 'carpenter/model/strategy/integer'
+require 'carpenter/model/strategy/base'
+require 'carpenter/model/strategy/array'
+require 'carpenter/model/strategy/json'
+require 'carpenter/model/strategy/redis_list'
+
+class Carpenter
+  module Model
+    module Strategy
+
+      STRATEGIES = {
+        base: Base,
+        string: Base,
+        integer: Base,
+        float: Base,
+        array: Array,
+        json: JSON,
+
+        redis_list: RedisList
+      }.freeze
+
+      def self.[](type) = type.is_a?(Symbol) ? STRATEGIES[type] || STRATEGIES[:base] : type
+
+    end
+  end
+end

data/lib/carpenter/model/type_caster/array.rb

@@ -0,0 +1,4 @@
+class Carpenter::Model::TypeCaster::Array
+  def self.stringify(data) = data.to_json
+  def self.cast(data) = data ? JSON.parse(data, symbolize_names: true) : nil
+end

data/lib/carpenter/model/type_caster/float.rb

@@ -0,0 +1,4 @@
+class Carpenter::Model::TypeCaster::Float
+  def self.stringify(data) = data.to_s
+  def self.cast(data) = data ? data.to_f : nil
+end

data/lib/carpenter/model/type_caster/integer.rb

@@ -0,0 +1,4 @@
+class Carpenter::Model::TypeCaster::Integer
+  def self.stringify(data) = data.to_s
+  def self.cast(data) = data ? data.to_i : nil
+end

data/lib/carpenter/model/type_caster/json.rb

@@ -0,0 +1,4 @@
+class Carpenter::Model::TypeCaster::JSON
+  def self.stringify(data) = data.to_json
+  def self.cast(data) = data ? JSON.parse(data, symbolize_names: true) : nil
+end

data/lib/carpenter/model/type_caster/string.rb

@@ -0,0 +1,4 @@
+class Carpenter::Model::TypeCaster::String
+  def self.stringify(data) = data.to_s
+  def self.cast(data) = data
+end

data/lib/carpenter/model/type_caster.rb

@@ -0,0 +1,21 @@
+require 'carpenter/model/type_caster/string'
+require 'carpenter/model/type_caster/integer'
+require 'carpenter/model/type_caster/float'
+require 'carpenter/model/type_caster/array'
+require 'carpenter/model/type_caster/json'
+
+class Carpenter::Model::TypeCaster
+
+  CASTERS = {
+    base: String,
+    string: String,
+    integer: Integer,
+    float: Float,
+    array: Array,
+    json: JSON,
+
+    redis_list: JSON
+  }.freeze
+
+  def self.[](type) = type.is_a?(Symbol) ? CASTERS[type] || CASTERS[:base] : type
+end

data/lib/carpenter/model.rb

@@ -0,0 +1,27 @@
+require 'carpenter/model/field_definition'
+require 'carpenter/model/field'
+require 'carpenter/model/param'
+
+require 'carpenter/model/modules'
+require 'carpenter/model/accessor'
+
+module Carpenter::Model
+
+  def self.included(base)
+    base.extend(ClassMethods)
+
+    base.include(Modules::Params)
+    #=>
+    base.include(Modules::Key)
+    #=>
+    base.include(Modules::Fields)
+
+    base.include(Accessor)
+  end
+
+  module ClassMethods
+    def self.extended(base); end
+
+  end
+
+end

data/lib/carpenter/redis.rb

@@ -0,0 +1,6 @@
+class Carpenter
+  REDIS = nil
+
+  def self.setup_redis(**options) = const_set(:REDIS, Redis.new(**options))
+  def self.use_redis(redis) = const_set(:REDIS, redis)
+end

data/lib/carpenter/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class Carpenter
+  VERSION = '0.0.1'
+end

data/lib/carpenter.rb

@@ -0,0 +1,10 @@
+require 'json'
+
+require 'struct_declaration'
+
+require 'carpenter/version'
+require 'carpenter/redis'
+
+require 'carpenter/model'
+
+class Carpenter; end

data/lib/struct_declaration.rb

@@ -0,0 +1,31 @@
+class Carpenter
+  module Model
+    class AttributesContainer; end
+
+    class ParamDefinition; end
+    class Param; end
+
+    class Field; end
+    module Accessor; end
+
+    module Modules
+      module Params; end
+      module Key; end
+      module Fields; end
+    end
+
+    class TypeCaster
+      class String; end
+      class Integer; end
+      class Float; end
+      class Array; end
+      class JSON; end
+    end
+
+    module Strategy
+      module Base; end
+      module Array; end
+      module JSON; end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# See https://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+require 'rspec'
+
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # This allows you to limit a spec run to individual examples or groups
+  # you care about by tagging them with `:focus` metadata. When nothing
+  # is tagged with `:focus`, all examples get run. RSpec also provides
+  # aliases for `it`, `describe`, and `context` that include `:focus`
+  # metadata: `fit`, `fdescribe` and `fcontext`, respectively.
+  config.filter_run_when_matching :focus
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  # https://rspec.info/features/3-12/rspec-core/configuration/zero-monkey-patching-mode/
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = "doc"
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

data/spec/test_redis_list.rb

@@ -0,0 +1,35 @@
+
+class Example
+  include Carpenter::Model
+
+  param :id
+
+  field :array, :redis_list
+end
+
+RSpec.describe Carpenter do
+
+  context 'test redis_list type' do
+
+    it 'getter/setter' do
+      expect(Example[1].array.get).to eq([])
+
+      Example[1].array = [1, 2, 3]
+
+      expect(Example[1].array.get).to eq([1, 2, 3])
+      expect(Example[1].array[1]).to eq(2)
+      expect(Example[1].array[1..2]).to eq([2, 3])
+      expect(Example[1].array[1...2]).to eq([2])
+
+      Example[1].array[1] = 10
+      expect(Example[1].array.get).to eq([1, 10, 3])
+
+      expect { Example[1].array[:a] }.to raise_error(StandardError)
+      Example[1].array << 200
+      expect(Example[1].array.get).to eq([1, 10, 3, 200])
+      Example[1].array << {email: 'example@mail.ru'}
+      expect(Example[1].array.get).to eq([1, 10, 3, 200, {email: 'example@mail.ru'}])
+    end
+
+  end
+end

data/spec/tests.rb

@@ -0,0 +1,172 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require './spec/spec_helper'
+require 'carpenter'
+require 'fakeredis'
+
+Carpenter.setup_redis
+
+class Res
+  include Carpenter::Model
+
+  param :id
+
+  field :first, :integer, force: true
+  field :second, :string, store: true
+  field :array, :array, default: []
+  field :json, :json, default: {}
+
+end
+
+class Res2 < Res
+
+  param :id2
+
+  field :last, :integer
+
+end
+
+RSpec.configure do |config|
+  config.before(:each) do
+    Carpenter::REDIS.flushdb
+  end
+end
+
+RSpec.describe Carpenter do
+  context 'test base accessors' do
+    it 'test keys' do
+      expect(Res.key).to eq('Res-{id}')
+      expect(Res2.key).to eq('Res2-{id}-{id2}')
+    end
+
+    it 'test params' do
+      expect(Res.params.map(&:name)).to eq([:id])
+      expect(Res2.params.map(&:name)).to eq(%i[id id2])
+    end
+
+    it 'test fields' do
+      expect(Res.fields.map(&:name)).to eq(%i[first second array json])
+      expect(Res2.fields.map(&:name)).to eq(%i[first second array json last])
+    end
+  end
+
+  context 'test instances' do
+    it 'test keys' do
+      expect(Res[id: 1].key).to eq('Res-1')
+      expect(Res[2].key).to eq('Res-2')
+      expect(Res[].key).to eq('Res-@')
+      expect(Res2[id: 2].key).to eq('Res2-2-@')
+      expect(Res2[id2: 2].key).to eq('Res2-@-2')
+      expect(Res2[0].key).to eq('Res2-0-@')
+      expect(Res2[8, 10].key).to eq('Res2-8-10')
+      expect(Res2[id: 3].key).to eq('Res2-3-@')
+      expect(Res2[id: 5, id2: 6].key).to eq('Res2-5-6')
+    end
+
+    it 'test params' do
+      expect(Res[1].params.map(&:name)).to eq([:id])
+      expect(Res2[10].params.map(&:name)).to eq(%i[id id2])
+    end
+
+    it 'test fields' do
+      expect(Res[1].fields.map(&:name)).to eq(%i[first second array json])
+      expect(Res2[10].fields.map(&:name)).to eq(%i[first second array json last])
+    end
+
+    it 'test field keys' do
+      expect(Res[1].first.key).to eq('Res-1:first')
+      expect(Res[10].second.key).to eq('Res-10:second')
+      expect(Res2[10].first.key).to eq('Res2-10-@:first')
+      expect(Res2[10, 1].last.key).to eq('Res2-10-1:last')
+    end
+
+    it 'test getters/setters' do
+      expect(Res[1].first.get).to eq(nil)
+      expect(Res[1].first.inspect).to eq('nil')
+      expect(Res[1].first.to_s).to eq('')
+
+      Res[1].first = 10
+
+      expect(Res[1].first.get).to eq(10)
+      expect(Res[1].first.inspect).to eq('10')
+      expect(Res[1].first.to_s).to eq('10')
+
+      expect(Res[1].second.get).to eq(nil)
+      expect(Res[2].first.get).to eq(nil)
+
+      Res[1].second.set(100)
+
+      expect(Res[1].second.get).to eq('100')
+      expect(Res[2].first.get).to eq(nil)
+      expect(Res[2].second.get).to eq(nil)
+
+      # =======
+
+      expect(Res2[1].first.get).to eq(nil)
+      expect(Res2[1].first.inspect).to eq('nil')
+      expect(Res2[1].first.to_s).to eq('')
+
+      Res2[1].first = 10
+
+      expect(Res2[1].first.get).to eq(10)
+      expect(Res2[1].first.inspect).to eq('10')
+      expect(Res2[1].first.to_s).to eq('10')
+
+      expect(Res2[1].second.get).to eq(nil)
+      expect(Res2[2].first.get).to eq(nil)
+
+      Res2[1].second.set(100)
+
+      expect(Res2[1].second.get).to eq('100')
+      expect(Res2[2].first.get).to eq(nil)
+      expect(Res2[2].second.get).to eq(nil)
+
+    end
+
+    it 'test options' do
+      expect(Res[id: 1].second.options.keys).to eq([:store])
+      expect(Res2[1, 2].last.options.keys).to eq([])
+    end
+
+    it 'test reload option' do
+      example = Res[id: 1]
+      expect(example.second.get).to eq(nil)
+
+      example.second = 100
+      expect(example.second.get).to eq('100')
+
+      example.second = 1000
+      expect(example.second.get).to eq('100')
+
+      example.second.reload
+      expect(example.second.get).to eq('1000')
+    end
+
+    it 'test array field' do
+      expect(Res[1].array.get).to eq([])
+      Res[1].array = [1, 2, 3]
+      expect(Res[1].array.get).to eq([1, 2, 3])
+      Res[1].array[1] = 10
+      expect(Res[1].array.get).to eq([1, 10, 3])
+      expect(Res[1].array[1]).to eq(10)
+      expect(Res[1].array[-1]).to eq(3)
+      expect(Res[1].array[10]).to eq(nil)
+      expect { Res[1].array[:a] }.to raise_error(TypeError)
+      Res[1].array << 200
+      expect(Res[1].array.get).to eq([1, 10, 3, 200])
+    end
+
+    it 'test json field' do
+      expect(Res[1].json.get).to eq({})
+      Res[1].json = {a: 1}
+      expect(Res[1].json.get).to eq({a: 1})
+      Res[1].json[:b] = 10
+      expect(Res[1].json.get).to eq({a: 1, b: 10})
+      expect(Res[1].json[:b]).to eq(10)
+      expect(Res[1].json[:ab]).to eq(nil)
+      expect(Res[1].json[0]).to eq(nil)
+    end
+  end
+end
+
+require './spec/test_redis_list'

metadata

@@ -0,0 +1,88 @@
+--- !ruby/object:Gem::Specification
+name: redis-carpenter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Abvgdeyoj
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2025-04-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.7'
+description: Simple ORM for Redis
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/carpenter.rb
+- lib/carpenter/model.rb
+- lib/carpenter/model/accessor.rb
+- lib/carpenter/model/attributes_container.rb
+- lib/carpenter/model/field.rb
+- lib/carpenter/model/field_definition.rb
+- lib/carpenter/model/modules.rb
+- lib/carpenter/model/modules/fields.rb
+- lib/carpenter/model/modules/key.rb
+- lib/carpenter/model/modules/params.rb
+- lib/carpenter/model/param.rb
+- lib/carpenter/model/strategy.rb
+- lib/carpenter/model/strategy/array.rb
+- lib/carpenter/model/strategy/base.rb
+- lib/carpenter/model/strategy/json.rb
+- lib/carpenter/model/strategy/redis_list.rb
+- lib/carpenter/model/type_caster.rb
+- lib/carpenter/model/type_caster/array.rb
+- lib/carpenter/model/type_caster/float.rb
+- lib/carpenter/model/type_caster/integer.rb
+- lib/carpenter/model/type_caster/json.rb
+- lib/carpenter/model/type_caster/string.rb
+- lib/carpenter/redis.rb
+- lib/carpenter/version.rb
+- lib/struct_declaration.rb
+- spec/spec_helper.rb
+- spec/test_redis_list.rb
+- spec/tests.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubygems_version: 3.3.3
+signing_key: 
+specification_version: 4
+summary: Simple ORM for Redis
+test_files:
+- spec/spec_helper.rb
+- spec/test_redis_list.rb
+- spec/tests.rb