pattern-proc 0.0.3 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5d5feb7784773d21a7a6cfd9004f771d8626d9c5
-  data.tar.gz: 9378aa295eb70fed4f8f3421bd8adfc22a611e0d
+  metadata.gz: adc2ed80e8a4406782666406fd1cda3117de27ad
+  data.tar.gz: 14792f45f789de53c59a60cf429d1d8e86151645
 SHA512:
-  metadata.gz: 2eb70413d2a4614ff8f9daa48071600d82a139f03fad5652b522280ed727451bb08bb2932ebe65bb1eea4d866eaf14458e4668cd56b338fa41b2427c8d997678
-  data.tar.gz: 311757068e3e8eaf2bd414e244bf55101f548118f2403f2085d1b1178e4260b727694f130aaccee6bdba11ede13e2805a282ea60bc1f8bab67a2a992023963db
+  metadata.gz: f18e19c8a4ad26628d01f35179f94aad549d9ea350c15fb6880524e0406a15758e1c52de4baf5dfb9379ba766c95761b755b692c8957cac33433e95444667c05
+  data.tar.gz: 4fcdedf9e878868403999bdd127d216d60b4030b90a3a5cb8f4b65f6a1b409de132a3a39b59ec5529f375e4e8d268fbdbdce3dc8e9bd04b477f3468027e400a5

data/Gemfile

@@ -2,4 +2,6 @@ source "https://rubygems.org"
 
 group :test do
   gem "rspec"
+  gem "pry"
+  gem "metaclass"
 end

data/Gemfile.lock

@@ -1,7 +1,14 @@
 GEM
   remote: https://rubygems.org/
   specs:
+    coderay (1.1.0)
     diff-lcs (1.2.5)
+    metaclass (0.0.4)
+    method_source (0.8.2)
+    pry (0.9.12.6)
+      coderay (~> 1.0)
+      method_source (~> 0.8)
+      slop (~> 3.4)
     rspec (3.0.0)
       rspec-core (~> 3.0.0)
       rspec-expectations (~> 3.0.0)
@@ -14,9 +21,12 @@ GEM
     rspec-mocks (3.0.2)
       rspec-support (~> 3.0.0)
     rspec-support (3.0.2)
+    slop (3.5.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
+  metaclass
+  pry
   rspec

data/lib/pattern_proc.rb

@@ -1,146 +1,167 @@
-class PatternProc
+require 'metaclass'
 
-  def initialize(cases = [])
-    @arity = -1
-    @cases = []
-    cases.each do |c| add_case c end
+module PatternProc
+  def self.included(klass)
+    klass.extend ClassMethods
+    Object.include ObjectMethods
   end
 
-  def with(*args, &block)
-    case_obj = PatternProcCase.new(args, &block)
-    add_case case_obj
-    case_obj
-  end
+  class PatternProc
 
-  def to_proc
-    ->(*args) { call(args) }
-  end
+    def initialize(cases = [])
+      @arity = -1
+      @cases = []
+      cases.each do |c| add_case c end
+    end
 
-  private
-  def add_case(case_obj)
-    if @arity == -1
-      @arity = case_obj.arity
-    elsif @arity != case_obj.arity
-      raise "mismatched arity"
+    def with(*args, &block)
+      case_obj = PatternProcCase.new(args, &block)
+      add_case case_obj
+      case_obj
     end
-    @cases << case_obj
-  end
 
+    def to_proc
+      ->(*args) { call(args) }
+    end
 
-  def call(args)
-    if args.size == @arity
-      best_match = find_matches(args, true).first
-      if best_match
-        best_match.to_proc.call(args)
-      else
-        raise "no match"
+    private
+    def add_case(case_obj)
+      if @arity == -1
+        @arity = case_obj.arity
+      elsif @arity != case_obj.arity
+        raise "mismatched arity"
       end
-    elsif args.size < @arity
-      sliced_cases = find_matches(args, false)
-      if sliced_cases.size > 0
-        PatternProc.new(sliced_cases).to_proc
+      @cases << case_obj
+    end
+
+
+    def call(args)
+      if args.size == @arity
+        best_match = find_matches(args, true).first
+        if best_match
+          best_match.to_proc.call(args)
+        else
+          raise "no match"
+        end
+      elsif args.size < @arity
+        sliced_cases = find_matches(args, false)
+        if sliced_cases.size > 0
+          PatternProc.new(sliced_cases).to_proc
+        else
+          raise "no match"
+        end
       else
-        raise "no match"
+        raise "too many args"
       end
-    else
-      raise "too many args"
     end
-  end
 
-  def find_matches(args, stop_at_first_match)
-    results = []
-    sorted_cases = @cases.sort do |case_obj_1, case_obj_2|
-      case_obj_1.specificity <=> case_obj_2.specificity
-    end.reverse
-    sorted_cases.each do |case_obj|
-      result = case_obj.make_subcase(args)
-      if result
-        results << result
-        if stop_at_first_match
-          break
+    def find_matches(args, stop_at_first_match)
+      results = []
+      sorted_cases = @cases.sort do |case_obj_1, case_obj_2|
+        case_obj_1.specificity <=> case_obj_2.specificity
+      end.reverse
+      sorted_cases.each do |case_obj|
+        result = case_obj.make_subcase(args)
+        if result
+          results << result
+          if stop_at_first_match
+            break
+          end
         end
       end
+      results
     end
-    results
   end
-end
 
-class PatternProcCase
+  class PatternProcCase
 
-  attr_reader :proc_applied_level
-  attr_reader :proc_arity
+    attr_reader :proc_applied_level
+    attr_reader :proc_arity
 
-  def initialize(args, previous_specificity = 0, proc_arity = 0, &block)
-    @expected_args = args
-    @proc = block
-    @proc_arity = proc_arity
-    @previous_specificity = previous_specificity || 0
-    if !block.nil? && block.arity > 0
-      @proc_arity = block.arity
+    def initialize(args, previous_specificity = 0, proc_arity = 0, &block)
+      @expected_args = args
+      @proc = block
+      @proc_arity = proc_arity
+      @previous_specificity = previous_specificity || 0
+      if !block.nil? && block.arity > 0
+        @proc_arity = block.arity
+      end
     end
-  end
 
-  def returns(value)
-    @return_value = value
-    self
-  end
+    def returns(value)
+      @return_value = value
+      self
+    end
 
-  # private ish
-  def expected_arity
-    @expected_args.size || 0
-  end
+    # private ish
+    def expected_arity
+      @expected_args.size || 0
+    end
 
-  def arity
-    expected_arity + proc_arity
-  end
+    def arity
+      expected_arity + proc_arity
+    end
 
-  def specificity
-    expected_arity + @previous_specificity
-  end
+    def specificity
+      expected_arity + @previous_specificity
+    end
 
-  def make_subcase(args)
-    match_len = [args.size, @expected_args.size].min
-    expected = @expected_args.take(match_len)
-    actual = args.take(match_len)
-    if expected == actual
-      new_proc = to_proc.curry
-      curry_count = args.size - @expected_args.size
-      new_arity = proc_arity
-      if curry_count > 0
-        send_args = args.drop(match_len).take(curry_count)
-        new_proc = new_proc.call(*send_args)
-        new_arity -= curry_count
-        if new_arity == 0
-          return PatternProcCase.new([], specificity).returns(new_proc)
-        elsif !(new_proc.is_a?(Proc))
-          raise "uh oh"
+    def make_subcase(args)
+      match_len = [args.size, @expected_args.size].min
+      expected = @expected_args.take(match_len)
+      actual = args.take(match_len)
+      if expected == actual
+        new_proc = to_proc.curry
+        curry_count = args.size - @expected_args.size
+        new_arity = proc_arity
+        if curry_count > 0
+          send_args = args.drop(match_len).take(curry_count)
+          new_proc = new_proc.call(*send_args)
+          new_arity -= curry_count
+          if new_arity == 0
+            return PatternProcCase.new([], specificity).returns(new_proc)
+          elsif !(new_proc.is_a?(Proc))
+            raise "uh oh"
+          end
         end
+        PatternProcCase.new(@expected_args.drop(match_len), specificity, new_arity, &new_proc).returns(@return_value)
+      else
+        nil
       end
-      PatternProcCase.new(@expected_args.drop(match_len), specificity, new_arity, &new_proc).returns(@return_value)
-    else
-      nil
     end
-  end
 
-  def to_proc
-    @proc || ->(*args) { @return_value }
+    def to_proc
+      @proc || ->(*args) { @return_value }
+    end
   end
-end
 
-class Object
-  def partials(method)
-    @__partials ||= {}
-    unless @__partials[method] 
-      proc_obj = PatternProc.new
-      metaclass = class << self; self; end
-      metaclass.class_eval do
-        define_method(method) do |*args|
-          curried_method = proc_obj.to_proc.curry
-          curried_method[*args]
+  module ObjectMethods
+
+    def pattern(method)
+      find_or_create_pattern self.__metaclass__, method
+    end
+
+    private
+    def find_or_create_pattern(receiver, method)
+      @__pattern ||= {}
+      unless @__pattern[method] 
+        proc_obj = PatternProc.new
+        receiver.class_eval do
+          define_method(method) do |*args|
+            curried_method = proc_obj.to_proc.curry
+            curried_method[*args]
+          end
         end
+        @__pattern[method] = proc_obj
       end
-      @__partials[method] = proc_obj
+      @__pattern[method]
+    end
+
+  end
+
+  module ClassMethods
+    def pattern(method)
+      find_or_create_pattern self, method
     end
-    @__partials[method]
   end
 end

data/pattern-proc.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'pattern-proc'
-  s.version     = '0.0.3'
+  s.version     = '0.0.4'
   s.date        = '2014-07-01'
   s.summary     = 'Pattern Proc'
   s.description = 'define a Proc with pattern matching "re-declaration" ala Haskell'

data/spec/lib/object_method_spec.rb

@@ -0,0 +1,80 @@
+require 'pattern_proc'
+
+class TestObjectClass
+  include PatternProc
+  def my_func(a,b,c)
+    raise "don't call me"
+  end
+
+  pattern(:p_func).with(3,2).returns(5)
+  pattern(:p_func).with do |x,y| x * y end
+end
+
+class TestSingletonClass
+  class << self
+    include PatternProc
+    def class_func(a,b,c)
+      raise "don't call me"
+    end
+
+    pattern(:p_cls_func).with(3) do |y| y * y * y end
+    pattern(:p_cls_func).with do |x, y| x + y end
+  end
+end
+
+describe "pattern object methods" do
+  context "class" do
+    let (:obj) { TestObjectClass.new }
+    context "in declaration" do
+      it "allows declaration of pattern methods in a class" do
+        obj.p_func(3,2).should == 5
+        obj.p_func(3,3).should == 9
+      end
+    end
+    context "after the fact" do
+      it "allows replacing methods on an instance" do
+        obj.pattern(:my_func).with(1,2,3).returns(7)
+        obj.pattern(:my_func).with(2,3,4).returns(9)
+
+        obj.my_func(1,2).(3).should == 7
+        obj.my_func(2).(3,4).should == 9
+      end
+
+      it "allows declaring new methods on an instance" do
+        obj.pattern(:new_func).with(:a, :b).returns(:c)
+        obj.pattern(:new_func).with(:d, :e).returns(:f)
+
+        obj.new_func(:a).(:b).should == :c
+        obj.new_func(:d,:e).should == :f
+      end
+    end
+  end
+
+  context "object" do
+    let (:klass) { TestSingletonClass }
+    context "in declaration" do
+      it "allows declaration of pattern class methods in a class" do
+        klass.p_cls_func(3,2).should == 8
+        klass.p_cls_func(9,3).should == 12
+      end
+    end
+
+    context "after the fact" do
+      it "allows replacing methods on a class" do
+        klass.pattern(:class_func).with(1,2,3).returns(7)
+        klass.pattern(:class_func).with(2,3,4).returns(9)
+
+        klass.class_func(1,2).(3).should == 7
+        klass.class_func(2).(3,4).should == 9
+      end
+
+      it "allows declaring new methods on an instance" do
+        klass.pattern(:new_func).with(:a, :b).returns(:c)
+        klass.pattern(:new_func).with(:d, :e).returns(:f)
+
+        klass.new_func(:a).(:b).should == :c
+        klass.new_func(:d,:e).should == :f
+      end
+    end
+  end
+end

data/spec/lib/pattern_proc_spec.rb

@@ -1,6 +1,6 @@
 require 'pattern_proc'
 
-describe PatternProc do
+describe PatternProc::PatternProc do
   subject { described_class.new }
 
   it "simple" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pattern-proc
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
 platform: ruby
 authors:
 - William Pleasant-Ryan
@@ -23,6 +23,7 @@ files:
 - README.md
 - lib/pattern_proc.rb
 - pattern-proc.gemspec
+- spec/lib/object_method_spec.rb
 - spec/lib/pattern_proc_spec.rb
 homepage: http://rubygems.org/gems/pattern-proc
 licenses: