fast_attributes_rails 1.0.0

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/benchmarks/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+ruby '2.1.2'
+
+gem 'fast_attributes', path: '..'
+gem 'virtus',          '1.0.2'
+gem 'attrio',          '0.7.3'
+gem 'benchmark-ips',   '2.0.0'

data/benchmarks/comparison.rb

@@ -0,0 +1,56 @@
+require 'benchmark/ips'
+require 'fast_attributes'
+require 'virtus'
+require 'attrio'
+
+ATTR_NAMES = [:attr0, :attr1, :attr2, :attr3, :attr4, :attr5, :attr6, :attr7, :attr8, :attr9]
+
+class FastIntegers
+  extend  FastAttributes
+  define_attributes initialize: true do
+    attribute *ATTR_NAMES, Integer
+  end
+end
+
+class AttrioIntegers
+  include Attrio
+  define_attributes do
+    ATTR_NAMES.each do |name|
+      attr name, Integer
+    end
+  end
+
+  def initialize(attributes = {})
+    attributes.each do |attribute, value|
+      public_send("#{attribute}=", value)
+    end
+  end
+end
+
+class VirtusIntegers
+  include Virtus.model
+  ATTR_NAMES.each do |name|
+    attribute name, Integer
+  end
+end
+
+Benchmark.ips do |x|
+  x.config(time: 1, warmup: 1)
+
+  integers = {attr0: 0, attr1: 1, attr2: 2, attr3: 3, attr4: 4, attr5: 5, attr6: 6, attr7: 7, attr8: 8, attr9: 9}
+  strings  = {attr0: '0', attr1: '1', attr2: '2', attr3: '3', attr4: '4', attr5: '5', attr6: '6', attr7: '7', attr8: '8', attr9: '9'}
+
+  x.report('FastAttributes: without values                       ') { FastIntegers.new }
+  x.report('FastAttributes: integer values for integer attributes') { FastIntegers.new(integers) }
+  x.report('FastAttributes: string values for integer attributes ') { FastIntegers.new(strings) }
+
+  x.report('Attrio: without values                               ') { AttrioIntegers.new }
+  x.report('Attrio: integer values for integer attributes        ') { AttrioIntegers.new(integers) }
+  x.report('Attrio: string values for integer attributes         ') { AttrioIntegers.new(strings) }
+
+  x.report('Virtus: without values                               ') { VirtusIntegers.new }
+  x.report('Virtus: integer values for integer attributes        ') { VirtusIntegers.new(integers) }
+  x.report('Virtus: string values for integer attributes         ') { VirtusIntegers.new(strings) }
+
+  x.compare!
+end

data/fast_attributes.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fast_attributes/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'fast_attributes_rails'
+  spec.version       = FastAttributes::VERSION
+  spec.authors       = ['Damian Baćkowski']
+  spec.email         = ['damianbackowski@gmail.com']
+  spec.summary       = 'Fast attributes with data types'
+  spec.description   = 'Fast attributes with data types'
+  spec.homepage      = 'https://github.com/dbackowski/fast_attributes'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.required_ruby_version = '>= 1.9.2'
+
+  spec.add_dependency 'activesupport', '>= 3.0.0', '< 6.0'
+
+  spec.add_development_dependency 'bundler',   '~> 1.5'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec',     '~> 3.0.0'
+  spec.add_development_dependency 'coveralls', '~> 0.7.0'
+  spec.add_development_dependency 'simplecov', '~> 0.8.2'
+end

data/lib/fast_attributes.rb

@@ -0,0 +1,83 @@
+require 'bigdecimal'
+require 'date'
+require 'time'
+require 'fast_attributes/version'
+require 'fast_attributes/builder'
+require 'fast_attributes/type_cast'
+require 'fast_attributes/default_attributes'
+require 'active_support/core_ext/hash'
+
+module FastAttributes
+  TRUE_VALUES  = {true => nil, 1 => nil, '1' => nil, 't' => nil, 'T' => nil, 'true' => nil, 'TRUE' => nil, 'on' => nil, 'ON' => nil}
+  FALSE_VALUES = {false => nil, 0 => nil, '0' => nil, 'f' => nil, 'F' => nil, 'false' => nil, 'FALSE' => nil, 'off' => nil, 'OFF' => nil}
+
+  class << self
+    def type_casting
+      @type_casting ||= {}
+    end
+
+    def get_type_casting(klass)
+      type_casting[klass]
+    end
+
+    def set_type_casting(klass, casting)
+      symbol = klass.name.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym  # DateTime => :date_time
+      type_cast symbol, klass do
+        from 'nil',      to: 'nil'
+        from klass.name, to: '%s'
+        otherwise casting
+      end
+    end
+
+    def remove_type_casting(klass)
+      type_casting.delete(klass)
+    end
+
+    def type_exists?(klass)
+      type_casting.has_key?(klass)
+    end
+
+    def type_cast(*types_or_classes, &block)
+      types_or_classes.each do |type_or_class|
+        type_cast = TypeCast.new(type_or_class)
+        type_cast.instance_eval(&block)
+        type_casting[type_or_class] = type_cast
+      end
+    end
+  end
+
+  def define_attributes(options = {}, &block)
+    builder = Builder.new(self, options)
+    builder.instance_eval(&block)
+    builder.compile!
+  end
+
+  def attribute(*attributes, type)
+    builder = Builder.new(self)
+    builder.attribute *attributes, type
+    builder.compile!
+  end
+
+  set_type_casting String,     'String(%s)'
+  set_type_casting Integer,    'Integer(%s)'
+  set_type_casting Float,      'Float(%s)'
+  set_type_casting Array,      'Array(%s)'
+  set_type_casting Date,       'Date.parse(%s)'
+  set_type_casting Time,       'Time.parse(%s)'
+  set_type_casting DateTime,   'DateTime.parse(%s)'
+  set_type_casting BigDecimal, 'Float(%s);BigDecimal(%s.to_s)'
+
+  type_cast :boolean do
+    otherwise <<-EOS
+      if FastAttributes::TRUE_VALUES.has_key?(%s)
+        true
+      elsif FastAttributes::FALSE_VALUES.has_key?(%s)
+        false
+      elsif %s.nil?
+        nil
+      else
+        raise FastAttributes::TypeCast::InvalidValueError, %(Invalid value "\#{%s}" for attribute "%a" of type ":boolean")
+      end
+    EOS
+  end
+end

data/lib/fast_attributes/builder.rb

@@ -0,0 +1,125 @@
+module FastAttributes
+  class UnsupportedTypeError < TypeError
+  end
+
+  class Builder
+    def initialize(klass, options = {})
+      @klass      = klass
+      @options    = options
+      @attributes = []
+      @methods    = Module.new
+    end
+
+    def attribute(*attributes, type, options)
+      unless options.is_a?(Hash)
+        (attributes ||= []) << type
+        type = options
+        options = {}
+      end
+
+      unless FastAttributes.type_exists?(type)
+        raise UnsupportedTypeError, %(Unsupported attribute type "#{type.inspect}")
+      end
+
+      @attributes << [attributes, type, options || {}]
+    end
+
+    def compile!
+      compile_getter
+      compile_setter
+      set_defaults
+
+      if @options[:initialize]
+        compile_initialize
+      end
+
+      if @options[:attributes]
+        compile_attributes(@options[:attributes])
+      end
+
+      include_methods
+    end
+
+    private
+
+    def compile_getter
+      each_attribute do |attribute, *|
+        @methods.module_eval <<-EOS, __FILE__, __LINE__ + 1
+          def #{attribute} # def name
+            @#{attribute}  #   @name
+          end              # end
+        EOS
+      end
+    end
+
+    def compile_setter
+      each_attribute do |attribute, type, *|
+        type_cast   = FastAttributes.get_type_casting(type)
+        method_body = type_cast.compile_method_body(attribute, 'value')
+
+        @methods.module_eval <<-EOS, __FILE__, __LINE__ + 1
+          def #{attribute}=(value)
+            @#{attribute} = #{method_body}
+          end
+        EOS
+      end
+    end
+
+    def compile_initialize
+      attribute_string = if FastAttributes.default_attributes(@klass).empty?
+                           "attributes"
+                         else
+                           "FastAttributes.default_attributes(self.class).merge(attributes)"
+                         end
+
+      @methods.module_eval <<-EOS, __FILE__, __LINE__ + 1
+        def initialize(attributes = {})
+          #{attribute_string}.each do |name, value|
+            public_send("\#{name}=", value) if respond_to?("\#{name}=".to_sym)
+          end
+        end
+      EOS
+    end
+
+    def compile_attributes(mode)
+      attributes = @attributes.flat_map(&:first)
+      prefix = case mode
+               when :accessors then ''
+               else '@'
+               end
+
+      attributes = attributes.map do |attribute|
+        "'#{attribute}' => #{prefix}#{attribute}"
+      end
+
+      @methods.module_eval <<-EOS, __FILE__, __LINE__ + 1
+        def attributes                			                 # def attributes
+          {#{attributes.join(', ')}}.with_indifferent_access #   {'name' => @name, ...}
+        end                           			                 # end
+      EOS
+    end
+
+    def include_methods
+      @methods.instance_eval <<-EOS, __FILE__, __LINE__ + 1
+        def inspect
+          'FastAttributes(#{@attributes.flat_map(&:first).join(', ')})'
+        end
+      EOS
+      @klass.send(:include, @methods)
+    end
+
+    def set_defaults
+      each_attribute do |attribute, type, options|
+        FastAttributes.add_default_attribute(@klass, attribute, options[:default]) if options[:default]
+      end
+    end
+
+    def each_attribute
+      @attributes.each do |attributes, type, options = {}|
+        attributes.each do |attribute|
+          yield attribute, type, options
+        end
+      end
+    end
+  end
+end

data/lib/fast_attributes/default_attributes.rb

@@ -0,0 +1,33 @@
+module FastAttributes
+  class << self
+    SINGLETON_CLASSES = [::NilClass, ::TrueClass, ::FalseClass, ::Numeric,  ::Symbol].freeze
+
+    def default_attributes(klass)
+      return {} unless (@default_attributes || {})[klass]
+      @default_attributes[klass].each_with_object({}) do |(attribute, value), memo|
+        memo[attribute] = if value.respond_to?(:call)
+                            value.call
+                          elsif cloneable?(value)
+                            value.clone
+                          else
+                            value
+                          end
+      end
+    end
+
+    def add_default_attribute(klass, attribute, value)
+      @default_attributes ||= {}
+      @default_attributes[klass] ||= {}
+      @default_attributes[klass][attribute] = value
+    end
+
+    def cloneable?(value)
+      case value
+      when *SINGLETON_CLASSES
+        false
+      else
+        true
+      end
+    end
+  end
+end

data/lib/fast_attributes/type_cast.rb

@@ -0,0 +1,81 @@
+module FastAttributes
+  class TypeCast
+    class UnknownTypeCastingError < StandardError
+    end
+
+    class InvalidValueError < TypeError
+    end
+
+    def initialize(type)
+      @type              = type
+      @if_conditions     = []
+      @else_condition    = %q(raise FastAttributes::TypeCast::UnknownTypeCastingError, 'Type casting is not defined')
+      @rescue_conditions = nil
+      @default_rescue    = %(raise FastAttributes::TypeCast::InvalidValueError, %(Invalid value "\#{%s}" for attribute "%a" of type "#{@type}"))
+    end
+
+    class << self
+      def escape_template(template, attribute_name, argument_name)
+        template.gsub(/%+a|%+s/) do |match|
+          match.each_char.each_slice(2).map do |placeholder|
+            case placeholder
+              when %w[% a] then attribute_name
+              when %w[% s] then argument_name
+              when %w[% %] then '%'
+              else placeholder.join
+            end
+          end.join
+        end
+      end
+    end
+
+    def from(condition, options = {})
+      @if_conditions << [condition, options[:to]]
+    end
+
+    def otherwise(else_condition)
+      @else_condition = else_condition
+    end
+
+    def on_error(error, options = {})
+      @rescue_conditions ||=[]
+      @rescue_conditions << [error, options[:act]]
+    end
+
+    def type_casting_template
+      @type_casting_template ||= begin
+        if @if_conditions.any?
+          conditions = @if_conditions.map do |from, to|
+            "when #{from}\n" +
+            "  #{to}\n"
+          end
+
+          "case %s\n" +
+          conditions.join +
+          "else\n" +
+          "  #{@else_condition}\n" +
+          "end"
+        else
+          @else_condition
+        end
+      end
+    end
+
+    def rescue_template
+      rescues = @rescue_conditions || [['', @default_rescue]]
+      rescues.map do |error, action|
+        "rescue #{error} => e\n" +
+        "  #{action}"
+      end.join("\n")
+    end
+
+    def compile_method_body(attribute_name, argument_name)
+      method_body = "begin\n" +
+                    "  #{type_casting_template}\n" +
+                    "#{rescue_template}\n" +
+                    "end"
+
+      self.class.escape_template(method_body, attribute_name, argument_name)
+    end
+  end
+end

data/lib/fast_attributes/version.rb

@@ -0,0 +1,3 @@
+module FastAttributes
+  VERSION = '1.0.0'
+end

data/spec/fast_attributes/type_cast_spec.rb

@@ -0,0 +1,170 @@
+require 'spec_helper'
+
+describe FastAttributes::TypeCast do
+  describe '.escape_template' do
+    it 'replaces placeholder with proper values' do
+      template = '% %s %%s %%%s %%%%s % %a %%a %%%a %%%%a'
+      escaped  = FastAttributes::TypeCast.escape_template(template, 'price', 'arg')
+      expect(escaped).to eq('% arg %s %arg %%s % price %a %price %%a')
+    end
+  end
+
+  describe '#type_casting_template' do
+    let(:type_cast) { FastAttributes::TypeCast.new(String) }
+
+    describe 'without any conditions' do
+      it 'return exception' do
+        expect(type_cast.type_casting_template.gsub(' ', '')).to eq <<-EOS.gsub(' ', '').chomp
+          raise FastAttributes::TypeCast::UnknownTypeCastingError, 'Type casting is not defined'
+        EOS
+      end
+    end
+
+    describe 'when one rule is defined' do
+      before do
+        type_cast.from 'nil', to: 'nil'
+      end
+
+      it 'returns one when statement' do
+        expect(type_cast.type_casting_template.gsub(' ', '')).to eq <<-EOS.gsub(' ', '').chomp
+          case %s
+          when nil
+            nil
+          else
+            raise FastAttributes::TypeCast::UnknownTypeCastingError, 'Type casting is not defined'
+          end
+        EOS
+      end
+    end
+
+    describe 'when three rules are defined' do
+      before do
+        type_cast.from 'String',  to: 'String(%s)'
+        type_cast.from 'Array',   to: 'Array(%s)'
+        type_cast.from 'Integer', to: 'Integer(%s)'
+      end
+
+      it 'returns three when statements' do
+        expect(type_cast.type_casting_template.gsub(' ', '')).to eq <<-EOS.gsub(' ', '').chomp
+          case %s
+          when String
+            String(%s)
+          when Array
+            Array(%s)
+          when Integer
+            Integer(%s)
+          else
+            raise FastAttributes::TypeCast::UnknownTypeCastingError, 'Type casting is not defined'
+          end
+        EOS
+      end
+    end
+
+    describe 'when 2 rules and otherwise condition are defined' do
+      before do
+        type_cast.from 'Date', to: 'Date.parse(%s)'
+        type_cast.from 'Time', to: 'Time.parse(%s)'
+        type_cast.otherwise 'Float(%s)'
+      end
+
+      it 'returns 2 when statements and overrides default else condition' do
+        expect(type_cast.type_casting_template.gsub(' ', '')).to eq <<-EOS.gsub(' ', '').chomp
+          case %s
+          when Date
+            Date.parse(%s)
+          when Time
+            Time.parse(%s)
+          else
+            Float(%s)
+          end
+        EOS
+      end
+    end
+
+    describe 'when only otherwise rule is defined' do
+      before do
+        type_cast.otherwise '42 * %s'
+      end
+
+      it 'returns otherwise statement only' do
+        expect(type_cast.type_casting_template.gsub(' ', '')).to eq <<-EOS.gsub(' ', '').chomp
+          42 * %s
+        EOS
+      end
+    end
+  end
+
+  describe '#rescue_template' do
+    let(:type_cast) { FastAttributes::TypeCast.new(Float) }
+
+    describe 'when on_error is not defined' do
+      it 'raises default error message' do
+        expect(type_cast.rescue_template.gsub(' ', '')).to eq <<-EOS.gsub(' ', '').chomp
+          rescue => e
+            raise FastAttributes::TypeCast::InvalidValueError, %(Invalid value "\#{%s}" for attribute "%a" of type "Float")
+        EOS
+      end
+    end
+
+    describe 'when on_error is defined' do
+      before do
+        type_cast.on_error 'ArgumentError', act: '"%s" + "%a"'
+      end
+
+      it 'overrides default action' do
+        expect(type_cast.rescue_template.gsub(' ', '')).to eq <<-EOS.gsub(' ', '').chomp
+          rescue ArgumentError => e
+            "%s" + "%a"
+        EOS
+      end
+    end
+
+    describe 'when several on_error methods is called' do
+      before do
+        type_cast.on_error 'ArgumentError', act: '0'
+        type_cast.on_error 'StandardError', act: '1'
+      end
+
+      it 'generates several rescue conditions' do
+        expect(type_cast.rescue_template.gsub(' ', '')).to eq <<-EOS.gsub(' ', '').chomp
+          rescue ArgumentError => e
+            0
+          rescue StandardError => e
+            1
+        EOS
+      end
+    end
+  end
+
+  describe '#compile_method_body' do
+    let(:type_cast) { FastAttributes::TypeCast.new(Float) }
+
+    before do
+      type_cast.from 'nil',   to: 'nil'
+      type_cast.from 'Float', to: '%s'
+      type_cast.otherwise 'Float(%s)'
+      type_cast.on_error 'ArgumentError', act: 'raise "a %s %a"'
+      type_cast.on_error 'StandardError', act: 'raise "b %s %a"'
+    end
+
+
+    it 'generates type casting method' do
+      expect(type_cast.compile_method_body('price', 'argument').gsub(' ', '')).to eq <<-EOS.gsub(' ', '').chomp
+        begin
+          case argument
+          when nil
+            nil
+          when Float
+            argument
+          else
+            Float(argument)
+          end
+        rescue ArgumentError => e
+          raise "a argument price"
+        rescue StandardError => e
+          raise "b argument price"
+        end
+      EOS
+    end
+  end
+end