mobj 1.0.0

data/README.md

@@ -0,0 +1,71 @@
+ctx
+===
+
+Simple utility to limit method redefinition within the bounds of arbitrary logical scopes
+
+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.
+
+---
+
+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.
+

data/lib/mobj.rb

@@ -0,0 +1,181 @@
+module Mobj
+
+  class ::BasicObject
+    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
+  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 defined_methods() (class_methods | object_methods).sort end
+  end
+
+  class ::Array
+    def sequester(lim = 1) compact.size <= lim ? compact.first : self end
+    def return_first(&block)
+      returned = nil
+      each { |item| break if (returned = block.call(item)) }
+      returned
+    end
+  end
+
+  class Moken
+    def initialize(type, *args)
+      @type, @path, @options = type.to_sym, nil, {}
+      tokens = []
+      args.each do |arg|
+        if arg.is_a? Hash
+          @options.merge!(arg)
+        elsif arg.is_a? String
+          tokens << arg.sym
+        else
+          tokens << arg
+        end
+      end
+      @path = tokens.sequester
+    end
+
+    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
+      else
+        if path.is_a?(Array)
+          path.map { |pth| obj[pth.sym] }
+        else
+          obj[path.sym]
+        end
+      end
+    end
+
+    def walk(obj, root = obj)
+      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]}
+              when :any
+                @path.return_first { |token| token.walk(obj, root) }
+              when :all
+                matches = @path.map { |token| token.walk(obj, root) }
+                matches.compact.size == @path.size ? matches : nil
+              when :each
+                @path.map { |token| token.walk(obj, root) }
+              when :lookup
+                lookup = @path.walk(obj)
+                if lookup.is_a?(Array)
+                  lookup.flatten.map { |lu| lu.tokenize.walk(root) }.flatten(1)
+                else
+                  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."
+              when :root
+                tree = [@path].flatten
+                while (path = tree.shift)
+                  obj = path.walk(obj)
+                end
+                obj.is_a?(Array) ? obj.flatten : obj
+            end
+
+      @options[:indexes] ? val.values_at(*@options[:indexes])  : val
+    end
+  end
+
+  class ::String
+    def ~@() "~#{self}" end
+
+    def tokenize
+      tokens = []
+      scan(/\~([^\.]+)|\/(.*?)\/|\{\{(.*?)\}\}|([^\.\[]+)(?:\[([\d\+\.,-]+)\])?/).each do |literal, regex, lookup, path, indexes|
+        if literal
+          tokens << Moken.new(:literal, literal)
+        elsif lookup
+          tokens << Moken.new(:lookup, lookup.tokenize)
+        elsif regex
+          tokens << Moken.new(:regex, Regexp.new(regex))
+        elsif path
+          eachs = path.split(",")
+          ors = path.split("|")
+          ands = path.split("&")
+          if eachs.size > 1
+            tokens << Moken.new(:each, eachs.map { |token| token.tokenize() })
+          elsif ands.size > 1
+            tokens << Moken.new(:all, ands.map { |token| token.tokenize() })
+          elsif ors.size > 1
+            tokens << Moken.new(:any, ors.map { |token| token.tokenize() })
+          end
+
+          unless ands.size + ors.size + eachs.size > 3
+            options = {}
+            options[:indexes] = indexes.scan(/(\d+)(?:(?:\.\.(\.)?|-?)(-?\d+|\+))?/).map do |start, exc, len|
+              len.nil? ? start.to_i : (Range.new(start.to_i, (len == "+" ? -1 : len.to_i), !exc.nil?))
+            end if indexes
+
+            if path[0] == '!'
+              tokens << Moken.new(:inverse, Moken.new(:path, path[1..-1].sym, options))
+            else
+              tokens << Moken.new(:path, path.sym, options)
+            end
+          end
+        end
+      end
+      tokens.size == 1 ? tokens.first : Moken.new(:root, tokens)
+    end
+  end
+
+  class Circle < Hash
+
+    def initialize
+      super
+      @index = 0
+    end
+
+    def <<(val)
+      self[@index] = val
+      @index += 1
+    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
+    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
+
+    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
+      end
+      circle
+    end
+  end
+
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: mobj
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Mason
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: rr
+  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'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  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: Utils and extentions for various ruby objects
+email: mobj@chipped.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mobj.rb
+- README.md
+homepage: https://github.com/gnovos/mobj
+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.24
+signing_key: 
+specification_version: 3
+summary: Helpful utils and extentions
+test_files: []