epitools 0.5.66 → 0.5.67

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b21feb448e04c5e66454eb31818b0b78e9d7e36e
-  data.tar.gz: baa845fabc8a02be3239af3b21f8e1149796ccd3
+  metadata.gz: f2271ae81c6b0b63bc52231e263ed3eaf4d556cf
+  data.tar.gz: d94254c24fe5d6bedb163adbfedea3870f249b05
 SHA512:
-  metadata.gz: 2f3805e7813acd3582fd6db84925969711e3cda216adfb7f219e6ee2d89ab3a5574a12bb160c60fa2df4f4429d9b87ca6686b1f88baf54113a8caa5591557b95
-  data.tar.gz: c713ea6609db9fe3a257af5b01ea9fddb13f45d5e9ba2bd9f7bc48a3d955b6b141669e4eb23c1f48366216863a34c30dd1dc714b1f7d5c3660d074b2cab8f084
+  metadata.gz: 45d4cdf94d0425dd4e05a6906872ecb01470bff766c59608e5faa8d8cc4d2fb9fb4716b88278e073f51544502f7966b530867faedd481098f654c10a5a7fb7ad
+  data.tar.gz: f02a980973a1c1543101e1ef2ae3dbe4618aa61f590bf875c7285388fe3485e50bc720d3895590846c3045fd24541ec062dd9914a1dba20cf5cbc52cc3a480fa

data/VERSION

@@ -1 +1 @@
-0.5.66
+0.5.67

data/lib/epitools/core_ext/enumerable.rb

@@ -17,7 +17,6 @@ module Enumerable
   #
   alias_method :includes?,  :include?
 
-
   #
   # Skip the first n elements and return an Enumerator for the rest, or pass them
   # in succession to the block, if given. This is like "drop", but returns an enumerator
@@ -158,12 +157,13 @@ module Enumerable
 
   #
   # The same as "map", except that if an element is an Array or Enumerable, map is called
-  # recursively on that element.
+  # recursively on that element. (Hashes are ignored because of the complications of block
+  # arguments and return values.)
   #
   # Example:
   #   [ [1,2], [3,4] ].deep_map{|e| e ** 2 } #=> [ [1,4], [9,16] ]
   #
-  def deep_map(max_depth=nil, current_depth=0, parent=nil, &block)
+  def map_recursively(max_depth=nil, current_depth=0, parent=nil, &block)
     return self if max_depth and (current_depth > max_depth)
 
     map do |obj|
@@ -171,10 +171,10 @@ module Enumerable
         yield obj
       else
         case obj
-        when String
+        when String, Hash
           yield obj
         when Enumerable
-          obj.deep_map(max_depth, current_depth+1, self, &block)
+          obj.map_recursively(max_depth, current_depth+1, self, &block)
         else
           yield obj
         end
@@ -182,69 +182,39 @@ module Enumerable
     end
   end
 
-  alias_method :recursive_map,    :deep_map
-  alias_method :map_recursively,  :deep_map
-  alias_method :map_recursive,    :deep_map
+  alias_method :deep_map,      :map_recursively
+  alias_method :recursive_map, :map_recursively
+  alias_method :map_recursive, :map_recursively
 
   #
   # The same as "select", except that if an element is an Array or Enumerable, select is called
   # recursively on that element.
   #
   # Example:
-  #   [ [1,2], [3,4] ].deep_select{|e| e % 2 == 0 } #=> [ [2], [4] ]
+  #   [ [1,2], [3,4] ].select_recursively{|e| e % 2 == 0 } #=> [ [2], [4] ]
   #
-  def deep_select(max_depth=nil, current_depth=0, parent=nil, &block)
+  def select_recursively(max_depth=nil, current_depth=0, parent=nil, &block)
     return self if max_depth and (current_depth > max_depth)
 
     map do |obj|
-      p [:obj, obj]
-      result = if obj == parent # infinite loop scenario!
-        p :infinite
+      if obj == parent # infinite loop scenario!
         obj if yield obj
       else
         case obj
-        when String
-          p :string
+        when String, Hash
           obj if yield obj
         when Enumerable
-          p :recurse
           obj.deep_select(max_depth, current_depth+1, self, &block)
         else
-          p :else
-          p [:yield, yield(obj)]
           obj if yield obj
         end
       end
-      p [:result, result]
-      result
     end.compact
   end
 
-  # def deep_select(depth=nil, &block)
-  #   map do |*args|
-
-  #     obj = args.last
-
-  #     if depth.nil? or depth > 0
-
-  #       case obj
-  #       when Hash
-
-  #       when Array, Enumerable
-  #         result = obj.deep_select(depth ? depth-1 : nil, &block)
-  #         result.any? ? result : nil
-  #       end
-
-  #     else
-  #       obj if block.call(obj)
-  #     end
-
-  #   end.compact
-  # end
-
-  alias_method :recursive_select,   :deep_select
-  alias_method :select_recursively, :deep_select
-  alias_method :select_recursive,   :deep_select
+  alias_method :deep_select,        :select_recursively
+  alias_method :recursive_select,   :select_recursively
+  alias_method :select_recursive,   :select_recursively
 
   #
   # Identical to "reduce" in ruby1.9 (or foldl in haskell.)
@@ -349,7 +319,6 @@ module Enumerable
   end
   alias_method :group_neighbors_by, :group_neighbours_by
 
-
   #
   # Convert the array into a stable iterator (Iter) object.
   #
@@ -376,7 +345,6 @@ module Enumerable
   alias_method :count_by,     :counts
   alias_method :group_counts, :counts
 
-
   #
   # group_by the elements themselves
   #
@@ -385,7 +353,6 @@ module Enumerable
   end
   alias_method :grouped, :groups
 
-
   #
   # Multiplies this Enumerable by something. (Same behaviour as Enumerator#*)
   #

data/lib/epitools/path.rb

@@ -907,8 +907,8 @@ class Path
         else
           #{command} path   # Make the directory
           reload!
-          self
         end
+        self
       end
     }
   end

data/lib/epitools/typed_struct.rb

@@ -50,9 +50,9 @@ class TypedStruct < Struct
     ["timestamp", "unixtime"]    => proc { |me| Time.at me },
     ["bool", "boolean"]          => proc do |me| 
       case me
-      when false, nil, 0, "0", "off", "no",  "false", "disabled", "disable"
+      when false, nil, 0, /^(0|off|no|false|disabled?)$/
         false
-      when true,  1, "1", "on",  "yes", "true", "enabled", "enable"
+      when true,  1, /^(1|on|yes|true|enabled?)$/
         true
       else
         raise "Invalid boolean type: #{me.inspect}"
@@ -64,18 +64,30 @@ class TypedStruct < Struct
   # Initialize a new struct.
   #
   def self.[](specs)
+    wildcard = false
+    drop_unknown = false
+
     # create [name,type] pairs
     pairs = specs.split.map do |spec|
-      name, type = spec.split(":")
+      case spec
+      when "*"
+        wildcard = true
+        next
+      when "-"
+        drop_unknown = true
+        next
+      end
 
-      type ||= :passthru
+      names, type = spec.split(":")
 
-      unless converter = CONVERTERS[type]
-        raise "Unknown type: #{type}"
+      names.split(",").map do |name|
+        type ||= :passthru
+        raise "Unknown type: #{type}" unless converter = CONVERTERS[type]
+        [name.to_sym, converter]
       end
+    end.compact.flatten(1)
 
-      [name.to_sym, converter]
-    end
+    raise "Error: Can't specify both wildcard ('*') and drop unknown ('-')" if wildcard and drop_unknown
 
     # initialize the Struct
     struct = new(*pairs.transpose.first)
@@ -88,6 +100,23 @@ class TypedStruct < Struct
       end
     end
 
+    if wildcard
+      struct.class_eval do
+        def method_missing(name, val=nil)
+          if name =~ /^(.+)=$/
+            @extra_slots ||= {}
+            @extra_slots[$1.to_sym] = val
+          else
+            @extra_slots && @extra_slots[name]
+          end
+        end
+      end
+    end
+
+    struct.class_eval do
+      @@drop_unknown = drop_unknown
+    end
+
     struct
   end
 
@@ -95,10 +124,18 @@ class TypedStruct < Struct
     if args.size == 1 and args.first.is_a? Hash
       opts = args.first
     else
-      opts = Hash[members.zip(args)]
+      opts = members.zip(args)
     end
 
-    opts.each { |key,value| send "#{key}=", value }
+    if @@drop_unknown
+      opts.each { |key,value| send "#{key}=", value if respond_to? "#{key}=" }
+    else
+      opts.each { |key,value| send "#{key}=", value }
+    end
   end
 
 end
+
+def TypedStruct(schema)
+  TypedStruct[schema]
+end

data/spec/core_ext_spec.rb

@@ -453,20 +453,14 @@ describe Enumerable do
   it "maps deeply" do
     [["a\n", "b\n"], ["c\n", "d\n"]].map_recursively(&:strip).should == [ %w[a b], %w[c d] ]
     
-    [[1,2],[3,4]].deep_map {|e| e ** 2}.should == [[1,4],[9,16]] 
-    [1,2,3,4].deep_map {|e| e ** 2}.should == [1,4,9,16] 
-    [[],[],1,2,3,4].deep_map {|e| e ** 2}.should == [[], [], 1, 4, 9, 16] 
-
-    {1=>2, 3=>{4=>5, 6=>7}}.deep_map {|k,v| [k, v**2] }.should == [ [1,4], [3, [[4,25], [6,49]]] ]
+    [[1,2],[3,4]].map_recursively {|e| e ** 2}.should == [[1,4],[9,16]] 
+    [1,2,3,4].map_recursively {|e| e ** 2}.should == [1,4,9,16] 
+    [[],[],1,2,3,4].map_recursively {|e| e ** 2}.should == [[], [], 1, 4, 9, 16] 
   end
   
   it "selects deeply" do
-    [[1,2],[3,4]].deep_select {|e| e % 2 == 0 }.should == [[2],[4]]
-    puts
-
-    {1=>2, 3=>{4=>5, 6=>7}}.deep_select {|k,v| k == 1 }.should == {1=>2} 
-    #[1,2,3,4].deep_select {|e| e ** 2}.should == [1,4,9,16] 
-    #[[],[],1,2,3,4].deep_select {|e| e ** 2}.should == [[], [], 1, 4, 9, 16] 
+    [[1,2],[3,4]].select_recursively {|e| e % 2 == 0 }.should == [[2],[4]]
+    [{},"Blah",1,2,3,4].select_recursively {|e| e == 2 }.should == [2] 
   end
   
   it "splits" do
@@ -605,6 +599,16 @@ describe Hash do
   before :each do
     @h = {"key1"=>"val1", "key2"=>"val2"}
   end
+
+  it "maps recursively" do
+    # nevermind. hashes are stupid.
+    # {a: 2, b: {c: 5, d: 7}}.map_recursively {|k,v| [k, v**2] }.should == {a: 4, b: {c: 25, d: 49}}
+  end
+
+  it "selects recursively" do
+    # nevermind. hashes are stupid.
+    # {1=>2, 3=>{4=>5, 6=>7}}.select_recursively {|k,v| k == 1 }.should == {1=>2} 
+  end
     
   it "maps keys" do
     h = @h.map_keys{|k| k.upcase}

data/spec/path_spec.rb

@@ -310,6 +310,13 @@ describe Path do
     tmp.rm
     tmp.mkdir.should be_truthy
     tmp.rm.should be_truthy
+
+    tmp2 = Path.tmpfile
+    tmp2.rm
+    tmp2 = tmp2/"nonexistent"/"directory"
+
+    tmp2.exists?.should == false
+    lambda { tmp2.mkdir_p }.should_not raise_error
   end
 
   it "has classmethods" do

data/spec/typed_struct_spec.rb

@@ -11,6 +11,41 @@ describe TypedStruct do
     t.c = "yes"; t.c.should == true
     #t.c?.should == true
   end    
+
+  it "compact syntaxes" do
+    t = TypedStruct["a,b:int c,d:bool"].new(1,2,1,0)
+    t.a.should == 1
+    t.b.should == 2
+    t.c.should == true
+    t.d.should == false
+  end
+
+  it "wildcardses" do
+    t = TypedStruct["a:int *"].new
+
+                 t.a.should == nil
+    t.a = "111"; t.a.should == 111
+
+                 t.q.should == nil
+    t.q = "111"; t.q.should == "111"
+  end
+
+  it "drops unknowns" do
+
+    ts = TypedStruct["a:int"]
+    lambda { ts.new a: 1, b: 2 }.should raise_error
+
+    ts = TypedStruct["a:int -"]
+    lambda { 
+      t = ts.new a: 1, b: 2 
+      t.a.should == 1
+      lambda { t.b }.should raise_error
+    }.should_not raise_error
+  end
+
+  it "can't use wildcard and drop unknown at once" do
+    lambda { TypedStruct["a:int - *"].new }.should raise_error
+  end
   
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: epitools
 version: !ruby/object:Gem::Version
-  version: 0.5.66
+  version: 0.5.67
 platform: ruby
 authors:
 - epitron
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-05 00:00:00.000000000 Z
+date: 2015-01-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec