ializer 0.1.0

data/Rakefile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'ializer'
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ializer.gemspec

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ializer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ializer'
+  spec.version       = Ializer::VERSION
+  spec.authors       = ['Jeremy Steinberg']
+
+  spec.summary       = 'Simple (de)serializers for Ruby objects'
+  spec.homepage      = 'https://github.com/jsteinberg/ializer'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'multi_json', '~> 1.0'
+
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'pry'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-rspec'
+  spec.add_development_dependency 'simplecov'
+end

data/lib/de/ser/ializer.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module De
+  module Ser
+    class Ializer < ::Ser::Ializer
+      class << self
+        def parse(data, model_class)
+          return parse_many(data, model_class) if data.is_a? Array
+
+          parse_one(data, model_class)
+        end
+
+        def parse_many(data, model_class)
+          data.map { |obj_data| parse_one(obj_data, model_class) }
+        end
+
+        def parse_one(data, model_class)
+          # OpenStruct lazily defines methods so respond_to? fails initially
+          return parse_ostruct(data) if ostruct?(model_class)
+
+          parse_object(data, model_class.new)
+        end
+
+        def parse_object(data, object)
+          data.each do |key, value|
+            parse_attribute(object, key, value)
+          end
+
+          object
+        end
+
+        def parse_json(json, model_class)
+          data = MultiJson.load(json)
+          parse(data, model_class)
+        end
+
+        def parse_attribute(object, key, value)
+          field = _attributes[key]
+
+          return unless field
+
+          return unless object.respond_to?(field.setter)
+
+          parse_field(object, field, value)
+        end
+
+        protected
+
+        def create_anon_class
+          Class.new(De::Ser::Ializer)
+        end
+
+        private
+
+        def parse_field(object, field, value)
+          parsed_value = field.parse(value)
+
+          return if parsed_value.nil?
+
+          object.public_send(field.setter, parsed_value)
+        end
+
+        def ostruct?(model_class)
+          defined?(OpenStruct) && model_class <= OpenStruct
+        end
+
+        def parse_ostruct(data)
+          object = OpenStruct.new
+
+          data.each do |key, value|
+            parse_ostruct_field(object, key, value)
+          end
+
+          object
+        end
+
+        def parse_ostruct_field(object, key, value)
+          field = _attributes[key]
+
+          return unless field
+
+          parse_field(object, field, value)
+        end
+      end
+    end
+  end
+end

data/lib/ializer/big_decimal_de_ser.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'bigdecimal'
+
+module Ializer
+  class BigDecimalDeSer
+    def self.serialize(value, _context = nil)
+      value.to_s('F')
+    end
+
+    def self.parse(value)
+      BigDecimal(value)
+    end
+  end
+end
+
+Ser::Ializer.register('decimal', Ializer::BigDecimalDeSer, :BigDecimal, :decimal)

data/lib/ializer/boolean_de_ser.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Ializer
+  class BooleanDeSer
+    def self.serialize(value, _context = nil)
+      value
+    end
+
+    def self.parse(value)
+      return value if value.is_a? TrueClass
+      return value if value.is_a? FalseClass
+
+      value.to_s == 'true'
+    end
+  end
+end
+
+Ser::Ializer.register('boolean', Ializer::BooleanDeSer, :Boolean, :boolean)

data/lib/ializer/config.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Ializer
+  class Config
+    def initialize
+      @warn_on_default = true
+    end
+
+    ##
+    # :key_transform=: key_transform
+    #
+    # symbol of string transform to call on field keys
+    # default is +:dasherize+.
+    def key_transform=(key_transform)
+      self.key_transformer = key_transform&.to_proc
+    end
+
+    ##
+    # :attr_accessor: key_transformer
+    #
+    # object that responds_to :call with arity 1
+    # the Field name is passed into the key_transformer
+    # A key_transformer has higher precedence than key_transform
+    # default is +nil+.
+    attr_accessor :key_transformer
+
+    ##
+    # :attr_accessor: warn_on_default
+    #
+    # The DefaultDeSer when converting to JSON will only work properly for standard
+    # JSON value types(:string, :number, :boolean)
+    # A warning message will be logged if the DefaultDeSer has been used
+    # default is +true+.
+    attr_accessor :warn_on_default
+    alias warn_on_default? warn_on_default
+
+    ##
+    # :attr_accessor: raise_on_default
+    #
+    # The DefaultDeSer when converting to JSON will only work properly for standard
+    # JSON value types(:string, :number, :boolean)
+    # An error will be raised if the DefaultDeSer has been used
+    # default is +nil+.
+    attr_accessor :raise_on_default
+    alias raise_on_default? raise_on_default
+  end
+end

data/lib/ializer/date_de_ser.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Ializer
+  class DateDeSer
+    def self.serialize(value, _context = nil)
+      value.to_s
+    end
+
+    def self.parse(value)
+      Date.parse(value)
+    rescue ArgumentError
+      nil
+    end
+  end
+end
+
+Ser::Ializer.register('date', Ializer::DateDeSer, Date, :date)

data/lib/ializer/default_de_ser.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ializer
+  class DefaultDeSer
+    def self.serialize(value, _context = nil)
+      value
+    end
+
+    def self.parse(value)
+      value
+    end
+  end
+end
+
+Ser::Ializer.register_default(Ializer::DefaultDeSer)

data/lib/ializer/fix_num_de_ser.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Ializer
+  class FixNumDeSer
+    def self.serialize(value, _context = nil)
+      value
+    end
+
+    def self.parse(value)
+      return value if value.is_a? Numeric
+
+      value.to_i
+    end
+  end
+end
+
+Ser::Ializer.register('integer', Ializer::FixNumDeSer, Integer, :integer)

data/lib/ializer/float_de_ser.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Ializer
+  class FloatDeSer
+    NAN_STRING = Float::NAN.to_s
+    INFINITY_STRING = Float::INFINITY.to_s
+    NEGATIVE_INFINITY_STRING = (-Float::INFINITY).to_s
+
+    def self.serialize(value, _context = nil)
+      value = value.to_f unless value.is_a? Float
+
+      return NAN_STRING if value.nan?
+
+      return value.to_s if value.infinite?
+
+      value
+    end
+
+    def self.parse(value)
+      return Float::NAN if value == NAN_STRING
+
+      return -Float::INFINITY if value == NEGATIVE_INFINITY_STRING
+
+      return Float::INFINITY if value == INFINITY_STRING
+
+      value.to_f
+    end
+  end
+end
+
+Ser::Ializer.register('float', Ializer::FloatDeSer, Float, :float)

data/lib/ializer/millis_de_ser.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'time'
+
+module Ializer
+  class MillisDeSer
+    def self.serialize(value, _context = nil)
+      (value.to_f * 1000).to_i
+    end
+
+    def self.parse(value)
+      Time.at(value / 1000.0)
+    end
+  end
+end
+
+Ser::Ializer.register('millis', Ializer::MillisDeSer, :Millis, :millis)

data/lib/ializer/string_de_ser.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ializer
+  class StringDeSer
+    def self.serialize(value, _context = nil)
+      value.to_s
+    end
+
+    def self.parse(value)
+      value.to_s
+    end
+  end
+end
+
+Ser::Ializer.register('string', Ializer::StringDeSer, String, :string)

data/lib/ializer/symbol_de_ser.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Ializer
+  class SymbolDeSer
+    def self.serialize(value, _context = nil)
+      value.to_s
+    end
+
+    def self.parse(value)
+      value.to_sym
+    end
+  end
+end
+
+Ser::Ializer.register('symbol', Ializer::SymbolDeSer, Symbol, :symbol, :sym)

data/lib/ializer/time_de_ser.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'active_support/time'
+
+module Ializer
+  class TimeDeSer
+    def self.serialize(value, _context = nil)
+      value.to_time.iso8601(3) # to_time to force consistent serialization
+    end
+
+    def self.parse(value)
+      DateTime.iso8601 value
+    end
+  end
+end
+
+Ser::Ializer.register('timestamp', Ializer::TimeDeSer, Time, DateTime, :timestamp)

data/lib/ializer/version.rb

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

data/lib/ializer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'ializer/version'
+
+require 'ser/ializer/field'
+require 'ser/ializer'
+require 'de/ser/ializer'
+
+require 'ializer/big_decimal_de_ser'
+require 'ializer/boolean_de_ser'
+require 'ializer/date_de_ser'
+require 'ializer/default_de_ser'
+require 'ializer/fix_num_de_ser'
+require 'ializer/float_de_ser'
+require 'ializer/millis_de_ser'
+require 'ializer/string_de_ser'
+require 'ializer/symbol_de_ser'
+require 'ializer/time_de_ser'
+
+require 'ializer/config'
+
+require 'multi_json'
+
+module Ializer
+  # Returns the global configuration instance
+  def self.config
+    @config ||= Ializer::Config.new
+  end
+
+  # Initialization block is passed a global Config instance that can be
+  # used to configure Ializer behavior.  E.g., if you want to
+  # disable automation DefaultDeSer warnings put the following in
+  # an initializer: config/initializers/ializer.rb
+  #
+  #    Ializer.setup do |config|
+  #       config.warn_on_default = false
+  #    end
+  #
+  def self.setup
+    yield config
+  end
+end

data/lib/ser/ializer/field.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Ser
+  class Ializer
+    class Field
+      class << self
+        def transform(key)
+          return key unless ::Ializer.config.key_transformer
+
+          ::Ializer.config.key_transformer.call(key)
+        end
+      end
+
+      attr_reader :name, :setter, :key, :deser, :model_class, :if_condition, :block
+
+      def initialize(name, options, &block)
+        @name = name
+        @setter = options[:setter] || "#{name}="
+        @key = options[:key] || Field.transform(name.to_s)
+        @deser = options[:deser]
+        @if_condition = options[:if]
+        @model_class = options[:model_class]
+        @block = block
+      end
+
+      def serialize(value, context)
+        deser.serialize(value, context)
+      end
+
+      def parse(value)
+        if model_class
+          deser.parse(value, model_class)
+        else
+          deser.parse(value)
+        end
+      end
+
+      def valid_for_context?(object, context)
+        return true if if_condition.nil?
+
+        if_condition.call(object, context)
+      end
+    end
+  end
+end

data/lib/ser/ializer.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module Ser
+  class Ializer # rubocop:disable Metrics/ClassLength
+    @@method_registry = {} # rubocop:disable Style/ClassVars
+
+    class << self
+      # Public DSL
+      def property(name, options = {}, &block)
+        return add_attribute(Field.new(name, options, &block)) if options[:deser]
+
+        return default(name, options, &block) unless options[:type]
+
+        meth = lookup_method(options[:type])
+
+        return meth.call(name, options, &block) if meth
+
+        default(name, options, &block)
+      end
+
+      def nested(name, options = {}, &block)
+        if block
+          deser = create_anon_class
+          deser.class_eval(&block)
+          options[:deser] = deser
+        end
+
+        add_attribute(Field.new(name, options))
+      end
+
+      def with(deser)
+        deser._attributes.values.map(&:dup).each(&method(:add_attribute))
+      end
+      # End Public DSL
+
+      def serialize(object, context = nil)
+        return serialize_one(object, context) unless valid_enumerable?(object)
+
+        object.map { |o| serialize_one(o, context) }
+      end
+
+      def serialize_json(object, context = nil)
+        MultiJson.dump(serialize(object, context))
+      end
+
+      def register(method_name, deser, *matchers)
+        raise ArgumentError, 'register should only be called on the Ser::Ializer class' unless self == Ser::Ializer
+
+        define_singleton_method(method_name) do |name, options = {}, &block|
+          options[:deser] = deser
+          add_attribute Field.new(name, options, &block)
+        end
+
+        matchers.each do |matcher|
+          method_registry[matcher.to_s.to_sym] = method_name
+        end
+      end
+
+      def register_default(deser)
+        define_singleton_method('default') do |name, options = {}, &block|
+          raise ArgumentError, warning_message(name) if ::Ializer.config.raise_on_default?
+
+          puts warning_message(name) if ::Ializer.config.warn_on_default?
+
+          options[:deser] = deser
+          add_attribute Field.new(name, options, &block)
+        end
+      end
+
+      def attribute_names
+        _attributes.values.map(&:name)
+      end
+
+      protected
+
+      def create_anon_class
+        Class.new(Ser::Ializer)
+      end
+
+      def method_registry
+        @@method_registry
+      end
+
+      def lookup_method(type)
+        method_name = method_registry[type.to_s.to_sym]
+
+        return nil unless method_name
+
+        method(method_name)
+      end
+
+      def _attributes
+        @attributes ||=
+          if equal? Ser::Ializer
+            {}
+          else
+            superclass._attributes.dup
+          end
+      end
+
+      private
+
+      def warning_message(name)
+        "Warning: #{self} using default DeSer for property #{name}"
+      end
+
+      def add_attribute(field)
+        _attributes[field.key] = field
+
+        if field.block
+          add_attribute_with_block(field)
+        else
+          add_attribute_with_method(field)
+        end
+      end
+
+      def add_attribute_with_block(field)
+        define_singleton_method field.name do |object, context|
+          value = field.block.call(object, context)
+
+          serialize_field(field, value, context)
+        end
+      end
+
+      def add_attribute_with_method(field)
+        define_singleton_method field.name do |object, context|
+          value = object.public_send(field.name)
+
+          serialize_field(field, value, context)
+        end
+      end
+
+      def serialize_field(field, value, context)
+        return nil if value.nil?
+
+        return field.serialize(value, context) unless valid_enumerable?(value)
+
+        value.map { |v| field.serialize(v, context) }
+      end
+
+      def serialize_one(object, context)
+        _attributes.values.each_with_object({}) do |field, data|
+          next unless field.valid_for_context?(object, context)
+
+          value = public_send(field.name, object, context)
+
+          next if value.nil?
+
+          data[field.key] = value
+        end
+      end
+
+      def valid_enumerable?(object)
+        return true if object.is_a? Array
+
+        return true if defined?(ActiveRecord) && object.is_a?(ActiveRecord::Relation)
+
+        false
+      end
+    end
+  end
+end