patme 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f270e55081adb2c27a467a59a88dcce06996a14f
-  data.tar.gz: 5fb92273c02545651cb7b0b2033c61c5f87c7f6a
+  metadata.gz: 34560aa2680a0d13d4447e3ce353dacfb6e69e8a
+  data.tar.gz: f2a5fd24660340288c657f2bd1905033944335cb
 SHA512:
-  metadata.gz: 60c5a51bb417bf20fe806040ab9f1e14428e4aa57021f134ddc007154fc69b955856aa97942abdf18fb6619fff21def8161f91fbaaf62e310ffe4ca846bcf184
-  data.tar.gz: 8d5b443bab40c29f57b1982931f0827d1a53227e9824b9fbcbf3b2606f3883480d9b48390691312d61f729abb162d65f488dbc895406a13c7b6827aada0c52ef
+  metadata.gz: 5063c52ccbd5e41b766b8bcd648139db2fb2cd51faeef3078e28045a6d7e4b03fe1d366247938f23d1c4b901ac13b94cfc1a395435dfddf31841333bd30489bc
+  data.tar.gz: 6e3f90a826db1cd5676aaa8cb6c6cc441f8b1b1895ee2875c6f033016f4c6ae90fb0967882b954fe3125b20136be8c991fee4ae07e6688d26b3da28bd164cc2a

data/README.md

@@ -2,24 +2,18 @@
 
 [![Build Status](https://travis-ci.org/vizvamitra/patme.svg?branch=master)](https://travis-ci.org/vizvamitra/patme)
 
-This gem is my experiment on elixir-style pattern matching in ruby.
+This gem is my experiment on elixir-style pattern matching in ruby. In it's current state it is no more than a proof of concept and I suggest not to use it in production.
 
-The implementation is neither production-ready, nor complete. It is just a proof of concept.
 
 ## Info
 
-Patme module stores your instance methods internally and removes them from your class. Then, when method is called, it tries to pattern-match given arguments with existing method implementations. If implementation was found, it executes it, othervise you'll get a NoMethodError.
+Patme module stores your instance methods internally and removes them from your class. Then, when method is called, it tries to pattern-match given arguments with existing method implementations. If implementation was found, it executes it, otherwise you'll get a NoMethodError.
 
 Currently this gem supports 3 types of arguments: specific, arbitrary and optional. In method definition `def foo(agr1, arg2=1, _arg3=false)` arg1 is an arbitrary argument, arg2 is specific and arg3 is optional.
 
 Patme supports class-based pattern matching. If method's specific argument is a `Class`, then it will be matched based on given argument's class using `is_a?`
 
 
-## Limitations
-
-Only pattern matching on instance methods is supported. Also you must use parentheses around method arguments.
-
-
 ## Usage
 
 #### Recursion example
@@ -35,7 +29,7 @@ class Factorial
   end
 
   def calculate(n)
-    n * self.of(n-1)
+    n * calculate(n-1)
   end
 end
 
@@ -50,7 +44,7 @@ factorial_calculator.calculate(-1) # => endless recursion, don't do so ^_^
 #### Class-based pattern matching
 
 ```ruby
-require 'parme'
+require 'patme'
 
 SeriousError = Class.new(StandardError)
 RegularError = Class.new(StandardError)
@@ -116,85 +110,138 @@ class MyClass
 
   # This method will match only when arg1  ='test'
   def foo(arg1='test')
-    "runned foo('test') with #{arg1}"
+    "ran foo('test') with #{arg1}"
   end
 
   # Will match only when arg1  ='other'
   def foo(arg1='other')
-    "runned foo('other') with #{arg1}"
+    "ran foo('other') with #{arg1}"
   end
 
   # You can also use other basic types
   def foo(arg1={a: 1, b: 2})
-    "runned foo({a: 1, b: 2}) with #{arg1}"
+    "ran foo({a: 1, b: 2}) with #{arg1}"
   end
 
   # Will match when arg2 = 'test' no matter what arg1 is
   def foo(arg1, arg2='test')
-    "runned foo(any, 'test') with [#{arg1}, #{arg2}]"
+    "ran foo(any, 'test') with [#{arg1}, #{arg2}]"
   end
 
   # Will match with any arg1 and both with and without arg2
   # if arg2 is not supplied, method will receive arg2 = 'default'
   def foo(arg1, _arg2="default")
-    "runned foo(any, optional) with [#{arg1}, #{_arg2}]"
+    "ran foo(any, optional) with [#{arg1}, #{_arg2}]"
   end
 
 
   # Will match with any one argument.
   def bar(arg1)
-    "runned bar(any) with #{arg1}"
+    "ran bar(any) with #{arg1}"
   end
 
   # Won't ever match because previous definition of bar will be pattern-matched
   # before this one
   def bar(arg1='never')
-    "runned bar('never') with #{arg1}"
+    "ran bar('never') with #{arg1}"
   end
 
 
   def baz(arg1='test')
-    "runned baz('test') with #{arg1}"
+    "ran baz('test') with #{arg1}"
   end
 end
 
 my_obj = MyClass.new
 
-my_obj.foo('test') # => "runned foo('test') with test"
-my_obj.foo('other') # => "runned foo('other') with other"
-my_obj.foo({a: 1, b: 2}) # => "runned foo({a: 1, b: 2}) with {:a => 1, :b => 2}"
-my_obj.foo(1, 'test') # => "runned foo(any, 'test') with [1, test]"
-my_obj.foo(1) # => "runned foo(any, optional) with [1, default]"
-my_obj.foo(1, 'some') # => "runned foo(any, optional) with [1, some]"
+my_obj.foo('test') # => "ran foo('test') with test"
+my_obj.foo('other') # => "ran foo('other') with other"
+my_obj.foo({a: 1, b: 2}) # => "ran foo({a: 1, b: 2}) with {:a => 1, :b => 2}"
+my_obj.foo(1, 'test') # => "ran foo(any, 'test') with [1, test]"
+my_obj.foo(1) # => "ran foo(any, optional) with [1, default]"
+my_obj.foo(1, 'some') # => "ran foo(any, optional) with [1, some]"
 
-my_obj.bar(1) # => "runned bar(any) with 1"
-my_obj.bar('never') # => "runned bar(any) with never"
+my_obj.bar(1) # => "ran bar(any) with 1"
+my_obj.bar('never') # => "ran bar(any) with never"
 
-my_obj.baz('test') # => "runned baz('test') with test"
+my_obj.baz('test') # => "ran baz('test') with test"
 my_obj.baz(1) # => NoMethodError
 ```
 
 
+## Limitations
+
+Pattern-matching in it's current implementation is slow and the more implementations of a method you have the slower it would be:
+
+```ruby
+require 'spec_helper'
+require 'benchmark'
+
+class BenchmarkDummy
+  def no_pm(arg1, arg2)
+    ['no_pm', arg1, arg2]
+  end
+
+  include Patme::PatternMatching
+
+  def pm(arg1='test', arg2='lol')
+    ['specific', arg1, arg2]
+  end
+
+  def pm(arg1, arg2)
+    ['arbitrary', arg1, arg2]
+  end
+end
+
+n = 1_000_000
+foo = BenchmarkDummy.new
+
+Benchmark.bm do |x|
+  x.report('no_pm       '){ n.times{foo.no_pm('test', 'lol')} }
+  x.report('pm_specific '){ n.times{foo.pm('test', 'lol')} }
+  x.report('pm_arbitrary'){ n.times{foo.pm('some', 'arg')} }
+end
+
+#                   user     system      total        real
+# no_pm         0.200000   0.000000   0.200000 (  0.205747)
+# pm_specific   3.570000   0.000000   3.570000 (  3.574598)
+# pm_arbitrary  5.210000   0.000000   5.210000 (  5.210410)
+```
+
+Only pattern matching on instance methods is supported.
+
+Including Patme::PatternMatching into your class makes all of the methods below the `include` statement be pattern-matched (I think I'll fix this issue later).
+
+
 ## Todos
 
-1. Add support for keyword arguments (`key:` - arbitrary, `key: value` - specific, `_key: value` - optional)
-2. Add support for class methods
-3. Add something to tell Parme not to pattern-match on given methods
+1. Add support for class methods
+2. Add something to tell Patme not to pattern-match on every method
 
     ```ruby
     # Possible example
     class Hello
-      include Parme::PatternMatching
+      include Patme::PatternMatching
 
-      # Comment after method header will tell Parme not to touch this method
+      # Comment after method header will tell Patme not to touch this method
       def tell(name) # ::pm_off
         puts "Hello, #{name}"
       end
+
+      # Or maybe it'll be better to use an annotation
+      pm_start
+      def yell(name="Boss", message)
+        raise CommonSenceError, "don't yell on your boss"
+      end
+
+      def yell(name, message)
+        puts message.upcase
+      end
+      pm_stop
     end
     ```
 
-4. Add support for method headers without parentheses
-5. Add watchers
+3. Add guards
 
     ```ruby
     # Possible example
@@ -215,7 +262,8 @@ my_obj.baz(1) # => NoMethodError
     end
     ```
 
-6. Your suggestions?
+4. Add support for keyword arguments (`key:` - arbitrary, `key: value` - specific, `_key: value` - optional)
+5. Your suggestions?
 
 
 ## Contributing
@@ -226,4 +274,3 @@ Bug reports and pull requests are welcome on GitHub at https://github.com/vizvam
 ## License
 
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
-

data/lib/patme.rb

@@ -1,5 +1,6 @@
 Dir[File.join(__dir__, "/patme/arguments/*")].each{|path| require path}
 Dir[File.join(__dir__, "/patme/*.rb")].each{|path| require path}
+require 'parser/current'
 
 module Patme
 

data/lib/patme/arguments/optional.rb

@@ -7,7 +7,7 @@ module Patme
 
       # *given is an array to distinguish cases with no value or nil
       def get_value(*given)
-        given.size == 1 ? given[0] : @default_value
+        given.size == 1 ? given.first : @default_value
       end
 
       def ==(other)

data/lib/patme/implementation_builder.rb

@@ -1,59 +1,48 @@
 module Patme
 
-  # Gets method's header (for example, def foo(arg1, arg2='spec', _arg3='opt') )
-  # parses it and creates method implementation with the following arguments:
-  #    arg1 - any argument
-  #    arg2 - specific argument, 'spec'
-  #   _arg3 - optional argument which defaults to 'opt'
+  # Parses method's arguments and creates method implementation.
+  #
+  # For example, if method looks like this:
+  #
+  # def foo(arg1, arg2='foo', _arg3='bar')
+  #   # some code
+  # end
+  #
+  # then implementation will be created with the following arguments:
+  #    arg1 - arbitrary argument
+  #    arg2 - specific argument, 'foo'
+  #   _arg3 - optional argument, defaults to 'bar'
   class ImplementationBuilder
     def initialize(method_obj)
       @method_obj = method_obj
     end
 
     def build
-      values = get_values(method_header, method_params)
-      args = build_args(method_params, values)
-
-      Patme::Implementation.new(@method_obj, args)
+      Patme::Implementation.new(@method_obj, arguments)
     end
 
     private
 
-    def get_values(header, params)
-      return {} if params.size == 0
-
-      regex_str = params.map do |type, name|
-        case type
-        when :opt then "#{name}=(?<#{name}>.+)"
-        when :req
-          name =~ /^_/ ? "#{name}=(?<#{name}>.+)" : "#{name}"
-        end
-      end.join(', ') + '\s*\)\s*$'
-
-      match_data = header.match( Regexp.new(regex_str) )
-      match_data.names.map do |name|
-        [name.to_sym, eval(match_data[name.to_s])]
-      end.to_h
-    end
+    def arguments
+      method_ast = Parser::CurrentRuby.parse(@method_obj.source)
+      arguments_ast = method_ast.children[1].children
 
-    def method_header
-      path, line = @method_obj.source_location
-      File.read(path).split("\n")[line - 1]
+      arguments_ast.map{|arg_ast| build_argument(arg_ast)}
     end
 
-    def method_params
-      @method_obj.parameters
-    end
-
-    def build_args(params, values)
-      return [] if params.size == 0
-
-      params.map do |type, name|
-        case type
-        when :opt
-          (name =~ /^_/ ? Arguments::Optional : Arguments::Specific).new(values[name])
-        when :req then Arguments::Arbitrary.new
-        end
+    def build_argument(ast_node)
+      name = ast_node.children[0]
+      type = ast_node.type
+
+      case type
+      when :optarg
+        default_value = eval ast_node.children[1].location.expression.source
+        arg_class = name[0] == '_' ? Arguments::Optional : Arguments::Specific
+        arg_class.new(default_value)
+      when :arg
+        Arguments::Arbitrary.new
+      else
+        raise "Argument #{name} has unsupported argument type: #{type}"
       end
     end
   end

data/lib/patme/version.rb

@@ -1,3 +1,3 @@
 module Patme
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/patme.gemspec

@@ -21,6 +21,8 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_runtime_dependency 'parser', "~> 2.4"
+
   spec.add_development_dependency "bundler", "~> 1.14"
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: patme
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Dmitrii Krasnov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-03-06 00:00:00.000000000 Z
+date: 2017-03-26 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: parser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement