strokedb 0.0.2 → 0.0.2.1

data/lib/init.rb

@@ -1,5 +1,5 @@
 module StrokeDB
-  VERSION = '0.0.2' + (RUBY_PLATFORM =~ /java/ ? '-java' : '')
+  VERSION = '0.0.2.1' + (RUBY_PLATFORM =~ /java/ ? '-java' : '')
 
   # UUID regexp (like 1e3d02cc-0769-4bd8-9113-e033b246b013)
   UUID_RE = /([a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12})/

data/lib/util/lazy_mapping_array.rb

@@ -20,7 +20,7 @@ module StrokeDB
   #
   # when model collection item is fetched, reference followed and turned into document
   # instance with mapping proc of lazy mapping array.
-  class LazyMappingArray < BlankSlate(Array)
+  class LazyMappingArray < Array
     def initialize(*args)
       @map_proc = proc {|v| v}
       @unmap_proc = proc {|v| v}
@@ -37,28 +37,107 @@ module StrokeDB
       self
     end
 
-    def class
-      Array
+    alias :_square_brackets :[]
+    def [](*args)
+      r = _square_brackets(*args)
+      if (args.first.is_a?(Range) || args.size == 2) && r.is_a?(Array)
+        LazyMappingArray.new(r).map_with(&@map_proc).unmap_with(&@unmap_proc)
+      else
+        @map_proc.call(r)
+      end
     end
+    alias :slice :[]
 
-    def method_missing sym, *args, &blk
-      super if sym.to_s =~ /^__/
-      mname = "__#{::BlankSlate::MethodMapping[sym.to_s] || sym}"
+    alias :_square_brackets_set :[]=
+    def []=(*args)
+      value = args.pop
+      if (args.first.is_a?(Range) || args.size == 2) && value.is_a?(Array)
+        args << value.map{|e| @unmap_proc.call(e) }
+        _square_brackets_set(*args)
+      else
+        _square_brackets_set(args[0], @unmap_proc.call(value))
+      end
+    end
 
-      case sym
-      when :push, :unshift, :<<, :[]=, :index, :-
-        last = args.pop
-        last = last.is_a?(Array) ? last.map{|v| @unmap_proc.call(v) } : @unmap_proc.call(last)
-        args.push last
+    alias :_at :at
+    def at(index)
+      @map_proc.call(_at(index))
+    end
 
-        __send__(mname, *args, &blk)
+    def first
+      at(0)
+    end
 
-      when :[], :slice, :at, :map, :shift, :pop, :include?, :last, :first, :zip, :each, :inject, :each_with_index
-        __map{|v| @map_proc.call(v) }.__send__(sym, *args, &blk)
+    def last
+      at(size-1)
+    end
 
-      else
-        __send__(mname, *args, &blk)
+    alias :_each :each
+    def each
+      _each do |val|
+        yield @map_proc.call(val)
       end
     end
+
+    alias :_map :map
+    def map
+      _map do |val|
+        yield @map_proc.call(val)
+      end
+    end
+
+    alias :_zip :zip
+    def zip(*args)
+      map{|v|v}.zip(*args)
+    end
+
+    alias :_push :push
+    def push(value)
+      _push(@unmap_proc.call(value))
+    end
+    alias :<< :push
+
+    alias :_unshift :unshift
+    def unshift(value)
+      _unshift(@unmap_proc.call(value))
+    end
+
+    alias :_pop :pop
+    def pop
+      @map_proc.call(_pop)
+    end
+
+    alias :_shift :shift
+    def shift
+      @map_proc.call(_shift)
+    end
+
+    alias :_find :find
+    def find
+      _find {|value| yield(@map_proc.call(value))}
+    end
+
+    alias :_index :index
+    def index(v)
+      _index(@unmap_proc.call(v))
+    end
+
+    alias :_substract :-
+    def -(a)
+      _substract(a.map {|v| @unmap_proc.call(v) })
+    end
+
+    alias :_include? :include?
+    def include?(v)
+      _include?(@unmap_proc.call(v))
+    end
+
+    def to_a
+       Array.new(map{|v| v})
+    end
+
+    def class
+      Array
+    end
   end
 end

data/lib/util/lazy_mapping_hash.rb

@@ -1,12 +1,12 @@
 module StrokeDB
-  class LazyMappingHash < BlankSlate(Hash)
+  class LazyMappingHash < Hash
     def initialize(original = {}, decoder = nil, encoder = nil)
       @decoder = decoder || proc {|v| v}
       @encoder = encoder || proc {|v| v}
       super(default)
-      original.each {|k,v| self.__squarebracket_set(k,v) }
+      original.each {|k,v| self[k] = v } 
     end
-    
+
     def map_with(&block)
       @encoder = block
       self
@@ -17,30 +17,36 @@ module StrokeDB
       self
     end
 
-    def class
-      Hash
+    alias :_square_brackets :[]
+    def [](k)
+      @encoder.call(_square_brackets(@decoder.call(k)))
     end
 
-    def method_missing sym, *args, &blk
-      super if sym.to_s =~ /^__/
-      mname = "__#{::BlankSlate::MethodMapping[sym.to_s] || sym}"
+    alias :_square_brackets_set :[]=
+    def []=(k,v)
+      _square_brackets_set(@decoder.call(k),@decoder.call(v))
+    end
 
-      case sym
-      when :keys, :values
-        __send__(mname, *args, &blk).map{|v| @encoder.call(v) }
+    alias :_each :each
+    def each
+      e = @encoder
+      _each do |k, v|
+        yield(e.call(k), e.call(v))
+      end
+    end
 
-      when :each
-        self.__each do |k,v|
-          yield @encoder.call(k), @encoder.call(v)
-        end
+    alias :_keys :keys
+    def keys
+      _keys.map {|k| @encoder.call(k)}
+    end
 
-      when :[], :[]=
-        args.map!{|v| @decoder.call(v) }
-        @encoder.call __send__(mname, *args, &blk)
+    alias :_values :values
+    def values
+      _values.map {|v| @encoder.call(v)}
+    end
 
-      else
-        __send__(mname, *args, &blk)
-      end
+    def class
+      Hash
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: strokedb
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.0.2.1
 platform: ruby
 authors: 
 - Yurii Rashkovskii, Oleg Andreev
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-04-13 00:00:00 +03:00
+date: 2008-04-15 00:00:00 +03:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency