mobj 1.5.4 → 1.6.7

data/lib/mobj.rb

@@ -1,8 +1,72 @@
 module Mobj
 
+
+  #magic init
+  #class Object
+  #  alias_method :orig_method_missing, :method_missing
+  #
+  #  def method_missing(m, *a, &b)
+  #    klass = begin
+  #      (self.is_a?(Module) ? self : self.class).const_get(m)
+  #    rescue NameError
+  #    end
+  #
+  #    return klass.send(:parens, *a, &b)  if klass.respond_to? :parens
+  #    orig_method_missing m, *a, &b
+  #  end
+  #end
+
+  #class Object
+  #  alias_method :orig_method_missing, :method_missing
+  #
+  #  def method_missing(m, *a, &b)
+  #    begin
+  #      l = eval(m.to_s, binding_n(1))
+  #    rescue NameError
+  #    else
+  #      return l.call(*a)  if l.respond_to? :call
+  #    end
+  #    orig_method_missing m, *a, &b
+  #  end
+  #end
+  #
+  #def call_a_lambda_with_parenths(val)
+  #  l = lambda {|v| p v }
+  #  l(val)
+  #end
+  #
+  #call_a_lambda_with_parenths(6)
+
+  class ::BasicObject
+    def class
+      klass = class << self; self end
+      klass.superclass
+    end
+  end
+
+  class ::Fixnum
+    def delimit(delim = ',')
+      to_s.split('').reverse.each_slice(3).to_a.map(&:join).join(delim).reverse
+    end
+  end
+
+  class ::Float
+    def delimit(delim = ',')
+      "#{to_i.delimit(delim)}.#{to_s.to_s[/\.(\d+)$/, 1]}"
+    end
+  end
+
+  class Forwarder < ::BasicObject
+    attr_accessor :root, :handler
+    def initialize(root = nil, &handler) @root, @handler = root, handler end
+    def method_missing(name, *args, &block) handler.call(name, *args, &block) end
+  end
+
   class ::Object
     alias responds_to? respond_to?
     def sym() respond_to?(:to_sym) ? to_sym : to_s.to_sym end
+    def s() respond_to?(:to_s) ? to_s : inspect end
+    def str() respond_to?(:to_str) ? to_str : to_s end
     def mroot() mparent.nil? || mparent == self ? self : mparent.mroot end
     def reparent() values.each { |v| v.mparent(self); v.reparent } if respond_to? :values end
     def mparent(rent = :mparent)
@@ -11,6 +75,74 @@ module Mobj
       end
       @mparent
     end
+    def attempt(value=:root)
+      Forwarder.new do |name, *args, &block|
+        if self.methods(true).include? name
+          self.__send__(name, *args, &block)
+        elsif value.is_a?(Proc)
+          value.call([name] + args, &block)
+        elsif value.is_a?(Hash) && value.key?(name)
+          value[name].when.is_a?(Proc).call(*args, &block)
+        else
+          value == :root ? self : value
+        end
+      end
+    end
+    alias_method :try?, :attempt
+    alias_method :do?, :attempt
+    alias_method :does?, :attempt
+    alias_method :if!, :attempt
+
+    def when
+      Forwarder.new do |name, *args, &block|
+        if self.methods.include?(name) && self.__send__(name, *args, &block)
+          thn = Forwarder.new do |name, *args, &block|
+            if name.sym == :then
+              thn
+            else
+              ret = self.__send__(name, *args, &block)
+              ret.define_singleton_method(:else) { Forwarder.new { ret } }
+              ret
+            end
+          end
+        else
+          Forwarder.new do |name|
+            if name.sym == :then
+              els = Forwarder.new do |name|
+                if name.sym == :else
+                  Forwarder.new { |name, *args, &block| self.__send__(name, *args, &block) }
+                else
+                  els
+                end
+              end
+            else
+              self
+            end
+          end
+        end
+      end
+    end
+    alias_method :if?, :when
+  end
+
+  class ::NilClass
+    def attempt(value=true)
+      Forwarder.new do |name, *args, &block|
+        if self.methods(true).include? name
+          self.__send__(name, *args, &block)
+        elsif value.is_a?(Proc)
+          value.call([name] + args, &block)
+        elsif value.is_a?(Hash) && value.key?(name)
+          value[name].when.is_a?(Proc).call(*args, &block)
+        else
+          value
+        end
+      end
+    end
+    alias_method :try?, :attempt
+    alias_method :do?, :attempt
+    alias_method :does?, :attempt
+    alias_method :if!, :attempt
   end
 
   class ::Class
@@ -24,7 +156,13 @@ module Mobj
     alias contains? include?
 
     def values() self end
-    def sequester(lim = 1) compact.size <= lim ? compact.first : self end
+    def sequester(crush = true)
+      if crush
+        compact.size <= 1 ? compact.first : self
+      else
+        size <= 1 ? first : self
+      end
+    end
     def return_first(&block)
       returned = nil
       each { |item| break if (returned = block.call(item)) }
@@ -32,6 +170,51 @@ module Mobj
     end
   end
 
+  module HashEx
+    def method_missing(name, *args, &block)
+      if name[-1] == '=' && args.size == 1
+        key = name[0...-1].sym
+        key = key.s if key?(key.s)
+        return self[key] = args.sequester
+      elsif name[-1] == '?'
+        key = name[0...-1].sym
+        return !!self[key, key.to_s]
+      elsif key?(name.sym) || key?(name.to_s)
+        return self[name.sym] || self[name.to_s]
+      end
+      super
+    end
+  end
+
+  class ::Hash
+    include HashEx
+
+    alias :mlookup :[]
+    alias :mdef :default
+    def [](*fkeys)
+      fkeys.map { |key| mlookup(key) || fetch(key.sym) { fetch(key.to_s) { mdef(key) }  } }.sequester
+    end
+  end
+
+  module MatchEx
+    def to_hash
+      Hash[ names.map(&:sym).zip( captures ) ]
+    end
+
+    def method_missing(name, *args, &block)
+      if name[-1] == '?' && names.includes?(name[0...-1])
+        return to_hash[name[0...-1].sym]
+      elsif names.includes?(name.to_s)
+        return to_hash[name.sym]
+      end
+      super
+    end
+  end
+
+  class ::MatchData
+    include MatchEx
+  end
+
   class Token
     def initialize(type, *args)
       @type, @path, @options = type.to_sym, nil, {}
@@ -52,7 +235,7 @@ module Mobj
 
     def extract(obj, path)
       obj.reparent
-      if path == :*
+      if path == :* || obj.nil?
         obj
       elsif obj.is_a?(Array)
         obj.map { |o| extract(o, path) }
@@ -109,6 +292,7 @@ module Mobj
 
   class ::String
     def ~@() "~#{self}" end
+    def -@() "^.#{self}" end
 
     def tokenize
       tokens = []
@@ -186,11 +370,6 @@ module Mobj
       val.mparent(self)
       keys.each { |key| store(key.sym, val) }
     end
-
-    alias_method :lookup, :[]
-    def [](*keys) keys.map { |key| self.lookup(key.sym) }.sequester end
-
-    def method_missing(name, *args, &block) self.has_key?(name) ? self[name] : super(name, *args, &block) end
   end
 
   class CircleRay < Array
@@ -212,11 +391,7 @@ module Mobj
     end
 
     alias_method :lookup, :[]
-    def [](*keys)
-      keys.map do |key|
-        self.lookup(key)
-      end.sequester
-    end
+    def [](*keys) keys.map { |key| self.lookup(key) }.sequester end
   end
-
 end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mobj
 version: !ruby/object:Gem::Version
-  version: 1.5.4
+  version: 1.6.7
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-11 00:00:00.000000000 Z
+date: 2012-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec