mallow 0.0.2

data/README.md

@@ -0,0 +1,64 @@
+# Mallow #
+
+Mallow is an engine and DSL for pattern matching and transforming Ruby objects that mildly eases the task of processing heterogeneous data sets. It is small, stateless, and strives to take simultaneous advantage of neat-o Ruby language features and functional programming techniques, while also reinventing ~~as few wheels as possible~~ ~~relatively few wheels~~ <  1 wheel / 20 LOC.
+
+An example of Mallow's versatility is Graham, a tiny testing library powered by Mallow and used for Mallow's own unit tests.
+
+## Papa teach me to mallow ##
+
+To mallow is very simple little boy: first marshal, then mallow!
+
+```ruby
+  mallow = Mallow::Core.build do |match|
+    match.a_hash.to {"#{keys.first} #{values.first}"}
+  end
+```
+Now feed your mallow some iterable data:
+```ruby
+  data = [{:hay => :good_buddy}]
+  mallow.fluff data #=> ["hay good_buddy"]
+```
+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|
+    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!
+    match.a_fixnum.of_size(8).to {'8bit'}
+    match.a_string.to_upcase
+    match.*.to { WILDCARD }
+  }.fluff( data )
+```
+
+### Metadata ###
+
+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|
+    line = 0
+    match.a(Fixnum).to {"Found a fixnum on line #{line+=1}"}
+    match.*.to {|e| line+=1;e}
+  end
+```
+But that is just awful, and will betray you if you forget to increment the line number or define your rules in different lexical environments.
+
+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
+  end
+
+  data = doubler.fluff  [1,2,:moo]     #=> [2, 4, nil]
+  metadata = doubler._fluff [1,2,:moo] #=> [{:type=>Fixnum}, {:type=>Fixnum}, {:matched=>false}]
+  metadata.map(&:val)                  #=> [2, 4, nil]
+```
+
+### Blocks & bindings ###
+
+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
+```
+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/Rakefile

@@ -0,0 +1,18 @@
+$LOAD_PATH << File.expand_path('../lib', __FILE__)
+require 'mallow'
+require 'rake'
+require 'graham/rake_task'
+
+Graham::RakeTask.new
+task default: :test
+
+namespace :gem do
+  task :build do
+    sh "gem b mallow.gemspec"
+  end
+  task :install do
+    sh "gem i #{Dir.glob('mallow-*.gem').sort.last}"
+  end
+end
+task gem: %w{ gem:build gem:install }
+

data/lib/mallow/dsl.rb

@@ -0,0 +1,104 @@
+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
+      end
+    end
+
+    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/monads.rb

@@ -0,0 +1,55 @@
+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
+    # 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)
+    Builder = ->(cs, as, e) {Rule.new cs, as, e }.curry
+    # Behaves like an inverted Maybe: return self if match succeeds, otherwise
+    # attempt another match.
+    def bind(rule_proc); matcher === val ? self : rule_proc[val] end
+    def return(val); Rule.new matcher, transformer, val end
+    def unwrap!; matcher === val ? transformer >> val : dx end
+    private
+    def dx
+      raise DeserializationException, "No rule matches #{val}:#{val.class}"
+    end
+  end
+  # Wrapper monad(ish) for successful matches that allows the user to
+  # transparently store and access metadata across binds.
+  class Meta < Hash
+    attr_reader :val
+    # Curried proc that takes a proc and an object, calls the proc with the
+    # object, and wraps the return value in a Meta if it wasn't one already.
+    Builder = ->(p,e) { Meta === (e=p[e]) ? e : Meta.return(e) }.curry
+    def initialize(obj,md={})
+      @val = obj
+      merge! md
+    end
+    # Calls argument with the wrapped object and reverse-merges its metadata
+    # into that of the return value.
+    def bind(meta_proc); meta_proc[val].merge(self) {|k,o,n| o} end
+    class << self; alias return new end
+  end
+
+  # Container for rule conditions
+  class Matcher < Array
+    # Checks argument against all conditions; returns false if no conditions
+    # are present
+    def ===(e); any? and all? {|t| t[e]} end
+  end
+  # Container for rule actions
+  class Transformer < Array
+    # Threads argument through actions
+    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

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

data/lib/mallow.rb

@@ -0,0 +1,40 @@
+$LOAD_PATH << File.dirname(__FILE__)
+require 'mallow/version'
+require 'mallow/monads'
+require 'mallow/dsl'
+module Mallow
+  class DeserializationException < 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
+  end
+end
+

data/mallow.gemspec

@@ -0,0 +1,17 @@
+$LOAD_PATH << File.expand_path("../lib", __FILE__)
+require 'rake'
+require 'mallow/version'
+
+mallow = Gem::Specification.new do |spec|
+  spec.name        = 'mallow'
+  spec.version     = Mallow::VERSION
+  spec.author      = 'feivel jellyfish'
+  spec.email       = 'feivel@sdf.org'
+  spec.files       = FileList['mallow.gemspec','README.md','lib/**/*.rb']
+  spec.test_files  = FileList['Rakefile','test/**/*.rb']
+  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'
+end
+

data/test/case/mallow.rb

@@ -0,0 +1,38 @@
+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
+}
+

data/test/unit/monad.rb

@@ -0,0 +1,48 @@
+class Graham::MonadLaws
+  def RuleLeftIdentity
+    rule = Mallow::Rule.return 350_000_000
+    f = Mallow::Rule::Builder[Mallow::Matcher.new][Mallow::Transformer.new]
+    rule.bind(f) == f[rule.val]
+  end
+
+  def RuleRightIdentity
+    rule = Mallow::Rule.return /thing/
+    rule == rule.bind(->(v){Mallow::Rule.return v})
+  end
+
+  def RuleAssociativity
+    rule = Mallow::Rule.return %w{qqq}
+    f = Mallow::Rule::Builder[Mallow::Matcher.new][Mallow::Transformer.new]
+    g = Mallow::Rule::Builder[Mallow::Matcher.new][Mallow::Transformer.new]
+    rule.bind(f).bind(g) == rule.bind(->(v){f[v].bind g})
+  end
+
+  def MetaLeftIdentity
+    meta = Mallow::Meta.return RUBY_VERSION
+    f = ->(v) {Mallow::Meta.return v, test: :data}
+    meta.bind(f) == f[meta.val]
+  end
+
+  def MetaRightIdentity
+    meta = Mallow::Meta.return Mallow
+    meta == meta.bind(->(v){Mallow::Meta.return v})
+  end
+
+  def MetaAssociativity
+    meta = Mallow::Meta.return __FILE__
+    f = ->(v){Mallow::Meta.return v, Florence: 'Nightingale'}
+    g = ->(v){Mallow::Meta.return v, 'Punk' => :Rock}
+    meta.bind(f).bind(g) == meta.bind(->(v){f[v].bind(g)})
+  end
+end
+
+Graham.pp(:MonadLaws) {|that|
+  that.RuleLeftIdentity.is  true
+  that.RuleRightIdentity.is true
+  that.RuleAssociativity.is true
+
+  that.MetaLeftIdentity.is  true
+  that.MetaRightIdentity.is true
+  that.MetaAssociativity.is true
+}
+

metadata

@@ -0,0 +1,72 @@
+--- !ruby/object:Gem::Specification
+name: mallow
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- feivel jellyfish
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: graham
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Tiny universal data pattern matcher / dispatcher
+email: feivel@sdf.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- mallow.gemspec
+- README.md
+- lib/mallow.rb
+- lib/mallow/version.rb
+- lib/mallow/dsl.rb
+- lib/mallow/monads.rb
+- Rakefile
+- test/case/mallow.rb
+- test/unit/monad.rb
+homepage: http://github.com/gwentacle/mallow
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Tiny universal data pattern matcher / dispatcher
+test_files:
+- Rakefile
+- test/case/mallow.rb
+- test/unit/monad.rb