teyu 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87e7a03297458dbcd3b39f42889063698ab00c8e972b9161105073392af77d0a
-  data.tar.gz: 3d399d485dba2dabb465f49c023bdeefc18b6cbf4390892240ff21c7ce1fd129
+  metadata.gz: 41d078479a7fd57cf1428b9722942ef7f841e39dfda2fbc3c77283b341a5e485
+  data.tar.gz: 467cd3079389e47959b0be66aa5527290a6d65ce547c6ebc6117801a28cf7860
 SHA512:
-  metadata.gz: fd7163924f7aefd117dd6f724ed3d0da5b7bcd19af5ad085ca008a1442ef9f3127a829343fbad2a4ac8070d52e9d2304fda97ced1541b9eb19bc6cfb8e0b00e1
-  data.tar.gz: 971732d8029ead2666a40a78a071568ceaaedd6325b4805b94c4497fd26c83603a68bc82989169e6b26d86025a1521c23b7e9d27e85c8755c2d25a65c1b99fa5
+  metadata.gz: 831c336a26f241cf4ddfb45f9771142601fdb4d223346d090e276fc8d385c1be0f56060255f7fc6f8ed84eb091e5e0fbc2fd8efd97bff6c1874551ede716f7a6
+  data.tar.gz: bd08a81adc45840d85df4c673ffa4709785899c695fb9c4679ac7431c46264ba12c75a7262e1258c9772369dc31ba489a8132cb7243f25de072ed1310bb6d070

data/.travis.yml

@@ -3,9 +3,6 @@ language: ruby
 sudo: false
 cache: bundler
 rvm:
-  - 2.3.0
-  - 2.3.8
-  - 2.4.5
   - 2.5.3
   - 2.6.3
   - ruby-head

data/README.md

@@ -1,4 +1,4 @@
-# Teyu
+# Teyu(手湯)
 
 A Ruby class extension for binding initialize method args to instance vars.  
 Inspired by [attr_extras](https://github.com/barsoom/attr_extras) gem.

data/benchmark/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem 'benchmark_driver'
+gem 'teyu', path: '../'
+gem 'attr_extras'

data/benchmark/bench.rb

@@ -0,0 +1,35 @@
+require 'benchmark_driver'
+
+Benchmark.driver do |x|
+  x.prelude <<~RUBY
+    require 'teyu'
+    require 'attr_extras'
+    class A
+      def initialize(a:, b:, c:, d:, e: 'e')
+        @a = a
+        @b = b
+        @c = c
+        @d = d
+        @e = e
+      end
+    end
+
+    class B
+      extend Teyu
+      teyu_init :a!, :b!, :c!, :d!, e: 'e'
+    end
+
+    class C
+      attr_initialize [:a, :b, :c, :d, e: 'e']
+    end
+
+    a, b, c, d = 'a', 'b', 'c', 'd'
+    A.new(a: a, b: b, c: c, d: d)
+    B.new(a: a, b: b, c: c, d: d)
+    C.new(a: a, b: b, c: c, d: d)
+  RUBY
+
+  x.report "Normal", %{ A.new(a: a, b: b, c: c, d: d) }
+  x.report "teyu", %{ B.new(a: a, b: b, c: c, d: d) }
+  x.report "attr_extras", %{ C.new(a: a, b: b, c: c, d: d) }
+end

data/lib/teyu.rb

@@ -3,89 +3,172 @@ require "teyu/version"
 module Teyu
   class Error < StandardError; end
 
-  def teyu_init(*arg_names)
-    define_initializer = DefineInitializer.new(self, arg_names)
-    define_initializer.apply
+  def teyu_init(*params)
+    argument = Teyu::Argument.new(params)
+    begin
+      Teyu::FastInitializer.new(self, argument).define
+    rescue SyntaxError  # fallback to slow, but generic initializer if failed
+      Teyu::GenericInitializer.new(self, argument).define
+    end
   end
 
-  class DefineInitializer
-    def initialize(klass, arg_names)
+  class FastInitializer
+    def initialize(klass, argument)
       @klass = klass
-      @arg_names = arg_names
+      @argument = argument
+    end
+
+    def define
+      @klass.class_eval(def_initialize, __FILE__, __LINE__)
     end
 
-    def apply
-      sorter = Teyu::ArgsSorter.new(@arg_names)
+    private def def_initialize
+      <<~EOS
+      def initialize(#{def_initialize_args})
+        #{def_initialize_body}
+      end
+      EOS
+    end
 
-      validate_number_of_req_args = method(:validate_number_of_req_args)
-      validate_keyreq_args = method(:validate_keyreq_args)
+    private def def_initialize_args
+      args = []
+      args << "#{@argument.required_positional_args.map(&:to_s).join(', ')}"
+      args << "#{@argument.required_keyword_args.map { |arg| "#{arg}:" }.join(', ')}"
+      # LIMITATION:
+      # supports only default values which can be stringified such as `1`, `"a"`, `[1]`, `{a: 1}`.
+      # Note that the default value objects are newly created everytime on a method call.
+      args << "#{@argument.optional_keyword_args.map { |k, v| "#{k}: #{v.inspect}" }.join(', ')}"
+      args.reject { |arg| arg.empty? }.join(', ')
+    end
 
-      @klass.send(:define_method, :initialize) do |*arg_values|
-        validate_number_of_req_args.call(sorter.req_args, arg_values)
-        validate_keyreq_args.call(sorter.keyreq_args, arg_values)
+    private def def_initialize_body
+      @argument.arg_names.map { |name| "@#{name} = #{name}" }.join("\n  ")
+    end
+  end
+
+  class GenericInitializer
+    def initialize(klass, argument)
+      @klass = klass
+      @argument = argument
+    end
 
-        sorter.req_args.zip(arg_values).each do |name, value|
+    def define
+      # NOTE: accessing local vars is faster than method calls, so cache to local vars
+      required_positional_args = @argument.required_positional_args
+      required_keyword_args = @argument.required_keyword_args
+      optional_keyword_args = @argument.optional_keyword_args
+      keyword_args = @argument.keyword_args
+
+      @klass.define_method(:initialize) do |*given_args|
+        if given_args.last.is_a?(Hash)
+          given_positional_args = given_args[0...-1]
+          given_keyword_args = given_args.last
+        else
+          given_positional_args = given_args
+          given_keyword_args = {}
+        end
+        given_keyword_args_keys = given_keyword_args.keys
+
+        if required_positional_args.size != given_positional_args.size
+          raise ArgumentError, "wrong number of arguments (given #{given_positional_args.size}, expected #{required_positional_args.size})"
+        end
+        missing_keywords = required_keyword_args - given_keyword_args_keys
+        raise ArgumentError, "missing keywords: #{missing_keywords.join(', ')}" unless missing_keywords.empty?
+        unknown_keywords = given_keyword_args_keys - keyword_args
+        raise ArgumentError, "unknown keywords: #{unknown_keywords.join(', ')}" unless unknown_keywords.empty?
+
+        # NOTE: `while` is faster than `each` because it does not create a so-called "environment"
+        i = 0
+        while i < required_positional_args.size
+          name = required_positional_args[i]
+          value = given_positional_args[i]
           instance_variable_set(:"@#{name}", value)
+          i += 1
         end
 
-        sorter.key_args.each do |name, value|
+        default_keyword_args_keys = optional_keyword_args.keys - given_keyword_args_keys
+        i = 0
+        while i < default_keyword_args_keys.size
+          name = default_keyword_args_keys[i]
+          value = optional_keyword_args[name]
+          # NOTE: In Ruby, objects of default arguments are newly created everytime on a method call.
+          #
+          #     def test(a: "a")
+          #       puts a.object_id
+          #     end
+          #     test #=> 70273097887660
+          #     test #=> 70273097887860
+          #
+          # In a method argument, it is possible to suppress the new object creation like:
+          #
+          #     $a = "a"
+          #     def test(a: $a)
+          #       puts a.object_id
+          #     end
+          #     test #=> 70273097887860
+          #     test #=> 70273097887860
+          #
+          # But, we do not support a such feature in this gem. That's why we `dup` here.
+          value = value.dup
           instance_variable_set(:"@#{name}", value)
+          i += 1
         end
 
-        keyword_arg_values = arg_values[sorter.req_args.length..].find { |value| value.is_a?(Hash) } || {}
-        (sorter.keyword_args & keyword_arg_values.keys).each do |name|
-          instance_variable_set(:"@#{name}", keyword_arg_values[name])
+        i = 0
+        while i < given_keyword_args_keys.size
+          name = given_keyword_args_keys[i]
+          value = given_keyword_args[name]
+          instance_variable_set(:"@#{name}", value)
+          i += 1
         end
       end
     end
+  end
 
-    private
-
-    def validate_number_of_req_args(arg_names, arg_values)
-      req_arg_names_count = arg_names.count
-      req_arg_values_count = arg_values.filter { |value| !value.is_a?(Hash) }.count
+  class Argument
+    REQUIRED_SYMBOL = '!'.freeze
+    VARIABLE_NAME_REGEXP = /\A[a-z_][a-z0-9_]*\z/
 
-      raise ArgumentError, "wrong number of arguments (given #{req_arg_values_count}, expected #{req_arg_names_count})" if req_arg_names_count != req_arg_values_count
+    def initialize(params)
+      @params = params
+      validate
     end
 
-    def validate_keyreq_args(arg_names, arg_values)
-      arg_names.each do |name|
-        keyword_arg_keys = arg_values.find { |value| value.is_a?(Hash) }&.keys || []
-        raise ArgumentError, "(missing keyword: #{name})" unless keyword_arg_keys.include?(name)
+    private def validate
+      invalid_variable_names = arg_names.reject { |name| VARIABLE_NAME_REGEXP.match?(name) }
+      unless invalid_variable_names.empty?
+        raise ArgumentError, "invalid variable names: #{invalid_variable_names.join(', ')}"
       end
     end
-  end
-
-  class ArgsSorter
-    REQUIRED_SYMBOL = '!'.freeze
 
-    def initialize(names)
-      @names = names
+    # @return [Array<Symbol>] names of arguments
+    def arg_names
+      @arg_names ||= required_positional_args + required_keyword_args + optional_keyword_args.keys
     end
 
     # method(a, b) => [:a, :b]
-    # @return [Array<Symbol>] req arg names
-    def req_args
-      @req_args ||= @names.take_while { |arg| !arg.is_a?(Hash) && !arg.to_s.end_with?(REQUIRED_SYMBOL) }
+    # @return [Array<Symbol>] names of required positional arguments
+    def required_positional_args
+      @required_positional_args ||= @params.take_while { |arg| !arg.is_a?(Hash) && !arg.to_s.end_with?(REQUIRED_SYMBOL) }
     end
 
     # method(a!:, b: 'b') => [:a, :b]
-    # @return [Array<Symbol>] keyword arg names
+    # @return [Array<Symbol>] names of keyword arguments
     def keyword_args
-      @keyword_args ||= keyreq_args + key_args.keys
+      @keyword_args ||= required_keyword_args + optional_keyword_args.keys
     end
 
     # method(a!:, b!:) => [:a, :b]
-    # @return [Array<Symbol>] keyreq arg names
-    def keyreq_args
-      @keyreq_args ||= @names.map(&:to_s).filter { |arg| arg.end_with?(REQUIRED_SYMBOL) }
-                         .map { |arg| arg.delete_suffix(REQUIRED_SYMBOL).to_sym }
+    # @return [Array<Symbol>] names of required keyword arguments
+    def required_keyword_args
+      @required_keyword_args ||= @params.map(&:to_s).select { |arg| arg.end_with?(REQUIRED_SYMBOL) }
+        .map { |arg| arg.delete_suffix(REQUIRED_SYMBOL).to_sym }
     end
 
     # method(a: 'a', b: 'b') => { a: 'a', b: 'b' }
-    # @return [Hash] keyword args with default value
-    def key_args
-      @key_args ||= @names.filter { |arg| arg.is_a?(Hash) }&.inject(:merge) || {}
+    # @return [Hash] optional keyword arguments with their default values
+    def optional_keyword_args
+      @optional_keyword_args ||= @params.select { |arg| arg.is_a?(Hash) }&.inject(:merge) || {}
     end
   end
 end

data/lib/teyu/version.rb

@@ -1,3 +1,3 @@
 module Teyu
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/teyu.gemspec

@@ -20,7 +20,7 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "bundler", ">= 1.17"
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'test-unit'
   spec.add_development_dependency 'power_assert'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: teyu
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Takahiro Kiso (takanamito)
@@ -9,20 +9,20 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-08-07 00:00:00.000000000 Z
+date: 2019-11-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.17'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '1.17'
 - !ruby/object:Gem::Dependency
@@ -81,6 +81,8 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- benchmark/Gemfile
+- benchmark/bench.rb
 - bin/console
 - bin/setup
 - lib/teyu.rb