serialize_attributes 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 866a54a31babd7bd446a0348107c7262b0ea49b71769ca573a75d37107429b85
+  data.tar.gz: 484d600fbc6fb88e9796ee067957e9b337a20f8c3180fad81f2f0b0792620514
+SHA512:
+  metadata.gz: b90b797aeb295de0516ab9b991c49fefb430b0943fee75e0e44710fa5ba85688d4c7220d64dd93d3e75566bca4d5b4dc8dd2b2c62ca2130c8fe4cd7c741be5d8
+  data.tar.gz: c0fcee019031311f0a597505669b5a42e50d2b935997ef1ba901e9f474ccde426b28f970e35d3b4ab053fd563b3944536c455c23a97bb606c200ad2f281254c2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2021 Zaikio
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,141 @@
+# serialize_attributes
+
+Serialize ActiveModel attributes in JSON using type casting:
+
+```ruby
+class MyModel
+  serialize_attributes :settings do
+    attribute :user_name, :string
+    attribute :subscribed, :boolean, default: false
+  end
+end
+```
+
+> Unlike similar projects like [`ActiveRecord::TypedStore`](https://github.com/byroot/activerecord-typedstore),
+> underneath this library doesn't  use the `store` interface and instead uses the native
+> type coercion provided by ActiveModel (as long as you have an attribute recognised as a
+> Hash-like object).
+
+## Quickstart
+
+Add `serialized_atributes` to your Gemfile:
+
+```bash
+$ bundle add serialized_atributes
+```
+
+Next, include `SerializeAttributes` in your model class (or `ApplicationRecord` if you want to make
+it available everywhere). Your model should have a JSON (or JSONB) attribute, for example
+this one is called `settings`:
+
+```ruby
+create_table :my_models do |t|
+  t.json :settings, null: false, default: {}
+end
+```
+
+Then, tell the model what attributes we'll be storing there:
+
+```ruby
+class MyModel < ActiveRecord::Base
+  include SerializeAttributes
+
+  serialize_attributes :settings do
+    attribute :user_name, :string
+    attribute :subscribed, :boolean, default: false
+  end
+end
+```
+
+Now you can read/write values on the model and they will be automatically cast to and from
+database values:
+
+```ruby
+record = MyModel.create!(user_name: "Nick")
+#=> #<MyModel id: 1, settings: { user_name: "Nick" }>
+
+record.subscribed
+#=> false
+
+record.subscribed = true
+record
+#=> #<MyModel id: 1, settings: { user_name: "Nick", subscribed: true }>
+```
+
+### Getting all of the stored attributes
+
+Default values are not automatically persisted to the database, so there is a helper
+method to get the full object including default values:
+
+```ruby
+record = MyModel.new(user_name: "Nick")
+record.serialized_attributes_on(:settings)
+#=> { user_name: "Nick", subscribed: false }
+```
+
+### Getting a list of attribute names
+
+If you wish to programmatically get the list of attributes known to a store, you can use
+`.serialized_attribute_names`. The list is returned in order of definition:
+
+```ruby
+MyModel.serialized_attribute_names(:settings)
+#=> [:user_name, :subscribed]
+```
+
+### Complex types
+
+Underneath, we use the `ActiveModel::Type` mechanism for type coercion, which means
+that more complex and custom types are also supported. For an example, take a look at
+[ActiveModel::Type::Value](https://api.rubyonrails.org/classes/ActiveModel/Type/Value.html).
+
+The `#attribute` method
+[has the same interface as ActiveRecord](https://api.rubyonrails.org/classes/ActiveRecord/Attributes/ClassMethods.html#method-i-attribute),
+and supports both symbols and objects for the `cast_type`:
+
+```ruby
+# An example from the Rails docs:
+class MoneyType < ActiveRecord::Type::Integer
+  def cast(value)
+    if !value.kind_of?(Numeric) && value.include?('$')
+      price_in_dollars = value.gsub(/\$/, '').to_f
+      super(price_in_dollars * 100)
+    else
+      super
+    end
+  end
+end
+
+ActiveRecord::Type.register(:money, MoneyType)
+```
+
+```ruby
+class MyModel
+  serialize_attributes :settings do
+    attribute :price_in_cents, :money
+  end
+end
+```
+
+### Usage with ActiveModel alone
+
+It's also possible to use this library without `ActiveRecord`:
+
+```ruby
+class MyModel
+  include ActiveModel::Model
+  include ActiveModel::Attributes
+  include SerializeAttributes
+
+  # ActiveModel doesn't include a native Hash type, we can just use the Value
+  # type here for demo purposes:
+  attribute :settings, ActiveModel::Type::Value
+
+  serialize_attributes :settings do
+    attribute :user_name, :string
+  end
+end
+```
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require "bundler/setup"
+
+require "bundler/gem_tasks"
+
+require "rake/testtask"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.pattern = "test/**/*_test.rb"
+  t.verbose = false
+end
+
+task default: :test

data/lib/serialize_attributes/store.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module SerializeAttributes
+  # SerializeAttributes::Store is the individual store, keyed by name. You can get a
+  # reference to the store by calling `Model.serialized_attributes_store(column_name)`.
+  class Store
+    def initialize(model_class, column_name, &block) # :nodoc:
+      @model_class = model_class
+      @column_name = column_name
+      @attributes = {}
+      @defaults = {}
+
+      instance_exec(&block)
+      wrap_store_column
+      [self, @attributes, @defaults].each(&:freeze)
+    end
+
+    # Get a list of the attributes managed by this store
+    def attribute_names = @attributes.keys
+
+    # Cast a stored attribute against a given name
+    #
+    #    Model.serialized_attributes_store(:settings).cast(:user_name, 42)
+    #    => "42"
+    def cast(name, value)
+      @attributes[name.to_sym].cast(value)
+    end
+
+    # Deserialize a stored attribute using the value from the database (or elsewhere)
+    #
+    #   Model.serialized_attributes_store(:settings).deserialize(:subscribed, "0")
+    #   => false
+    def deserialize(name, value)
+      @attributes[name.to_sym].deserialize(value)
+    end
+
+    # Retrieve the default value for a given block. If the default is a Proc, it can be
+    # optionally executed in the context of the model.
+    #
+    #   Model.serialized_attributes_store(:settings).default(:subscribed)
+    #   #=> false
+    def default(name, context = nil)
+      given = @defaults[name]
+      return (context || self).instance_exec(&given) if given.is_a?(Proc)
+
+      given
+    end
+
+    private
+
+    def attribute(name, type, **options)
+      name = name.to_sym
+      type = ActiveModel::Type.lookup(type, **options.except(:default)) if type.is_a?(Symbol)
+
+      @attributes[name] = type
+      @defaults[name] = options[:default] if options.key?(:default)
+
+      @model_class.module_eval <<~RUBY, __FILE__, __LINE__ + 1
+        def #{name}                                          # def user_name
+          store = public_send(:#{@column_name})              #   store = public_send(:settings)
+          if store.key?("#{name}")                           #   if store.key?("user_name")
+            store["#{name}"]                                 #     store["user_name"]
+          else                                               #   else
+            self.class                                       #     self.class
+              .serialized_attributes_store(:#{@column_name}) #       .serialized_attributes_store(:settings)
+              .default(:#{name}, self)                       #       .default(:user_name, self)
+          end                                                #   end
+        end                                                  # end
+
+        def #{name}=(value)                                  # def user_name=(value)
+          cast_value = self.class                            #   cast_value = self.class
+            .serialized_attributes_store(:#{@column_name})   #     .serialized_attributes_store(:settings)
+            .cast(:#{name}, value)                           #     .cast(:user_name, value)
+          store = public_send(:#{@column_name})              #   store = public_send(:settings)
+          self.public_send(                                  #   self.public_send(
+            :#{@column_name}=,                               #     :settings=,
+            store.merge("#{name}" => cast_value)             #     store.merge("user_name" => cast_value)
+          )                                                  #   )
+        end                                                  # end
+      RUBY
+    end
+
+    class StoreColumnWrapper < SimpleDelegator # :nodoc:
+      def initialize(original, store) # rubocop:disable Lint/MissingSuper
+        __setobj__(original)
+        @store = store
+      end
+
+      def deserialize(...)
+        result = __getobj__.deserialize(...)
+        return result unless @store && result.respond_to?(:each)
+
+        result.each_with_object({}) do |(attribute_name, serialized_value), out|
+          out[attribute_name] = @store.deserialize(attribute_name, serialized_value)
+        end
+      end
+    end
+
+    # This method wraps the original store column and catches the `deserialize` call -
+    # this gives us a chance to convert the data in the database back into our types.
+    def wrap_store_column
+      return unless @model_class.respond_to?(:attribute_types)
+
+      original_store_column_type = @model_class.attribute_types.fetch(@column_name.to_s)
+      @model_class.attribute(@column_name, StoreColumnWrapper.new(
+                                             original_store_column_type,
+                                             self
+                                           ))
+    end
+  end
+end

data/lib/serialize_attributes/version.rb

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

data/lib/serialize_attributes.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require "serialize_attributes/version"
+require "serialize_attributes/store"
+
+# Serialize ActiveModel attributes in JSON using type casting
+module SerializeAttributes
+  extend ActiveSupport::Concern
+
+  class_methods do
+    # Configure a SerializeAttributes::Store, using the given column to store each
+    # attribute.
+    #
+    #   class Person
+    #     serialize_attributes :settings do
+    #       attribute :user_name, :string, default: "Christian"
+    #     end
+    #   end
+    #
+    #   Person.new(user_name: "Nick")
+    def serialize_attributes(column_name, &block)
+      column_name = column_name.to_sym
+
+      @serialized_attribute_stores ||= {}
+      @serialized_attribute_stores[column_name] = Store.new(self, column_name, &block)
+    end
+
+    # Retrieve a SerializeAttributes registered against the given column
+    #
+    #   Person.serialized_attributes_store(:settings)
+    def serialized_attributes_store(column_name)
+      @serialized_attribute_stores.fetch(column_name.to_sym)
+    end
+
+    # Get a list of the attributes registered in a given store
+    #
+    #   Person.serialized_attribute_names(:settings)
+    def serialized_attribute_names(column_name)
+      serialized_attributes_store(column_name).attribute_names
+    end
+  end
+
+  # Retrieve all of the SerializeAttributes attributes, including their default values
+  #
+  #   person = Person.new
+  #   person.serialized_attributes_on(:settings)
+  #   #=> { "user_name" => "Christian" }
+  def serialized_attributes_on(column_name)
+    store = self.class.serialized_attributes_store(column_name)
+
+    store.attribute_names.index_with do |attribute_name|
+      public_send(attribute_name)
+    end
+  end
+end

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification
+name: serialize_attributes
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Zaikio
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-12-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6'
+description: 
+email:
+- support@zaikio.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/serialize_attributes.rb
+- lib/serialize_attributes/store.rb
+- lib/serialize_attributes/version.rb
+homepage: https://github.com/zaikio/serialize_attributes
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/zaikio/serialize_attributes
+  source_code_uri: https://github.com/zaikio/serialize_attributes
+  changelog_uri: https://github.com/zaikio/serialize_attributes/blob/main/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.32
+signing_key: 
+specification_version: 4
+summary: Serialize ActiveModel attributes in JSON using type casting
+test_files: []