mobj 1.6.9 → 1.7.1

data/README.md

@@ -3,14 +3,170 @@ mobj
 
 Some utilities that I keep using.
 
+Of particular note may be the string tokenizer/path walker.
+
 Example
 ===
 
 Read the code.
 
+No, really.  Give me some examples, dork.
+===
+
+Fine.
+
+### Toking Up
+
+This is really the most useful part of the entire library, when you get right down to it.
+String is given a method called "tokenize" that allows it's contents to be split up into
+a structured path of tokens.  This tokenized path can then be used to do some pretty amazing
+things in terms of walking through arbitrarily complex trees of data.
+
+For example, given this object:
+
+```ruby
+obj = {
+    name: { first: "Joe", last: "Smith" },
+    ids: [ 1, 3, 5, 16, 941, 13, 100, 3, 0, 104 ],
+    auth_tokens: [ { provider: { name: "example.com", id:123 }, token: { auth: "123456", expire: "10-20-2012" } },
+                   { provider: { name: "site.com", id:265 },    token: { authentication_token: "891011", date: "10-20-2013" } }
+    ],
+    primary_key: { path: "auth_tokens.provider" }
+}
+```
+
+...  Easily traverse it's data using rules embedded into a simple string, like so:
+
+```ruby
+# Walk a simple object path:
+"name.first".walk(obj)
+#=> "Joe"
+
+# Select multiple items out of an object:
+"name.first,last".walk(obj)
+#=> ["Joe", "Smith"]
+
+# Or indexes (and ranges) in an array:
+"ids[1, 3, 5 - 7, 9+]".walk(obj)
+#=> [3, 16, 13, 100, 3, 104]
+
+# Use regular expressions or method calls as selection keys:
+"auth_tokens.token./^auth/.*to_i".walk(obj)
+#=> [ 123456, 891011 ]
+
+# Choose the first element that doesn't return nil:
+"auth_tokens.token.expire|date".walk(obj)
+#=> [ "10-20-2012", "10-20-2013" ]
+
+# Provide default values when everything is nil:
+"/auth/.provider,token.auth|authentication_token|~N/A".walk(obj)
+#=> ["N/A", "N/A", "123456", "891011"]
+
+# Even look up keys based on the values in other fields:
+"{{primary_key.path}}.id".walk(obj)
+#=> [123, 265]
+
+```
+
+And much, much more, though you'd probably want to check out the tests to see how it really works.
+
+### Much Ado about Nulling
+
+Every so often you find yourself in a situation where you want nil to behave like "null"
+(i.e. you want it to silently allow unknown method calls to simply do nothing instead of throwing
+and exception).  All classes are now given a "null!" method that alters the behavior of nil for
+the remainder of the line:
+
+```ruby
+obj = FooObject.new
+
+if obj.null!.foo.bar.baz
+  puts "Acts like normal"
+end
+
+obj = nil
+
+if obj.null!.foo.bar.baz
+  puts "Won't throw and exception and evaluates to nil"
+end
+
+if obj.foo.bar.baz
+  puts "Will throw an exception as normal"
+end
+```
+
+### When you just want to be contrary
+
+Sometimes you just want to write everything in dot notation for no reason.
+Or maybe you have a reason, and that reason is impressing your co workers with your
+ruby tricks:
+
+```ruby
+if foo && foo.bar
+  foo.baz
+else
+  foo.biz
+end
+```
+... becomes ...
+
+```ruby
+foo.when.bar.then.baz.else.biz
+```
+
+### Sequestration, HashEx, MatchEx, etc
+
+Found myself writing these things sooo many times that I just dumped them into my package of stuff:
+
+```ruby
+foo.compact.size == 1 ? foo.compact.first : foo.compact
+```
+... becomes ...
+
+```ruby
+foo.sequester
+```
+
+Hash utils:
+
+```ruby
+hash = { symbol: "sym", "string" => "string", :nilval => nil }
+
+hash.symbol == hash[:symbol] == hash[:symbol]
+#=> These are equvilent
+
+hash.string == hash[:string] == hash["string"]
+#=> These are also equvilent
+
+hash.string?
+#=> true
+
+hash.nilval?
+#=> false
+
+hash.unknown?
+#=> True
+```
+
+Matching stuff
+
+```ruby
+match = "Joe Bob".match(/(?<first_name>\w+) (?<first_name>)/)
+
+match.to_hash
+#=> Creates a hash of named captures
+
+match.first_name if match.first_name?
+#=> Or just use them directly as method names
+
+"foo,bar,baz".matches(/([^,]+),/) do |match|
+  #=> same as "string#scan", but returns the actual MatchData
+end
+```
+
 ---
 
 Caveats and such
 ===
 
-None.  It's prefection.
+All of them.

data/lib/mobj.rb

@@ -5,6 +5,8 @@ module Mobj
       klass = class << self; self end
       klass.superclass
     end
+    def null!() self end
+    def nil!() self end
   end
 
   class ::Fixnum
@@ -244,15 +246,33 @@ module Mobj
         end
       elsif path.is_a?(Array)
         path.map { |pth| obj[pth.sym] }
+      elsif path[0] == '*' && obj.respond_to?(path[1..-1].sym)
+        obj.__send__(path[1..-1].sym)
+      elsif obj.respond_to? :[]
+        if obj.is_a?(Hash)
+          obj[path.sym]
+        else
+          obj[path.to_s.to_i] if path.to_s =~ /^\d+$/
+        end
       elsif obj.respond_to?(path.sym)
         obj.__send__(path.sym)
-      elsif obj.respond_to? :[]
-        obj[path.sym]
       else
         nil
       end
     end
 
+
+
+    def find(obj, match)
+      if obj.is_a?(Array)
+        obj.map do |child|
+          find(child, match)
+        end
+      elsif obj.respond_to?(:keys)
+        obj.keys.map { |key| key if key.match(match) }.compact.map{|key| obj[key] }
+      end
+    end
+
     def walk(obj, root = obj)
       obj, root = Circle.wrap(obj), Circle.wrap(root)
       val = case @type
@@ -261,7 +281,7 @@ module Mobj
               when :path
                 extract(obj, @path)
               when :regex
-                obj.keys.map { |key| key if key.match(@path) }.compact.map{|key| obj[key] }
+                find(obj, @path)
               when :up
                 if obj.respond_to? :parent
                   obj.__mobj__parent || obj.__mobj__parent
@@ -269,7 +289,11 @@ module Mobj
                   obj.__mobj__parent
                 end
               when :any
-                @path.return_first { |token| token.walk(obj, root) }
+                if obj.is_a?(Array)
+                  obj.map { |o| walk(o, root) }
+                else
+                  @path.return_first { |token| token.walk(obj, root) }
+                end
               when :all
                 matches = @path.map { |token| token.walk(obj, root) }
                 matches.compact.size == @path.size ? matches : nil
@@ -277,6 +301,7 @@ module Mobj
                 @path.map { |token| token.walk(obj, root) }
               when :lookup
                 lookup = @path.walk(obj)
+                puts "lookup '#{lookup}':#{obj}:#{@path}"
                 if lookup.is_a?(Array)
                   lookup.flatten.map { |lu| lu.tokenize.walk(root) }.flatten(1)
                 else
@@ -322,7 +347,7 @@ module Mobj
       lookup = /\{\{(?<lookup>.*?)\}\}/
       up = /(?<up>\^)/
       path = /(?<path>[^\.\[]+)/
-      indexes = /(?<indexes>[\d\+\.,-]+)/
+      indexes = /(?<indexes>[\d\+\.,\s-]+)/
 
       matcher = /#{lit}|#{regex}|#{lookup}|#{up}|#{path}(?:\[#{indexes}\])?/
 
@@ -349,7 +374,7 @@ module Mobj
 
           unless ands.size + ors.size + eachs.size > 3
             options = {}
-            index_matcher = /(?<low>\d+)(?:(?:\.\.(?<ex>\.)?|-?)(?<high>-?\d+|\+))?/
+            index_matcher = /\s*(?<low>\d+)\s*(?:(?:\.\s*\.\s*(?<ex>\.)?\s*|-?)\s*(?<high>-?\d+|\+))?\s*/
 
             options[:indexes] = match.indexes.matches(index_matcher).map do |index|
               if index.high?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mobj
 version: !ruby/object:Gem::Version
-  version: 1.6.9
+  version: 1.7.1
   prerelease: 
 platform: ruby
 authors: