serdes 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1b3503dd727a37b864788db7ee33c3f3e4f78e2c74e507ffb5c609063f7bba74
+  data.tar.gz: 2da0aab394b27b6f3a4446c002149ad2948734b9cc3be6ef535bb6edb6729314
+SHA512:
+  metadata.gz: 80a98b17cdabde8aec50f520d811123c199166576af8965ff5a52b636d49b082203ee7aebc74c344c80039ba09d6a3e1c6ca03201936c8be76c20160cdd10cca
+  data.tar.gz: 34a2506c7337a94c676f5969f1f448de64ee34e2c377d0fa0f129056fa987f062dd41ff6a818c80e0071b15fde31155cdb5756c50a52f2dede5c6cc59c071f32

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+## [Unreleased]
+
+## [0.1.0] - 2025-02-03
+
+- Initial release

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 Shia
+
+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,89 @@
+# Serdes
+
+Serdes is a tool for *ser*ializing and *des*erializing class.
+It provides:
+
+- general way to serialize and deserialize
+- simple type checking for attributes
+- basic implementation for some class to Hash.
+
+## Installation
+
+```bash
+bundle add serdes
+```
+
+If bundler is not being used to manage dependencies, install the gem by executing:
+
+```bash
+gem install serdes
+```
+
+## Usage
+
+```ruby
+require "serdes"
+
+class User
+  include Serdes
+
+  rename_all_attributes :PascalCase
+
+  attribute :name, String
+  attribute :age, Integer
+  attribute :profile, optional(String)
+  attribute :tags, array(String)
+  attribute :has_pet, Boolean
+end
+
+user_hash = {
+  "Name" => "Alice",
+  "Age" => 20,
+  "HasPet" => true,
+  "Tags" => ["tag1", "tag2"]
+}
+
+user = User.from(user_hash)
+
+user_hash = {
+  "Name" => "Alice",
+  "Age" => 20,
+  "HasPet" => true,
+  "Tags" => ["tag1", "tag2"]
+}
+
+User.from(user_hash) # => raise Serdes::TypeError
+```
+
+### API
+
+- `<class>.from(obj)`: Deserialize object to <class> instance.
+  - `from` will call `from_<obj.class>` method if it exists. if not, it returns obj as it is.
+- `<class>#to_hash`: Serialize <class> instance to Hash.
+  - There is no support for serializaion, as only you need to do is just implement `to_<class>` method where you want.
+
+### Types
+
+`serdes` provides some convenient types for type checking:
+
+- `optional(type)`:  `type` | `nil`
+- `array`: Array of `type`
+
+### Macro
+
+- `rename_all_attributes`: Rename all attributes when serializing and deserializing.
+  - Supported: `:snake_case`, `:PascalCase`
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/riseshia/serdes.
+
+## 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,11 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+path = File.expand_path(__dir__)
+Dir.glob("#{path}/lib/tasks/**/*.rake").each { |f| import f }
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/serdes/version.rb

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

data/lib/serdes.rb

@@ -0,0 +1,295 @@
+# frozen_string_literal: true
+
+require_relative "serdes/version"
+
+module Serdes
+  DeclareError = Class.new(StandardError)
+  RequiredAttributeError = Class.new(StandardError)
+  SerializeError = Class.new(StandardError)
+  TypeError = Class.new(StandardError)
+  AttributeAlreadyDefined = Class.new(StandardError)
+  RenameStrategyNotFound = Class.new(StandardError)
+
+  Boolean = [TrueClass, FalseClass].freeze
+
+  class TypeBase
+    def optional?
+      false
+    end
+
+    def array?
+      false
+    end
+  end
+
+  class ConcreteType < TypeBase
+    attr_reader :exact_type
+
+    def initialize(exact_type)
+      @exact_type = exact_type
+    end
+
+    def permit?(value)
+      @exact_type == value.class
+    end
+
+    def to_s
+      @exact_type.to_s
+    end
+  end
+
+  class OptionalType < TypeBase
+    attr_reader :base_type
+
+    def initialize(base_type)
+      @base_type = base_type
+    end
+
+    def optional?
+      true
+    end
+
+    def permit?(value)
+      return true if value.nil?
+
+      if @base_type.is_a?(TypeBase)
+        @base_type.permit?(value)
+      else
+        @base_type == value.class
+      end
+    end
+
+    def to_s
+      "optional(#{@base_type})"
+    end
+  end
+
+  class ArrayType < TypeBase
+    attr_reader :element_type
+
+    def initialize(element_type)
+      @element_type = element_type
+    end
+
+    def array?
+      true
+    end
+
+    def permit?(value)
+      return false if !value.is_a?(Array)
+
+      if @element_type.is_a?(TypeBase)
+        value.all? { |v| @element_type.permit?(v) }
+      else
+        value.all? { |v| v.class == @element_type }
+      end
+    end
+
+    def to_s
+      "array(#{@element_type})"
+    end
+  end
+
+  class Attribute
+    attr_accessor :class_name, :name, :attr_type, :options
+
+    def initialize(class_name:, name:, attr_type:, options: {})
+      @class_name = class_name
+      @name = name
+      @attr_type = attr_type
+      @options = options
+    end
+
+    def serialized_name(rename_strategy = nil)
+      if rename_strategy && rename_strategy != :snake_case
+        Functions._serde_rename_strategy_func_fetch(:snake_case, rename_strategy).call(@name)
+      else
+        @name.to_s
+      end
+    end
+  end
+
+  def self.included(base)
+    base.extend ClassMethods
+    base.include InstanceMethods
+  end
+
+  module ClassMethods
+    def optional(type)
+      OptionalType.new(type)
+    end
+
+    def array(type)
+      ArrayType.new(type)
+    end
+
+    def attribute(name, attr_type, options = {})
+      attr_reader name
+
+      attr_type = ConcreteType.new(attr_type) if !attr_type.is_a?(TypeBase)
+      attr = Attribute.new(class_name: self.name, name: name, attr_type: attr_type, options: options)
+      _serde_attrs[name] = attr
+      _serde_deserialize_keymap[attr.serialized_name(_serde_rename_strategy)] = attr.name
+
+      define_method("#{name}=") do |value|
+        Functions.validate_type!(attr, value)
+        instance_variable_set("@#{name}", value)
+      end
+    end
+
+    def rename_all_attributes(strategy)
+      if _serde_attrs.size.positive?
+        raise AttributeAlreadyDefined, "Call rename_all_attributes before defining attributes."
+      end
+
+      rename_strategy =
+        case strategy
+        when :PascalCase
+        when :snake_case
+        else
+          raise RenameStrategyNotFound, "Rename strategy '#{strategy}' not found."
+        end
+
+      @_serde_rename_strategy = strategy
+    end
+
+    def from(obj)
+      Functions.from__proxy(self, obj)
+    end
+
+    def from_hash(hash)
+      new.tap do |instance|
+        _serde_attrs.each_value do |attr|
+          key = attr.serialized_name(_serde_rename_strategy)
+          serialized_value = hash[key]
+
+          value = Functions.from__proxy(attr.attr_type, serialized_value)
+
+          instance.__send__("#{attr.name}=", value)
+        end
+      end
+    end
+
+    private def _serde_attrs
+      @_serde_attrs ||= {}
+    end
+
+    private def _serde_deserialize_keymap
+      @_serde_deserialize_keymap ||= {}
+    end
+
+    private def _serde_rename_strategy
+      @_serde_rename_strategy ||= :snake_case
+    end
+  end
+
+  module InstanceMethods
+    def to_hash
+      self.class.__send__(:_serde_attrs).each_with_object({}) do |(name, attr), hash|
+        key = attr.serialized_name(self.class.__send__(:_serde_rename_strategy))
+        value = __send__(name)
+
+        hash[key] =
+          if value.respond_to?(:to_hash)
+            value.to_hash
+          elsif value.is_a?(Array)
+            value.map { |v| Functions.skip_to_hash?(v) ? v : v.to_hash }
+          elsif Functions.skip_to_hash?(value)
+            value
+          else
+            raise SerializeError, "Cannot serialize #{attr.class_name}##{attr.name} to Hash."
+          end
+      end
+    end
+  end
+
+  module Functions
+    module_function
+
+    # To avoid monkey patching stdlib classes, we use this proxy.
+    def from__proxy(from_type, to_value)
+      case from_type
+      when OptionalType
+        if to_value.nil?
+          nil
+        else
+          from_type = from_type.base_type
+          from__native_type__proxy(from_type, to_value)
+        end
+      when ArrayType
+        if to_value.is_a?(Array)
+          elem_type = from_type.element_type
+          to_value.map { |v| from__native_type__proxy(elem_type, v) }
+        else
+          from__native_type__proxy(from_type, to_value)
+        end
+      when ConcreteType
+        from_type = from_type.exact_type if from_type.is_a?(ConcreteType)
+        from__native_type__proxy(from_type, to_value)
+      else
+        from__native_type__proxy(from_type, to_value)
+      end
+    end
+
+    def from__native_type__proxy(from_type, to_value)
+      from_method = Functions.from_interface_for(to_value)
+
+      if from_type.respond_to?(from_method)
+        from_type.__send__(from_method, to_value)
+      else
+        # Do nothing, delegate error to validate_type! for better error message if mismached.
+        to_value
+      end
+    end
+
+    def from_interface_for(obj)
+      "from_#{const_name_to_snake_case(obj.class.name)}"
+    end
+
+    def const_name_to_snake_case(const_name)
+      const_name.gsub(/A-Z/, "_\\1").downcase.gsub("::", "__")
+    end
+
+    def validate_type!(attr, value)
+      valid = attr.attr_type.permit?(value)
+      return if valid
+
+      actual_type = humanize_type(value)
+
+      raise TypeError, "Wrong type for #{attr.class_name}##{attr.name}. Expected type #{attr.attr_type}, got #{value.class} (val: '#{value}')."
+    end
+
+    def humanize_type(value)
+      if value.is_a?(Array)
+        "array(" + value.map { |el| humanize_type(el) }.join(", ") + ")"
+      else
+        case value
+        when NilClass then "nil"
+        when TrueClass then "boolean"
+        when FalseClass then "boolean"
+        else value.class.to_s
+        end
+      end
+    end
+
+    def skip_to_hash?(value)
+      case value
+      when NilClass, String, Numeric, TrueClass, FalseClass
+        true
+      else
+        false
+      end
+    end
+
+    def _serde_rename_strategy_func_fetch(from, to)
+      _serde_rename_strategy_func[[from, to]]
+    end
+
+    def _serde_rename_strategy_func
+      @_serde_rename_strategy_func ||= {
+        [:PascalCase, :snake_case] => ->(name) { name.to_s.gsub(/([A-Z])/, '_\1').downcase },
+        [:snake_case, :PascalCase] => ->(name) { name.to_s.split('_').map(&:capitalize).join },
+      }
+    end
+  end
+end

metadata

@@ -0,0 +1,49 @@
+--- !ruby/object:Gem::Specification
+name: serdes
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Shia
+bindir: bin
+cert_chain: []
+date: 2025-02-03 00:00:00.000000000 Z
+dependencies: []
+description: Serdes is a tool for serializing and deserializing class.
+email:
+- rise.shia@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/serdes.rb
+- lib/serdes/version.rb
+homepage: https://github.com/riseshia/serdes
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/riseshia/serdes
+  source_code_uri: https://github.com/riseshia/serdes
+  changelog_uri: https://github.com/riseshia/serdes/blob/main/CHANGELOG.md
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.6.2
+specification_version: 4
+summary: Serdes is a tool for serializing and deserializing class.
+test_files: []