defmatch 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 050ab21f9d8461b8945a213a2f454fda069a44b2
+  data.tar.gz: 21be01216d2b525b3451436bdd920170b3d51480
+SHA512:
+  metadata.gz: c1bdc6c310cc0a49cb809d64ed77dfa9073ac55124e4b4adc365ec5608f222ffea9558c20ba40225552895e08a60f99064e1db9ecec8d1741be4014b23a6eff8
+  data.tar.gz: 8f65bddf87a83e0bc890adac30dd073118de2bc66afebbb622b9ab506f4a3f54fef64cc243f22bb191936ca558949a3b9d10698086621e9f8668286fb848eb41

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in defmatch.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Max Warnock
+
+MIT License
+
+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,90 @@
+# Defmatch
+
+Switching between erlang and ruby a fair amount has me missing erlang's function definition features. Particularly dispatching based on pattern matching. In erlang it's common to write a function that handles both a single item or a list of those items like this:
+
+```erlang
+times_two(List) when is_list(List) ->
+  [times_two(I) || I <- List]; %% This is a basic list comprehension (think collect if you're a ruby person)
+times_two(I) when is_number(I) ->
+  I * 2.
+
+times_two(4). % Returns 8
+times_two([1,2,3,4]). % Returns [2,4,6,8]
+times_two("asdf"). % Throws a bad match (function clause) error
+```
+
+To do the same type of operation in ruby I'd have to write something like this:
+
+```ruby
+def times_two(number_or_list)
+  if number_or_list.class == Fixnum
+    number_or_list * 2
+  elsif number_or_list.class == Array
+    number_or_list.collect(&:times_two)
+  else
+    throw "Not a valid argument type"
+  end
+end
+```
+
+Functionally these two are identical, but from a readability stand point I'd take erlang's version every time; even more so when this type of dispatching gets really complicated.
+
+So how would you write the same thing using Defmatch?
+
+```ruby
+class TestMe
+  extend(Defmatch)
+
+  defmatch(:times,Fixnum) {|num| num * 2 }
+  defmatch(:times,Array) {|list| list.collect {|i| times(i) } }
+end
+
+x = TestMe.new
+x.times(4) # -> 8
+x.times([1,2,3,4]) # -> [2,4,6,8]
+```
+
+## How does it work and how do I use it?
+Defmatch is written as a module and when it's used to extend a class it creates a ```defmatch``` class method. The ```defmatch``` method takes one required argument as the name of the method you're defining. The remaining arguments are the pattern to match on when the method you're calling that method. Those arguments can be classes, literals, or procedures (lambdas). It also takes a block which is the actual function body that will run when the pattern matches. Those with a java background think method overloading, but more powerful. Those with an erlang background will feel right at home. But here are some concrete examples.
+
+```ruby
+class TestMe
+  extend(Defmatch)
+
+  # Run this function if the argument passed to magic is of type Fixnum
+  defmatch(:magic,Fixnum) {|number| "I got a number #{number}" }
+  # Run this function if the argument passed to magic is of type Array
+  defmatch(:magic,Array) {|a| "I got an Array #{a.inspect}" }
+  # Run this function if the argument passed to magic is the symbol :literally
+  defmatch(:magic,:literally) {|duh| "This literally matched #{duh}" }
+  # Run this function when there are two fixnums passed to magic
+  defmatch(:magic,Fixnum,Fixnum) {|a,b| "Found two numbers #{a}:#{b}" }
+  # Run this function when there is a single argument that is equal to "banana" (not a great example as this could be done with a literal)
+  defmatch(:magic,lambda {|arg| arg == "banana" }) {|arg| "I matched using a procedure that made sure \"banana\" == #{arg}" }
+end
+
+#Now you have an instance method called magic that dispatches what runs based on the patterns you defined and their associated block
+x = TestMe.new
+x.magic(10) # -> Matches the first
+x.magic([1,2,3]) # -> Matches the second
+x.magic(:literally) # -> You get the idea
+x.magic(2,3)
+x.magic("banana")
+```
+
+This can come in very handy, but remember that the order in which you define things matters. Lets say I define my magic function like this:
+
+```ruby
+  #...
+  defmatch(:magic,Fixnum) {|num| num * 2 }
+  defmatch(:magic,1) {|num| "I got me a 1" }
+  #...
+```
+
+Even if I run ```x.magic(1)``` I will get ```2``` as the result. The second defmatch will never be matched because there is a more general match case above it. Order matters. Define your most specific matches first.
+
+## Roadmap
+
+* Add defclassmatch for class methods
+* Add parameter deconstruction
+* Add it to the Kernel so it's available without having to include things. This will require ruby 2.0 and I'm not prepared to kill backwards compatability yet.

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+# Default directory to look in is `/specs`
+# Run with `rake spec`
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color']
+end
+
+task :default => :spec

data/defmatch.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'defmatch/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "defmatch"
+  spec.version       = Defmatch::VERSION
+  spec.authors       = ["Max Warnock"]
+  spec.email         = ["mwarnock@analytical.info"]
+  spec.summary       = %q{Defmatch provides a method for classes to define and dispatch methods off of pattern matching.}
+  spec.description   = %q{Switching between erlang and ruby a fair amount has me missing erlang's function definition features. Particularly dispatching based on pattern matching. Defmatch is my way of bringing some of that functionality into ruby.}
+  spec.homepage      = "http://github.com/mwarnock/defmatch"
+  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.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "rspec-nc"
+  spec.add_development_dependency "guard"
+  spec.add_development_dependency "guard-rspec"
+end

data/lib/defmatch/version.rb

@@ -0,0 +1,3 @@
+module Defmatch
+  VERSION = "0.0.1"
+end

data/lib/defmatch.rb

@@ -0,0 +1,41 @@
+module Defmatch
+
+  def self.signiture_match(method,args)
+    tests = args.collect do |arg|
+      if arg.class == Proc
+        arg
+      elsif arg.class == Class
+        lambda {|param| param.class == arg }
+      else
+        lambda {|param| param == arg }
+      end
+    end
+    lambda do |*args|
+      test = true;
+      param_test_pairs = args.zip(tests)
+      param_test_pairs.each {|pair| if pair[1].call(pair[0]) == false; test = false; break; end; }
+      return test
+    end
+  end
+
+  def defmatch(method,*args,&block)
+    @defmatch_dispatch_info ||= {} # setup the methods in an instance variable
+    @defmatch_dispatch_info[method] ||= [] # setup the ordered array for the method the first time
+    @defmatch_dispatch_info[method] << {:test => Defmatch.signiture_match(method,args), :block => block} # add the hash for the test proc and the run proc (block given) to the list of matchers
+
+    # define dispatch method the first time
+    unless respond_to?(method)
+      self.send(:define_method,method) do |*args|
+        self.class.instance_variable_get(:@defmatch_dispatch_info)[method].each do |hash|
+          if hash[:test].call(*args)
+           return self.instance_exec(*args,&hash[:block])
+          end
+        end
+        throw "No function clause matching arguments" #This should be a real Exception
+      end
+    end
+
+  end
+
+end
+

data/spec/defmatch_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Defmatch do
+
+  class Tester
+    extend(Defmatch)
+
+    defmatch(:times,Fixnum) {|num| num * 2 }
+    defmatch(:times,Array) {|list| list.collect {|i| times(i) } } #how do I refer to the instance method in this context?
+    defmatch(:times,lambda {|asdf| asdf == :asdf }) {|asdf| :asdf }
+    defmatch(:times,1) {|num| puts "this should never get run"; num }
+    defmatch(:times,"matchme") {|string| "matched literal #{string}" }
+    defmatch(:times,String) {|string| string*2 }
+  end
+
+  it 'creates a method' do
+    expect(Tester).to respond_to(:defmatch)
+  end
+
+  it 'should have an instance method "times"' do
+    expect(Tester.new).to respond_to(:times)
+  end
+
+  instance = Tester.new
+
+  describe instance do
+
+    it 'should handle an integer' do
+      expect(instance.times(4)).to equal(8)
+    end
+
+    it 'should handle a list of integers' do
+      expect(instance.times([1,2,3,4])).to eq([2,4,6,8])
+    end
+
+    it 'should match a basic proc matcher' do
+      expect(instance.times(:asdf)).to equal(:asdf)
+    end
+
+    it 'should match on literals' do
+      expect(instance.times("matchme")).to eq("matched literal matchme")
+    end
+
+    it 'should run the first valid match based on defmatch declaration order' do
+      expect(instance.times(1)).to equal(2)
+      expect(instance.times("matchme")).to eq("matched literal matchme")
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require 'defmatch'

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: defmatch
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Max Warnock
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-08-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec-nc
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: guard
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  prerelease: false
+  type: :development
+description: Switching between erlang and ruby a fair amount has me missing erlang's function definition features. Particularly dispatching based on pattern matching. Defmatch is my way of bringing some of that functionality into ruby.
+email:
+- mwarnock@analytical.info
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- defmatch.gemspec
+- lib/defmatch.rb
+- lib/defmatch/version.rb
+- spec/defmatch_spec.rb
+- spec/spec_helper.rb
+homepage: http://github.com/mwarnock/defmatch
+licenses:
+- MIT
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.2.2
+signing_key:
+specification_version: 4
+summary: Defmatch provides a method for classes to define and dispatch methods off of pattern matching.
+test_files:
+- spec/defmatch_spec.rb
+- spec/spec_helper.rb