gorillib 0.5.0 → 0.5.2

data/lib/gorillib/collection/model_collection.rb

@@ -40,6 +40,7 @@ module Gorillib
         item.receive!(attrs, &block)
         item
       else
+        attrs = attrs.attributes if attrs.is_a? Gorillib::Model
         attrs = attrs.merge(key_method => label) if key_method && label
         receive_item(label, attrs, &block)
       end

data/lib/gorillib/data_munging.rb

@@ -12,4 +12,3 @@ require 'gorillib/model/serialization'
 require 'gorillib/model/serialization/csv'
 require 'gorillib/model/serialization/tsv'
 require 'gorillib/model/serialization/json'
-require 'gorillib/model/indexable'

data/lib/gorillib/hashlike/slice.rb

@@ -16,6 +16,8 @@ module Gorillib
       #   valid_keys = [:mass, :velocity, :time]
       #   search(options.slice(*valid_keys))
       #
+      # Note: Compatible with Rails 4.0 Active Support
+      #
       # @return key/value pairs for keys in self and allowed
       def slice(*allowed)
         allowed.map!{|key| convert_key(key) } if respond_to?(:convert_key, true)

data/lib/gorillib/model/field.rb

@@ -45,8 +45,8 @@ module Gorillib
         @model            = model
         @name             = name.to_sym
         @type             = Gorillib::Factory.factory_for(type, type_opts)
-        default_visabilities = visibilities
-        @visibilities     = default_visabilities.merge( options.extract!(*default_visabilities.keys) )
+        default_visibilities = visibilities
+        @visibilities     = default_visibilities.merge( options.extract!(*default_visibilities.keys).compact )
         @doc              = options.delete(:name){ "#{name} field" }
         receive!(options)
       end

data/lib/gorillib/model/serialization.rb

@@ -1,13 +1,16 @@
+require_relative '../serialization/to_wire'
+
 class Array
   def to_tsv
-    join("\t")
+    to_wire.join("\t")
   end
 end
 
 module Gorillib
   module Model
+
     def to_wire(options={})
-      attributes.merge(:_type => self.class.typename).inject({}) do |acc, (key,attr)|
+      compact_attributes.merge(:_type => self.class.typename).inject({}) do |acc, (key,attr)|
         acc[key] = attr.respond_to?(:to_wire) ? attr.to_wire(options) : attr
         acc
       end
@@ -18,8 +21,10 @@ module Gorillib
       MultiJson.dump(to_wire(options), options)
     end
 
-    def to_tsv
-      attribute_values.map(&:to_s).join("\t")
+    def to_tsv(options={})
+      attributes.map do |key, attr|
+        attr.respond_to?(:to_wire) ? attr.to_wire(options) : attr
+      end.join("\t")
     end
 
     module ClassMethods

data/lib/gorillib/model/serialization/csv.rb

@@ -1,5 +1,6 @@
 require 'csv'
 require 'gorillib/pathname'
+require_relative '../serialization'
 
 module Gorillib
   module Model

data/lib/gorillib/model/serialization/lines.rb

@@ -1,3 +1,5 @@
+require 'gorillib/pathname'
+
 module Gorillib
   module Model
 

data/lib/gorillib/model/serialization/tsv.rb

@@ -1,4 +1,5 @@
 require_relative './lines'
+require_relative '../serialization'
 
 module Gorillib
   module Model

data/lib/gorillib/pathname.rb

@@ -66,7 +66,7 @@ module Gorillib
     #
     def relpath_to(*pathsegs)
       ArgumentError.arity_at_least!(pathsegs, 1)
-      pathsegs = pathsegs.map{|ps| expand_pathseg(ps) }.flatten
+      pathsegs = pathsegs.flatten.map{|ps| expand_pathseg(ps) }.flatten
       self.new(File.join(*pathsegs)).cleanpath(true)
     end
     alias_method :relative_path_to, :relpath_to

data/lib/gorillib/pathname/utils.rb

@@ -14,6 +14,12 @@ class Pathname
     return self
   end
 
+  # Like find, but returns an enumerable
+  #
+  def find_all
+    Enumerator.new{|yielder| find{|path| yielder << path } }
+  end
+
   #
   # Executes the block (passing the opened file) if the file does not
   # exist. Ignores the block otherwise. The block is required.

data/lib/gorillib/string/inflector.rb

@@ -114,7 +114,7 @@ module Gorillib::Inflector
   #
   def constantize(str)
     unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ str
-      raise NameError, "#{self.inspect} is not a valid constant name!"
+      raise NameError, "#{str.inspect} is not a valid constant name!"
     end
 
     Object.module_eval("::#{$1}", __FILE__, __LINE__)

data/lib/gorillib/system.rb

@@ -0,0 +1 @@
+require_relative 'system/runner'

data/lib/gorillib/system/runner.rb

@@ -0,0 +1,36 @@
+#You must include childprocess in your gemfile. 
+#Gorillib (intentionally) does not do so.
+require 'childprocess'
+require 'tempfile'
+
+module Gorillib
+  module System
+    module Runner
+      extend self
+
+      def run(args, options={})
+        options = options.reverse_merge(mirror_io: false)
+        process = ChildProcess.build(*args)
+        out = Tempfile.new('gorillib-runner-out')
+        err = Tempfile.new('gorillib-runner-err')
+        process.io.stdout = out
+        process.io.stderr = err
+        process.start
+        process.wait
+        begin 
+          out.rewind ; err.rewind
+          res = [out.read, err.read, process.exit_code]
+          if options[:mirror_io]
+            $stdout.write res[0]
+            $stderr.write res[1]
+          end
+        ensure
+          out.close ; err.close
+          out.unlink ; err.unlink
+        end
+        res
+      end
+
+    end
+  end
+end

data/lib/gorillib/type/ip_address.rb

@@ -22,8 +22,8 @@ module IpAddresslike
     packed | (ONES >> bitness)
   end
 
-  def hex_str
-    packed.to_s(16)
+  def to_hex
+    "%08x" % packed
   end
 
   def to_s

data/lib/gorillib/version.rb

@@ -0,0 +1,3 @@
+module Gorillib
+  VERSION = '0.5.2'
+end

data/old/lib/gorillib/hash/indifferent_access.rb

@@ -0,0 +1,207 @@
+require 'gorillib/hash/keys'
+
+# This class has dubious semantics and we only have it so that
+# people can write <tt>params[:key]</tt> instead of <tt>params['key']</tt>
+# and they get the same value for both keys.
+
+module Gorillib
+  class HashWithIndifferentAccess < Hash
+    def extractable_options?
+      true
+    end
+
+    def with_indifferent_access
+      dup
+    end
+
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    def default(key = nil)
+      if include?(converted = convert_key(key))
+        self[converted]
+      else
+        super
+      end
+    end
+
+    def self.new_from_hash_copying_default(hash)
+      new(hash).tap do |new_hash|
+        new_hash.default = hash.default
+      end
+    end
+
+    alias_method(:regular_writer, :[]=)    unless method_defined?(:regular_writer)
+    alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:key] = "value"
+    #
+    def []=(key, value)
+      regular_writer(convert_key(key), convert_value(value))
+    end
+
+    alias_method :store, :[]=
+
+    # Updates the instantized hash with values from the second:
+    #
+    #   hash_1 = HashWithIndifferentAccess.new
+    #   hash_1[:key] = "value"
+    #
+    #   hash_2 = HashWithIndifferentAccess.new
+    #   hash_2[:key] = "New Value!"
+    #
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    #
+    def update(other_hash)
+      raise TypeError, "can't convert #{other_hash.nil? ? 'nil' : other_hash.class} into Hash" unless other_hash.respond_to?(:each_pair)
+      if other_hash.is_a? HashWithIndifferentAccess
+        super(other_hash)
+      else
+        other_hash.each_pair{|key, value| regular_writer(convert_key(key), convert_value(value)) }
+        self
+      end
+    end
+
+    alias_method :merge!, :update
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash["key"] = "value"
+    #   hash.key? :key  # => true
+    #   hash.key? "key" # => true
+    #
+    def key?(key)
+      super(convert_key(key))
+    end
+
+    alias_method :include?, :key?
+    alias_method :has_key?, :key?
+    alias_method :member?, :key?
+
+    # Fetches the value for the specified key, same as doing hash[key]
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = HashWithIndifferentAccess.new
+    #   hash[:a] = "x"
+    #   hash[:b] = "y"
+    #   hash.values_at("a", "b") # => ["x", "y"]
+    #
+    def values_at(*indices)
+      indices.collect {|key| self[convert_key(key)]}
+    end
+
+    # Returns an exact copy of the hash.
+    def dup
+      self.class.new(self).tap do |new_hash|
+        new_hash.default = default
+      end
+    end
+
+    # Merges the instantized and the specified hashes together, giving precedence to the values from the second hash
+    # Does not overwrite the existing hash.
+    def merge(hash)
+      self.dup.update(hash)
+    end
+
+    # Performs the opposite of merge, with the keys and values from the first hash taking precedence over the second.
+    # This overloaded definition prevents returning a regular hash, if reverse_merge is called on a <tt>HashWithDifferentAccess</tt>.
+    def reverse_merge(other_hash)
+      super self.class.new_from_hash_copying_default(other_hash)
+    end
+
+    def reverse_merge!(other_hash)
+      replace(reverse_merge( other_hash ))
+    end
+
+    # Removes a specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    def stringify_keys!; self end
+    def stringify_keys; dup end
+    undef_method :symbolize_keys! if method_defined?(:symbolize_keys!)
+    def symbolize_keys; to_hash.symbolize_keys end
+    def to_options!; self end
+
+    # Convert to a Hash with String keys.
+    def to_hash
+      Hash.new(default).merge!(self)
+    end
+
+    def assoc key
+      key = convert_key(key)
+      return unless has_key?(key)
+      [key, self[key]]
+    end
+
+    def rassoc val
+      key = key(val) or return
+      [key, self[key]]
+    end
+
+  protected
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+
+    def convert_value(value)
+      if value.is_a? Hash
+        value.nested_under_indifferent_access
+      elsif value.is_a?(Array)
+        value.dup.replace(value.map{|e| convert_value(e) })
+      else
+        value
+      end
+    end
+  end
+
+end
+
+module Gorillib
+  class HashWithIndifferentSymbolKeys < Gorillib::HashWithIndifferentAccess
+
+    def convert_key key
+      return key if key.is_a?(Fixnum)
+      key.respond_to?(:to_sym) ? key.to_sym : key
+    end
+  end
+end
+
+class Hash
+
+  # Returns an +ActiveSupport::HashWithIndifferentAccess+ out of its receiver:
+  #
+  #   {:a => 1}.with_indifferent_access["a"] # => 1
+  #
+  def with_indifferent_access
+    Gorillib::HashWithIndifferentAccess.new_from_hash_copying_default(self)
+  end
+
+  # Called when object is nested under an object that receives
+  # #with_indifferent_access. This method with be called on the current object
+  # by the enclosing object and is aliased to #with_indifferent_access by
+  # default. Subclasses of Hash may overwrite this method to return +self+ if
+  # converting to an +ActiveSupport::HashWithIndifferentAccess+ would not be
+  # desirable.
+  #
+  #   b = {:b => 1}
+  #   {:a => b}.with_indifferent_access["a"] # calls b.nested_under_indifferent_access
+  #
+  alias nested_under_indifferent_access with_indifferent_access
+end
+

