mallow 0.0.2 → 0.0.4

data/README.md

@@ -6,10 +6,10 @@ An example of Mallow's versatility is Graham, a tiny testing library powered by
 
 ## Papa teach me to mallow ##
 
-To mallow is very simple little boy: first marshal, then mallow!
+To mallow it is very easy little boy. First marshal, then mallow:
 
 ```ruby
-  mallow = Mallow::Core.build do |match|
+  mallow = Mallow.build do |match|
     match.a_hash.to {"#{keys.first} #{values.first}"}
   end
 ```
@@ -20,7 +20,7 @@ Now feed your mallow some iterable data:
 ```
 Mallow's DSL has a moderately rich vocabulary of built-in helpers (with complementary method_missing magic if that's yr thing):
 ```ruby
-  Mallow.fluff { |match|
+  Mallow.build { |match|
     match.a(Float).to &:to_i
     match.tuple(3).where{last != 0}.to {|a,b,c| (a + b) / c}
     match.an(Array).and_hashify_with( :name, :age ).and_make_a( Person ).and &:save!
@@ -34,7 +34,7 @@ Mallow's DSL has a moderately rich vocabulary of built-in helpers (with compleme
 
 A mallow is stateless, so it can't supply internal metadata (like index or match statistics) to rules. But that is not necessary for two reasons. First:
 ```ruby
-  Mallow.fluff do |match|
+  Mallow.build do |match|
     line = 0
     match.a(Fixnum).to {"Found a fixnum on line #{line+=1}"}
     match.*.to {|e| line+=1;e}
@@ -44,9 +44,9 @@ But that is just awful, and will betray you if you forget to increment the line
 
 Luckily the second reason is that this should be done as part of some kind of post-processing anyway. To aid in such an undertaking, Mallow wraps a matched element in its _own_ metadata, which can be accessed transparently at any point in the transformer chain once a match has succeeded:
 ```ruby
-  doubler = Mallow.fluff do |m|
-    m.a(Fixnum).with_metadata(type: Fixnum).to {|n| n*2}
-    m.anything.to {nil}.^(matched: false) # alias
+  doubler = Mallow.build do |m|
+    m.a(Fixnum).^(type: Fixnum).to {|n| n*2}
+    m.anything.to {nil}.^(matched: false)
   end
 
   data = doubler.fluff  [1,2,:moo]     #=> [2, 4, nil]
@@ -58,7 +58,7 @@ Luckily the second reason is that this should be done as part of some kind of po
 
 When a matcher is passed a parameter-less block, Mallow evaluates that block in the context of the element running against the matcher:
 ```ruby
-  Mallow.fluff {|m| m.*.to {self} }.fluff1(1) #=> 1
+  Mallow.build {|m| m.*.to {self} }.fluff1(1) #=> 1
 ```
 In most cases this helps to make code less verbose and more semantic without having to rely on dispatch-via-method_missing (hooray!). If you're sticking side-effecting code in these blocks, though, weird things could potentially happen unless you're careful. If you want to avoid this behaviour, just be sure to give parameters to your blocks.
 

data/lib/mallow/basic_dsl.rb

@@ -0,0 +1,50 @@
+module Mallow
+  class BasicDSL
+    attr_reader :core, :actions, :conditions
+
+    def self.build_core
+      yield (dsl = new)
+      dsl.finish!
+    end
+
+    def initialize
+      @core = Core.new
+      reset!
+    end
+
+    def where(&b); push b, :conditions end
+    def to(&b);    push b, :actions    end
+    def and(&b);   push b              end
+
+    def finish!
+      in_conds? ? to{self}.finish! : rule!.core
+    end
+
+    alias such_that where
+
+    private
+    def in_conds?
+      actions.empty?
+    end
+
+    def rule!
+      core << Rule::Builder[conditions, actions]
+      reset!
+    end
+
+    def push(p, loc = in_conds? ? :conditions : :actions)
+      rule! if loc == :conditions and not in_conds?
+      send(loc) << preproc(p)
+      self
+    end
+
+    def preproc(p)
+      p.parameters.empty? ? proc {|e| e.instance_eval &p} : p
+    end
+
+    def reset!
+      @conditions, @actions = Matcher.new, Transformer.new
+      self
+    end
+  end
+end

data/lib/mallow/dsl.rb

@@ -1,104 +1,42 @@
+require 'mallow/basic_dsl'
 module Mallow
-  class DSL
-    attr_reader :core, :actions, :conditions
-
-    def self.build
-      yield (dsl = new)
-      dsl.finish!
-    end
-
-    def initialize
-      @core = Core.new
-      reset!
-    end
-
-    def where(&b); push b, :conditions end
-    def to(&b);    push b, :actions    end
-    def and(&b);   push b              end
-
-    def *;           where {true}                             end
-    def a(c);        where {|e| e.is_a? c}                    end
-    def this(o);     where {|e| e == o}                       end
-    def size(n);     where {|e| e.size==n     rescue false}   end
-    def with_key(k); where {|e| e.has_key?(k) rescue false}   end
-
-    def and_hashify_with_keys(*ks);   to {|e| Hash[ks.zip e]} end
-    def and_hashify_with_values(*vs); to {|e| Hash[e.zip vs]} end
-    def with_metadata(d={});          to {|e| Meta.new e, d}  end
-
-    def to_nil;   to{nil}   end
-    def to_true;  to{true}  end
-    def to_false; to{false} end
-    def to_self;  to{self}  end
-
-    def tuple(n);            a(Array).size(n)   end
-    def and_make(o,s=false); and_send(:new,o,s) end
-
-    def and_send(msg, obj, splat = false)
-      to {|e| splat ? obj.send(msg, *e) : obj.send(msg, e)}
-    end
-
-    alias an a
-    alias ^ with_metadata
-    alias anything *
-    alias and_hashify_with and_hashify_with_keys
-    alias and_make_a and_make
-    alias and_make_an and_make
-    alias a_tuple tuple
-    alias such_that where
-    alias of_size size
-    alias to_itself to_self
-
-    def finish!
-      in_conds? ? to_self.finish! : rule!.core
-    end
-
-    # Checks for three forms:
-    # * (a|an)_(<thing>) with no args
-    # * (with|of)_(<msg>) with one arg, which tests <match>.send(<msg>) == arg
-    # * to_(<msg>) with any args, which resolves to <match>.send(<msg>) *args
-    def method_missing(msg, *args)
-      case msg.to_s
-      when /^(a|an)_(.+)$/
-        args.empty??
-          (a(Object.const_get $2.split(?_).map(&:capitalize).join) rescue super) :
-          super
-      when /^(with|of)_(.+)$/
-        args.size == 1 ?
-          where {|e| e.send($2) == args.first rescue false} :
-          super
-      when /^to_(.+)$/
-        to {|e| e.send $1, *args}
-      else
-        super
+  class DSL < BasicDSL
+    module Matchers
+      def *;           where {true}                             end
+      def a(c);        where {|e| c===e}                        end
+      def this(o);     where {|e| o== e}                        end
+      def size(n);     where {|e| e.size==n     rescue false}   end
+      def with_key(k); where {|e| e.has_key?(k) rescue false}   end
+
+      def tuple(n)
+        a(Array).size(n) 
       end
+      alias an               a
+      alias anything         *
+      alias of_size          size
+      alias a_tuple          tuple
     end
 
-    private
-
-    def in_conds?
-      actions.empty?
-    end
+    module Transformers
+      def and_hashify_with_keys(*ks);   to {|e| Hash[ks.zip e]} end
+      def and_hashify_with_values(*vs); to {|e| Hash[e.zip vs]} end
+      def ^(d={});                      to {|e| Meta.new e, d } end
 
-    def rule!
-      core << Rule::Builder[conditions, actions]
-      reset!
-    end
+      def and_make(o,s=false)
+        and_send(o,:new,s)
+      end
 
-    def push(p, loc = in_conds? ? :conditions : :actions)
-      rule! if loc == :conditions and not in_conds?
-      send(loc) << preproc(p)
-      self
+      def and_send(obj, mgs, splat = false)
+        to {|e| splat ? obj.send(msg, *e) : obj.send(msg, e)}
+      end
+      alias and_hashify_with and_hashify_with_keys
+      alias and_make_a       and_make
+      alias and_make_an      and_make
     end
 
-    def preproc(p)
-      p.parameters.empty? ? proc {|e| e.instance_eval &p} : p
-    end
+    include Matchers
+    include Transformers
 
-    def reset!
-      @conditions, @actions = Matcher.new, Transformer.new
-      self
-    end
   end
 end
 

data/lib/mallow/monads.rb

@@ -2,9 +2,7 @@ module Mallow
   # Rule monad(ish) encapsulating "execute the first rule whose conditions
   # pass" logic.
   class Rule < Struct.new :matcher, :transformer, :val
-    class << self
-      def return(v); new Matcher.new, Transformer.new, v end
-    end
+    def self.return(v); new Matcher.new, Transformer.new, v end
     # Curried proc for building procs for binding rules. If this were Haskell
     # its type signature might vaguely resemble:
     # Elt e => [e -> Bool] -> [e -> e] -> e -> Maybe (Meta e)
@@ -16,7 +14,7 @@ module Mallow
     def unwrap!; matcher === val ? transformer >> val : dx end
     private
     def dx
-      raise DeserializationException, "No rule matches #{val}:#{val.class}"
+      raise MatchException, "No rule matches #{val}:#{val.class}"
     end
   end
   # Wrapper monad(ish) for successful matches that allows the user to
@@ -48,8 +46,6 @@ module Mallow
     def >>(e); reduce(Meta.return(e),:bind) end
     # Wraps argument using Meta::proc
     def <<(p); super Meta::Builder[p] end
-    alias push <<
   end
-
 end
 

data/lib/mallow/version.rb

@@ -1,4 +1,3 @@
 module Mallow
-  # Mainly for show.
-  VERSION = '0.0.2'
+  VERSION = '0.0.4'
 end

data/lib/mallow.rb

@@ -3,38 +3,14 @@ require 'mallow/version'
 require 'mallow/monads'
 require 'mallow/dsl'
 module Mallow
-  class DeserializationException < StandardError; end
-
+  class MatchException < StandardError; end
   class Core < Array
-    def fluff(es)
-      _fluff(es).map &:val
-    end
-    def fluff1(e)
-      _fluff1(e).val
-    end
-    def _fluff(es)
-      es.map {|e| _fluff1 e}
-    end
-    def _fluff1(e)
-      reduce(Rule.return(e),:bind).unwrap!
-    end
-    class << self
-      # aka Mallow::DSL::build
-      def build(&b); DSL.build &b end
-    end
-  end
-
-  class << self
-    # aka Mallow::Core::build
-    def fluff(&b); Core.build(&b) end
-    # Defines a class method <sym> on <klass> to deserialize its argument (as 
-    # with Core#fluff) using the Core generated by passing the supplied block
-    # to Mallow.fluff
-    def engulf(klass, sym=:fluff, &b)
-      mtd, mod = Mallow.fluff(&b), Module.new
-      mod.send(:define_method, sym) {|d| mtd.fluff d}
-      klass.extend mod
-    end
+    def fluff(es);  _fluff(es).map &:val                  end
+    def fluff1(e);  _fluff1(e).val                        end
+    def _fluff(es); es.map {|e| _fluff1 e}                end
+    def _fluff1(e); reduce(Rule.return(e),:bind).unwrap!  end
   end
+  # see DSL#build_core
+  def self.build(&b); DSL.build_core &b end
 end
 

data/mallow.gemspec

@@ -2,7 +2,7 @@ $LOAD_PATH << File.expand_path("../lib", __FILE__)
 require 'rake'
 require 'mallow/version'
 
-mallow = Gem::Specification.new do |spec|
+Gem::Specification.new do |spec|
   spec.name        = 'mallow'
   spec.version     = Mallow::VERSION
   spec.author      = 'feivel jellyfish'
@@ -12,6 +12,6 @@ mallow = Gem::Specification.new do |spec|
   spec.homepage    = 'http://github.com/gwentacle/mallow'
   spec.summary     = 'Tiny universal data pattern matcher / dispatcher'
   spec.description = 'Tiny universal data pattern matcher / dispatcher'
-  spec.add_development_dependency 'graham'
+  spec.add_development_dependency 'graham', '>=0.0.2'
 end
 

data/test/case/control.rb

@@ -0,0 +1,44 @@
+class Cases
+  def initialize
+    @mallow = Mallow.build do |match|
+      match.a(String).to{upcase}
+      match.a_tuple(3).to {|a,b,c| a+b+c}
+      match.a(Fixnum).to {self*2}
+    end
+  end
+
+  def test_case_1
+    @mallow.fluff [ 99, 'asdf', 'qwer', [5,5,5], 47, %w{cool story bro} ]
+  end
+
+end
+
+class Exceptions
+  def initialize
+    @mallow = Mallow.build do |match|
+      match.a(Fixnum).to {self/0}
+      match.a(String).to {self/0}
+    end
+  end
+  def division_by_zero
+    @mallow.fluff1 1
+  end
+  def calling_a_nonexistent_method
+    @mallow.fluff1 ?1
+  end
+  def an_unmatched_element
+    @mallow.fluff1 :ok
+  end
+
+end
+
+Graham.pp(Cases) {|that|
+  that.test_case_1.returns_an_array.that_is [ 198, 'ASDF', 'QWER', 15, 94, 'coolstorybro' ]
+}
+
+Graham.pp(Exceptions) {|that|
+  that.division_by_zero.raises_a ZeroDivisionError
+  that.calling_a_nonexistent_method.raises_a NoMethodError
+  that.an_unmatched_element.raises_a Mallow::MatchException
+}
+

data/test/unit/meta.rb

@@ -0,0 +1,11 @@
+class MetaTests
+  def binding_behaviour_with_common_keys
+    meta = Mallow::Meta.return 1, meta: :data, any: :body?
+    meta.bind ->(v){Mallow::Meta.return v, meta: :data!}
+  end
+end
+
+Graham.pp(MetaTests) do |that|
+  that.binding_behaviour_with_common_keys.returns meta: :data!, any: :body?
+end
+

data/test/unit/{monad.rb → monad_laws.rb}

@@ -1,4 +1,4 @@
-class Graham::MonadLaws
+class MonadLaws
   def RuleLeftIdentity
     rule = Mallow::Rule.return 350_000_000
     f = Mallow::Rule::Builder[Mallow::Matcher.new][Mallow::Transformer.new]
@@ -36,7 +36,7 @@ class Graham::MonadLaws
   end
 end
 
-Graham.pp(:MonadLaws) {|that|
+Graham.pp(MonadLaws) {|that|
   that.RuleLeftIdentity.is  true
   that.RuleRightIdentity.is true
   that.RuleAssociativity.is true

data/test/unit/rule.rb

@@ -0,0 +1,52 @@
+class RuleTests
+  def initialize
+    (@fmatcher = Mallow::Matcher.new)[0] = ->(e){false}
+    (@pmatcher = Mallow::Matcher.new)[0] = ->(e){true}
+    @fbuilder = Mallow::Rule::Builder[@fmatcher, Mallow::Transformer.new]
+    @pbuilder = Mallow::Rule::Builder[@pmatcher, Mallow::Transformer.new]
+  end
+
+  def unwrapping_an_empty_rule
+    Mallow::Rule.return(nil).unwrap!
+  end
+
+  def unwrapping_a_passing_rule
+    @pbuilder[:value].unwrap!
+  end
+
+  def unwrapping_a_failing_rule
+    @fbuilder[:value].unwrap!
+  end
+
+  def binding_a_failing_rule_in_a_passing_rule
+    @fbuilder[1].bind(@pbuilder)
+  end
+
+  def binding_a_passing_rule_in_a_failing_rule
+    @pbuilder[//].bind(@fbuilder)
+  end
+
+  def binding_a_passing_rule_in_a_passing_rule
+    (passing_matcher = Mallow::Matcher.new)[0] = ->(e){1}
+    passing_builder  = Mallow::Rule::Builder[passing_matcher, Mallow::Transformer.new]
+    @pbuilder[1].bind passing_builder
+  end
+
+  def binding_a_failing_rule_in_a_failing_rule
+    (failing_matcher = Mallow::Matcher.new)[0] = ->(e){nil}
+    failing_builder  = Mallow::Rule::Builder[failing_matcher, Mallow::Transformer.new]
+    @fbuilder[1].bind failing_builder
+  end
+end
+
+Graham.pp(RuleTests) do |that|
+  that.unwrapping_an_empty_rule.raises_a Mallow::MatchException
+  that.unwrapping_a_failing_rule.raises_a Mallow::MatchException
+  that.unwrapping_a_passing_rule.returns_a(Mallow::Meta).such_that { val == :value }
+
+  that.binding_a_failing_rule_in_a_passing_rule.returns_a(Mallow::Rule).such_that { matcher === val }
+  that.binding_a_passing_rule_in_a_passing_rule.returns_a(Mallow::Rule).such_that { matcher === val }
+  that.binding_a_passing_rule_in_a_failing_rule.returns_a(Mallow::Rule).such_that { matcher === val }
+  that.binding_a_failing_rule_in_a_failing_rule.returns_a(Mallow::Rule).such_that { not matcher === val }
+end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mallow
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-25 00:00:00.000000000 Z
+date: 2012-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graham
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.2
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.2
 description: Tiny universal data pattern matcher / dispatcher
 email: feivel@sdf.org
 executables: []
@@ -36,12 +36,15 @@ files:
 - mallow.gemspec
 - README.md
 - lib/mallow.rb
+- lib/mallow/basic_dsl.rb
 - lib/mallow/version.rb
 - lib/mallow/dsl.rb
 - lib/mallow/monads.rb
 - Rakefile
-- test/case/mallow.rb
-- test/unit/monad.rb
+- test/case/control.rb
+- test/unit/monad_laws.rb
+- test/unit/meta.rb
+- test/unit/rule.rb
 homepage: http://github.com/gwentacle/mallow
 licenses: []
 post_install_message: 
@@ -68,5 +71,7 @@ specification_version: 3
 summary: Tiny universal data pattern matcher / dispatcher
 test_files:
 - Rakefile
-- test/case/mallow.rb
-- test/unit/monad.rb
+- test/case/control.rb
+- test/unit/monad_laws.rb
+- test/unit/meta.rb
+- test/unit/rule.rb

data/test/case/mallow.rb

@@ -1,38 +0,0 @@
-class Graham::Cases
-  def initialize
-    @mallow1 = Mallow.fluff do |match|
-      match.a_string.to_upcase
-      match.a_tuple(3).to {|a,b,c| a+b+c}
-      match.a_fixnum.to {self*2}
-    end
-
-    @xmallow = Mallow.fluff do |match|
-      match.a(Fixnum).to {self/0}
-      match.a(String).to {self/self}
-      match.*.to {}
-      match.a_symbol.to {UNDEFINED}
-    end
-  end
-
-  def Case1
-    @mallow1.fluff [ 99, 'asdf', 'qwer', [5,5,5], 47, %w{cool story bro} ]
-  end
-
-  def XCase1
-    @xmallow.fluff1 1
-  end
-  def XCase2
-    @xmallow.fluff1 ?1
-  end
-  def XCase3
-    @xmallow.fluff1 :ok
-  end
-end
-
-Graham.pp {|that|
-  that.Case1.returns_an(Array).that_is [ 198, 'ASDF', 'QWER', 15, 94, 'coolstorybro' ]
-  that.XCase1.raises_a ZeroDivisionError
-  that.XCase2.raises_a NoMethodError
-  that.XCase3.does_not_raise_an_exception
-}
-