key-vortex 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f16908e843138ceefe28247b31cc1fe6b0a6e4c704174f7af7f98bcf8ac433dd
-  data.tar.gz: 759988a8108b14ca1be504c1a6eeb102b1efc86b970b33c6078fa4290963b67b
+  metadata.gz: 2ef4caa4048de91fa4f99f928fd154c9ae3950a971fb6d8ad34149070f900914
+  data.tar.gz: 179229a1dd86d3e31fa2dca1d43089ab11000625a5260c5aaf8c31c7a691f3c8
 SHA512:
-  metadata.gz: 233359a3b6e85fe314abed09916491de40596ca47ac927dc18587970059c2470ef7071d6346baf67893e14416d041147130e62d2f4698011b81813b951225025
-  data.tar.gz: e4fc5a84f2726d24cbf2362890eb7dcfd2da5a67ad32e8982b73961f8acb0b34a94ff982a0075aa7a119008ead364bfa57608616729875801ac1efa0df44e332
+  metadata.gz: 7c847153af457304066f16e28436a018f289e73b1a929811e506c83d5bfb1da3d45be68a89b6c3781207dd11481753cfd9ec6b95335da58c6a88fc072d65546f
+  data.tar.gz: cfddc7282c2775b03595c679a3369c61584069b2cb961eeb68194ecb9d62fa1c204602611a1be473c410271648bcb3f7fe4b6b8230dacd874e3b2daea66a119a

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    key-vortex (0.1.2)
+    key-vortex (0.1.4)
 
 GEM
   remote: https://rubygems.org/

data/Guardfile

@@ -27,7 +27,7 @@
 #  * 'just' rspec: 'rspec'
 
 group :red_green_refactor, halt_on_fail: true do
-  guard :rspec, cmd: "bundle exec rspec", all_on_pass: true do
+  guard :rspec, cmd: "bundle exec rspec", failed_mode: :focus, all_on_pass: true do
     require "guard/rspec/dsl"
     dsl = Guard::RSpec::Dsl.new(self)
 

data/key-vortex.gemspec

@@ -29,9 +29,6 @@ Gem::Specification.new do |spec|
   spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
-
   # For more information and examples about making a new gem, checkout our
   # guide at: https://bundler.io/guides/creating_gem.html
   spec.metadata["rubygems_mfa_required"] = "true"

data/lib/key_vortex/adapter/memory.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
+require "key_vortex/adapter"
+
 class KeyVortex
   class Adapter
     class Memory < KeyVortex::Adapter
-      def initialize(items)
+      def initialize(items, limitations: [])
         super()
         @items = items
+        limitations.each { |limit| register_limitation(limit) }
       end
 
       def save(record)

data/lib/key_vortex/adapter.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+class KeyVortex
+  class Adapter
+    def initialize
+      @limitations = {}
+    end
+
+    def limitation_for(field)
+      @limitations[field.limitation.type]
+    end
+
+    def register_limitation(limitation)
+      @limitations[limitation.type] = limitation
+    end
+  end
+end

data/lib/key_vortex/constraint/base.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class KeyVortex
+  class Constraint
+    class Base
+      def applies_to?(constraint)
+        attribute == constraint.attribute
+      end
+
+      def within?(constraint)
+        constraint.instance_of?(self.class)
+      end
+
+      def to_s
+        "#{attribute}: #{value}"
+      end
+    end
+  end
+end

data/lib/key_vortex/constraint/length.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "key_vortex/constraint/base"
+
+class KeyVortex
+  class Constraint
+    class Length < KeyVortex::Constraint::Base
+      attr_reader :value
+
+      def initialize(value)
+        super()
+        @value = value
+      end
+
+      def attribute
+        :length
+      end
+
+      def within?(constraint)
+        super && value <= constraint.value
+      end
+    end
+  end
+end

data/lib/key_vortex/constraint/maximum.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "key_vortex/constraint/base"
+
+class KeyVortex
+  class Constraint
+    class Maximum < KeyVortex::Constraint::Base
+      attr_reader :value
+
+      def initialize(value)
+        super()
+        @value = value
+      end
+
+      def attribute
+        :maximum
+      end
+
+      def within?(constraint)
+        super && value <= constraint.value
+      end
+    end
+  end
+end

data/lib/key_vortex/constraint/minimum.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "key_vortex/constraint/base"
+
+class KeyVortex
+  class Constraint
+    class Minimum < KeyVortex::Constraint::Base
+      attr_reader :value
+
+      def initialize(value)
+        super()
+        @value = value
+      end
+
+      def attribute
+        :maximum
+      end
+
+      def within?(constraint)
+        super && value >= constraint.value
+      end
+    end
+  end
+end

data/lib/key_vortex/constraint.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "key_vortex/constraint/base"
+require "key_vortex/constraint/length"
+require "key_vortex/constraint/maximum"
+require "key_vortex/constraint/minimum"
+
+class KeyVortex
+  class Constraint
+    def self.build(attribute, value)
+      case attribute
+      when :length
+        KeyVortex::Constraint::Length.new(value)
+      when :maximum
+        KeyVortex::Constraint::Maximum.new(value)
+      when :minimum
+        KeyVortex::Constraint::Minimum.new(value)
+      else
+        raise KeyVortex::Error, "Unexpected attribute: #{attribute}"
+      end
+    end
+  end
+end

data/lib/key_vortex/field.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "key_vortex/constraint"
+require "key_vortex/limitation"
+
+class KeyVortex
+  class Field
+    attr_reader :name, :limitation
+
+    def initialize(name, type, *constraints_array, **constraints_hash)
+      @name = name
+      @limitation = KeyVortex::Limitation.new(type)
+
+      @limitation.add_constraint(*constraints_array)
+      @limitation.add_constraint(*constraints_hash.map do |attribute, value|
+        KeyVortex::Constraint.build(attribute, value)
+      end)
+    end
+
+    def prohibited_by?(adapter)
+      limitation = adapter.limitation_for(self)
+      limitation&.prohibits?(self.limitation)
+    end
+  end
+end

data/lib/key_vortex/limitation.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+class KeyVortex
+  class Limitation
+    attr_reader :type, :constraints
+
+    def initialize(type, *constraints)
+      @type = type
+      @constraints = constraints
+    end
+
+    def add_constraint(*constraints)
+      constraints.each do |constraint|
+        unless constraint.is_a?(KeyVortex::Constraint::Base)
+          raise KeyVortex::Error,
+                "Not a constraint: #{constraint.class}"
+        end
+      end
+
+      @constraints += constraints
+    end
+
+    def allows?(limitation)
+      @constraints.all? do |constraint|
+        limitation.accomodates?(constraint)
+      end
+    end
+
+    def prohibits?(limitation)
+      !allows?(limitation)
+    end
+
+    def applicable_constraints(constraint)
+      @constraints.select do |con|
+        con.applies_to?(constraint)
+      end
+    end
+
+    def accomodates?(constraint)
+      !applicable_constraints(constraint).select do |con|
+        con.within?(constraint)
+      end.empty?
+    end
+
+    def to_s
+      "Limitation: #{@type}\n\t#{@constraints.join('\n\t')}"
+    end
+  end
+end

data/lib/key_vortex/record.rb

@@ -1,19 +1,40 @@
 # frozen_string_literal: true
 
+require "key_vortex"
+require "key_vortex/constraint"
+require "key_vortex/field"
+require "key_vortex/limitation"
+
 class KeyVortex
   class Record
-    def self.constraints
-      @constraints ||= {}
+    def self.fields
+      field_hash.values
+    end
+
+    def self.field_hash
+      @field_hash ||= {}
+    end
+
+    def self.field(name, type, **constraints_hash)
+      register_field(KeyVortex::Field.new(name, type, **constraints_hash))
+    end
+
+    def self.register_field(field)
+      field_hash[field.name] = field
     end
 
-    def self.field(type, **constraints)
-      self.constraints[type] = constraints
+    def self.inherited(subclass)
+      super
+      fields.each do |field|
+        subclass.register_field(field)
+      end
     end
 
-    field :id
+    # Long enough to accomodate a GUID
+    field :key, String, length: 36
 
     def initialize(fields)
-      @fields = fields
+      @field_hash = fields
     end
 
     def respond_to_missing?(method, *args)
@@ -21,11 +42,11 @@ class KeyVortex
     end
 
     def method_missing(method, *_args)
-      @fields[method]
+      @field_hash[method]
     end
 
     def self.field_constraints(field)
-      @fields[field]
+      @field_hash[field]
     end
   end
 end

data/lib/key_vortex/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class KeyVortex
-  VERSION = "0.1.2"
+  VERSION = "0.1.4"
 end

data/lib/key_vortex.rb

@@ -8,6 +8,15 @@ class KeyVortex
   def initialize(adapter, record_class)
     @adapter = adapter
     @record_class = record_class
+
+    record_class.fields.each do |field|
+      next unless field.prohibited_by?(adapter)
+
+      raise KeyVortex::Error,
+            "#{adapter.class} can only handle field #{field.name} with these limitations:\n" +
+            adapter.limitation_for(field).to_s +
+            "\n\nThe following record violates these limitations:\n#{field.limitation}"
+    end
   end
 
   def save(record)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: key-vortex
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Lambda Null
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-07-08 00:00:00.000000000 Z
+date: 2023-07-09 00:00:00.000000000 Z
 dependencies: []
 description: Defines abstractions that can be built on top of for key/value storage
   on different technologies (file, s3, sql, redis, etc.)
@@ -32,7 +32,15 @@ files:
 - bin/setup
 - key-vortex.gemspec
 - lib/key_vortex.rb
+- lib/key_vortex/adapter.rb
 - lib/key_vortex/adapter/memory.rb
+- lib/key_vortex/constraint.rb
+- lib/key_vortex/constraint/base.rb
+- lib/key_vortex/constraint/length.rb
+- lib/key_vortex/constraint/maximum.rb
+- lib/key_vortex/constraint/minimum.rb
+- lib/key_vortex/field.rb
+- lib/key_vortex/limitation.rb
 - lib/key_vortex/record.rb
 - lib/key_vortex/version.rb
 - sig/record/store.rbs