data/old/lib/gorillib/hash/tree_merge.rb

@@ -0,0 +1,4 @@
+require 'gorillib/hashlike/tree_merge'
+class Hash
+  include Gorillib::Hashlike::TreeMerge
+end

data/old/lib/gorillib/hashlike/tree_merge.rb

@@ -0,0 +1,49 @@
+module Gorillib
+  module Hashlike
+    module TreeMerge
+
+      # Recursively merges hashlike objects
+      #
+      # For each key in keys,
+      # * if block_given? and yield(key,self_val,other_val) returns non-nil, set that
+      # * if self is missing value for key, receive the attribute.
+      # * if self's attribute is an Array, append to it.
+      # * if self's value responds to tree_merge!, deep merge it.
+      # * if self's value responds_to merge!, merge! it.
+      # * otherwise, receive the value from other_hash
+      #
+      def tree_merge!(other_hash)
+        return self if other_hash.blank?
+        [self.keys, other_hash.keys].flatten.uniq.each do |key|
+          # get other's val if any
+          if    other_hash.has_key?(key.to_sym) then other_val = other_hash[key.to_sym]
+          elsif other_hash.has_key?(key.to_s)   then other_val = other_hash[key.to_s]
+          else  next ; end
+          # get self val if any
+          self_val  = self[key]
+          # get block resolved result if any
+          if block_given? && yield(key, self_val, other_val)
+            next
+          end
+          # p ['hash tree_merge', key, self_val.respond_to?(:tree_merge!), self_val, '***************', other_val]
+          #
+          case
+          when other_val.nil?                     then next
+          when (not has_key?(key))                then self[key] = other_val
+          when self_val.is_a?(Array)              then self[key] += other_val
+          when self_val.respond_to?(:tree_merge!) then self[key] = self_val.tree_merge!(other_val)
+          when self_val.respond_to?(:merge!)      then self[key] = self_val.merge!(other_val)
+          else                                         self[key] = other_val
+          end
+        end
+        self
+      end
+
+    end
+  end
+end
+
+
+class Hash
+  include Gorillib::Hashlike::TreeMerge
+end