mobj 1.0.0 → 1.5.4

data/README.md

@@ -1,71 +1,16 @@
-ctx
+mobj
 ===
 
-Simple utility to limit method redefinition within the bounds of arbitrary logical scopes
+Some utilities that I keep using.
 
 Example
 ===
 
-Here, figure it out:
-
-    require 'ctx'
-
-    class ::String
-      ctx :reversaroo do
-        def +(other)
-          "#{other.reverse}#{self.reverse}"
-        end
-      end
-      ctx :camels do
-        def +(other)
-          "#{self.capitalize}#{other.capitalize}"
-        end
-      end
-      ctx :polite do
-        def +(other)
-          "I say, good day to you there '#{other}', may I introduce you to my good friend '#{self}'?"
-        end
-      end
-      ctx do
-        def +(other)
-          "#{self} + #{other} = ?"
-        end
-      end
-    end
-
-    puts "hello" + "world"
-    #=> helloworld
-
-    ctx :camels do
-      puts "hello" + "world"
-      #=> HelloWorld
-
-      ctx :polite do
-        puts "hello" + "world"
-        #=> I say, good day to you there 'world', may I introduce you to my good friend 'hello'?
-      end
-
-      ctx do
-        puts "hello" + "world"
-        #=> hello + world = ?
-      end
-    end
-
-    ctx :reversaroo do
-      puts "hello" + "world"
-      #=> dlrowolleh
-    end
-
-    puts "hello" + "world"
-    #=> helloworld
-
-
-There are bugs.  You'll find them.
+Read the code.
 
 ---
 
 Caveats and such
 ===
 
-For whatever goofy reason, this stuff doesn't play well with rspec all the time, particularly if you override stuff the matchers are hoping to also override, like == or =~ on String, or whatnot.  Don't do that right now unless you like stuff to break in inexplicable ways.  Personally, I do like that kind of stuff, makes life interesting (kind of explains my dating choices, when you get right down to it), but anywhoo, honestly, it's your call.
-
+None.  It's prefection.

data/lib/mobj.rb

@@ -1,18 +1,29 @@
 module Mobj
 
-  class ::BasicObject
+  class ::Object
+    alias responds_to? respond_to?
     def sym() respond_to?(:to_sym) ? to_sym : to_s.to_sym end
-    def mparent(rent = :mparent) @mparent = rent unless rent == :mparent; @mparent end
-    def mroot() mparent.nil? ? self : mparent.mroot 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)
+      unless rent == :mparent
+        @mparent = rent == self ? nil : rent
+      end
+      @mparent
+    end
   end
 
   class ::Class
-    def object_methods() (self.instance_methods - Object.instance_methods).sort end
-    def class_methods() (self.singleton_methods - Object.singleton_methods).sort end
+    def object_methods() (self.instance_methods(true) - Object.instance_methods(true)).sort end
+    def class_methods() (self.singleton_methods(true) - Object.singleton_methods(true)).sort end
     def defined_methods() (class_methods | object_methods).sort end
   end
 
   class ::Array
+    alias includes? include?
+    alias contains? include?
+
+    def values() self end
     def sequester(lim = 1) compact.size <= lim ? compact.first : self end
     def return_first(&block)
       returned = nil
@@ -21,7 +32,7 @@ module Mobj
     end
   end
 
-  class Moken
+  class Token
     def initialize(type, *args)
       @type, @path, @options = type.to_sym, nil, {}
       tokens = []
@@ -40,29 +51,33 @@ module Mobj
     def to_s() "#{@type.to_s.upcase}(#@path#{ " => #@options" unless @options.empty?})" end
 
     def extract(obj, path)
-      if obj.is_a?(Array)
-        if path == :*
-          obj
-        else
-          obj.map { |o| extract(o, path)}
-        end
+      obj.reparent
+      if path == :*
+        obj
+      elsif obj.is_a?(Array)
+        obj.map { |o| extract(o, path) }
+      elsif path.is_a?(Array)
+        path.map { |pth| obj[pth.sym] }
       else
-        if path.is_a?(Array)
-          path.map { |pth| obj[pth.sym] }
-        else
-          obj[path.sym]
-        end
+        obj[path.sym]
       end
     end
 
     def walk(obj, root = obj)
+      obj, root = Circle.wrap(obj), Circle.wrap(root)
       val = case @type
               when :literal
                 @path.to_s
               when :path
                 extract(obj, @path)
               when :regex
-                obj.keys.map { |key| key if key.match(@path) }.compact.map{|key| obj[key]}
+                obj.keys.map { |key| key if key.match(@path) }.compact.map{|key| obj[key] }
+              when :up
+                if obj.respond_to? :parent
+                  obj.mparent || obj.parent
+                else
+                  obj.mparent
+                end
               when :any
                 @path.return_first { |token| token.walk(obj, root) }
               when :all
@@ -78,7 +93,7 @@ module Mobj
                   lookup.tokenize.walk(root)
                 end
               when :inverse
-                raise "not implemented yet.  not sure how to implement yet, actually.  please continue to hold.  your call is important to us."
+                raise "not implemented yet. not sure how to implement yet, actually. please continue to hold. your call is important to us."
               when :root
                 tree = [@path].flatten
                 while (path = tree.shift)
@@ -87,7 +102,8 @@ module Mobj
                 obj.is_a?(Array) ? obj.flatten : obj
             end
 
-      @options[:indexes] ? val.values_at(*@options[:indexes])  : val
+      val = @options[:indexes] ? val.values_at(*@options[:indexes]) : val
+      val
     end
   end
 
@@ -96,23 +112,25 @@ module Mobj
 
     def tokenize
       tokens = []
-      scan(/\~([^\.]+)|\/(.*?)\/|\{\{(.*?)\}\}|([^\.\[]+)(?:\[([\d\+\.,-]+)\])?/).each do |literal, regex, lookup, path, indexes|
+      scan(/\~([^\.]+)|\/(.*?)\/|\{\{(.*?)\}\}|(\^)|([^\.\[]+)(?:\[([\d\+\.,-]+)\])?/).each do |literal, regex, lookup, up, path, indexes|
         if literal
-          tokens << Moken.new(:literal, literal)
+          tokens << Token.new(:literal, literal)
         elsif lookup
-          tokens << Moken.new(:lookup, lookup.tokenize)
+          tokens << Token.new(:lookup, lookup.tokenize)
         elsif regex
-          tokens << Moken.new(:regex, Regexp.new(regex))
+          tokens << Token.new(:regex, Regexp.new(regex))
+        elsif up
+          tokens << Token.new(:up)
         elsif path
           eachs = path.split(",")
           ors = path.split("|")
           ands = path.split("&")
           if eachs.size > 1
-            tokens << Moken.new(:each, eachs.map { |token| token.tokenize() })
+            tokens << Token.new(:each, eachs.map { |token| token.tokenize() })
           elsif ands.size > 1
-            tokens << Moken.new(:all, ands.map { |token| token.tokenize() })
+            tokens << Token.new(:all, ands.map { |token| token.tokenize() })
           elsif ors.size > 1
-            tokens << Moken.new(:any, ors.map { |token| token.tokenize() })
+            tokens << Token.new(:any, ors.map { |token| token.tokenize() })
           end
 
           unless ands.size + ors.size + eachs.size > 3
@@ -122,59 +140,82 @@ module Mobj
             end if indexes
 
             if path[0] == '!'
-              tokens << Moken.new(:inverse, Moken.new(:path, path[1..-1].sym, options))
+              tokens << Token.new(:inverse, Token.new(:path, path[1..-1].sym, options))
             else
-              tokens << Moken.new(:path, path.sym, options)
+              tokens << Token.new(:path, path.sym, options)
             end
           end
         end
       end
-      tokens.size == 1 ? tokens.first : Moken.new(:root, tokens)
+      tokens.size == 1 ? tokens.first : Token.new(:root, tokens)
     end
   end
 
-  class Circle < Hash
+  class Circle
+    def self.wrap(wrapped)
+      return wrapped if wrapped.is_a?(CircleHash) || wrapped.is_a?(CircleRay)
 
-    def initialize
-      super
-      @index = 0
+      if wrapped.is_a?(Array)
+        circle = CircleRay.new
+        wrapped.each_with_index { |item, i| circle[i] = wrap(item) }
+        circle
+      elsif wrapped.is_a?(Hash)
+        circle = CircleHash.new
+        wrapped.each_pair { |key, val| circle[key] = wrap(val) }
+        circle
+      else
+        wrapped
+      end
     end
+  end
 
-    def <<(val)
-      self[@index] = val
-      @index += 1
+  class CircleHash < Hash
+    def *(&block)
+      if block.nil?
+        self
+      else
+        map = CircleHash.new
+        self.each_pair do |key, val|
+          map.merge!(block.call(key, val))
+        end
+        map
+      end
     end
 
     def []=(*keys, val)
       val.mparent(self)
-      keys.each do |key|
-        if key.is_a?(Range)
-          key.to_a.each{ |k| self[k]= val }
-        else
-          @index = key + 1 if key.is_a?(Fixnum) && key >= @index
-          store(key.sym, val)
-        end
-      end
+      keys.each { |key| store(key.sym, val) }
     end
 
     alias_method :lookup, :[]
-    def [](*keys) keys.map { |key| self.lookup(key.sym) }.sequester
-    end
+    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)
+    def method_missing(name, *args, &block) self.has_key?(name) ? self[name] : super(name, *args, &block) end
+  end
+
+  class CircleRay < Array
+    alias_method :*, :map
+
+    alias_method :set, :[]=
+    def []=(*keys, val)
+      val.mparent(self)
+      set(*keys, val)
     end
 
-    def self.wrap(wrapped)
-      circle = self.new
-      if wrapped.is_a?(Array)
-        wrapped.each_with_index { |item, i| circle[i] = wrap(item) }
-      elsif wrapped.is_a?(Hash)
-        wrapped.each_pair { |key, val| circle[key] = wrap(val) }
-      else
-        return wrapped
+    alias_method :append, :<<
+    def <<(*vals)
+      vals.each do |val|
+        val.mparent(self)
+        self.append(val)
       end
-      circle
+      self
+    end
+
+    alias_method :lookup, :[]
+    def [](*keys)
+      keys.map do |key|
+        self.lookup(key)
+      end.sequester
     end
   end
 

metadata

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