gorillib 0.1.11 → 0.4.0pre

data/lib/gorillib/hash/mash.rb

@@ -0,0 +1,202 @@
+class Hash
+
+  # Convert to Mash. This class has semantics of ActiveSupport's
+  # HashWithIndifferentAccess and we only have it so that people can write
+  # params[:key] instead of params['key'].
+  #
+  # @return [Mash] This hash as a Mash for string or symbol key access.
+  def to_mash
+    hash = Mash.new(self)
+    hash.default = default
+    hash
+  end
+
+  ##
+  # Create a hash with *only* key/value pairs in receiver and +allowed+
+  #
+  #   { :one => 1, :two => 2, :three => 3 }.only(:one)    #=> { :one => 1 }
+  #
+  # @param allowed [Array[String, Symbol]] The hash keys to include.
+  #
+  # @return [Hash] A new hash with only the selected keys.
+  #
+  # @api public
+  def only(*allowed)
+    hash = {}
+    allowed.each {|k| hash[k] = self[k] if self.has_key?(k) }
+    hash
+  end
+
+  ##
+  # Create a hash with all key/value pairs in receiver *except* +rejected+
+  #
+  #    { :one => 1, :two => 2, :three => 3 }.except(:one)
+  #     #=> { :two => 2, :three => 3 }
+  #
+  # @param rejected [Array[String, Symbol]] The hash keys to exclude.
+  #
+  # @return [Hash] A new hash without the selected keys.
+  #
+  # @api public
+  def except(*rejected)
+    hash = self.dup
+    rejected.each {|k| hash.delete(k) }
+    hash
+  end
+end
+
+# This class has dubious semantics and we only have it so that people can write
+# params[:key] instead of params['key'].
+class Mash < Hash
+
+  # @param constructor [Object]
+  #   The default value for the mash. Defaults to an empty hash.
+  #
+  # @overload [Alternatives]
+  #   If constructor is a Hash, a new mash will be created based on the keys of
+  #   the hash and no default value will be set.
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
+  end
+
+  # @param key<Object> The default value for the mash. Defaults to nil.
+  #
+  # @overload [Alternatives]
+  #   If key is a Symbol and it is a key in the mash, then the default value will
+  #   be set to the value matching the key.
+  def default(key = nil)
+    if key.is_a?(Symbol) && include?(key = key.to_s)
+      self[key]
+    else
+      super
+    end
+  end
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+  # @param key<Object> The key to set.
+  # @param value<Object>
+  #   The value to set the key to.
+  #
+  # @see Mash#convert_key
+  # @see Mash#convert_value
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
+  end
+
+  # @param other_hash<Hash>
+  #   A hash to update values in the mash with. The keys and the values will be
+  #   converted to Mash format.
+  #
+  # @return [Mash] The updated mash.
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+
+  alias_method :merge!, :update
+
+  # @param key<Object> The key to check for. This will be run through convert_key.
+  #
+  # @return [Boolean] True if the key exists in the mash.
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  # def include? def has_key? def member?
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  # @param <Object> key The key to fetch. This will be run through convert_key.
+  # @param <Array> extras Default value.
+  #
+  # @return [Object] The value at key or the default value.
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  # @param indices [Array]
+  #   The keys to retrieve values for. These will be run through +convert_key+.
+  #
+  # @return [Array] The values at each of the provided keys
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
+  end
+
+  # @param hash<Hash> The hash to merge with the mash.
+  #
+  # @return [Mash] A new mash with the hash values merged in.
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  # @param key<Object>
+  #   The key to delete from the mash.\
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  # @param [Array[(String, Symbol)]] rejected The mash keys to exclude.
+  #
+  # @return [Mash] A new mash without the selected keys.
+  #
+  # @example
+  #   { :one => 1, :two => 2, :three => 3 }.except(:one)
+  #     #=> { "two" => 2, "three" => 3 }
+  def except(*rejected)
+    super(*rejected.map {|k| convert_key(k)})
+  end
+
+  # Used to provide the same interface as Hash.
+  #
+  # @return [Mash] This mash unchanged.
+  def stringify_keys!; self end
+
+  # @return [Hash] The mash as a Hash with symbolized keys.
+  def symbolize_keys
+    h = Hash.new(default)
+    each { |key, val| h[key.to_sym] = val }
+    h
+  end
+
+  # @return [Hash] The mash as a Hash with string keys.
+  def to_hash
+    Hash.new(default).merge(self)
+  end
+
+  protected
+  # @param key [Object] The key to convert.
+  #
+  # @return [Object]
+  #   The converted key. If the key was a symbol, it will be converted to a
+  #   string.
+  #
+  # @api private
+  def convert_key(key)
+    key.kind_of?(Symbol) ? key.to_s : key
+  end
+
+  # @param value [Object] The value to convert.
+  #
+  # @return [Object]
+  #   The converted value. A Hash or an Array of hashes, will be converted to
+  #   their Mash equivalents.
+  #
+  # @api private
+  def convert_value(value)
+    if value.class == Hash
+      value.to_mash
+    elsif value.is_a?(Array)
+      value.collect { |e| convert_value(e) }
+    else
+      value
+    end
+  end
+end

data/lib/gorillib/hashlike/slice.rb

@@ -1,13 +1,14 @@
 module Gorillib
   module Hashlike
     module Slice
-      # Slice a hash to include only the given allowed_keys. This is useful for
-      # limiting an options hash to valid keys before passing to a method:
+      # Slice a hash to include only the given allowed_keys.
       #
+      # @return the sliced hash
+      #
+      # @example limit an options hash to valid keys before passing to a method:
       #   def search(criteria = {})
       #     assert_valid_keys(:mass, :velocity, :time)
       #   end
-      #
       #   search(options.slice(:mass, :velocity, :time))
       #
       # If you have an array of keys you want to limit to, you should splat them:
@@ -21,8 +22,10 @@ module Gorillib
         hash
       end unless method_defined?(:slice)
 
-      # Replaces the hash with only the given allowed_keys.
-      # Returns a hash containing the removed key/value pairs
+      # Replace the hash with only the given allowed_keys.
+      #
+      # @return a hash containing the removed key/value pairs
+      #
       # @example
       #   hsh = {:a => 1, :b => 2, :c => 3, :d => 4}
       #   hsh.slice!(:a, :b)
@@ -37,21 +40,9 @@ module Gorillib
         omit
       end unless method_defined?(:slice!)
 
-      # This also works, and doesn't require #replace method, but is uglier and
-      # wasn't written by Railsians.  I'm not sure that slice! is interesting if
-      # you're a duck-typed Hash but not is_a?(Hash), so we'll just leave it at the
-      # active_record implementation.
-      #
-      # def slice!(*allowed_keys)
-      #   allowed_keys = allowed_keys.map!{|key| convert_key(key) } if respond_to?(:convert_key)
-      #   omit_keys = self.keys - allowed_keys
-      #   omit = slice(*omit_keys)
-      #   omit_keys.each{|k| delete(k) }
-      #   omit
-      # end
-
       # Removes the given allowed_keys from the hash
-      # Returns a hash containing the removed key/value pairs
+      #
+      # @return a hash containing the removed key/value pairs
       #
       # @example
       #   hsh = {:a => 1, :b => 2, :c => 3, :d => 4}
@@ -62,6 +53,49 @@ module Gorillib
       def extract!(*allowed_keys)
         slice!(*self.keys - allowed_keys)
       end unless method_defined?(:extract!)
+
+      # Return a hash that includes everything but the given keys.
+      #
+      # @example Exclude a blacklist of parameters
+      #   @person.update_attributes(params[:person].except(:admin))
+      #
+      # If the receiver responds to +convert_key+, the method is called on each of the
+      # arguments. This allows +except+ to play nice with hashes with indifferent access
+      # for instance:
+      #
+      # @example mash, hash, it does the right thing:
+      #   {:a => 1}.to_mash.except(:a)  # => {}
+      #   {:a => 1}.to_mash.except('a') # => {}
+      #
+      def except(*keys)
+        dup.except!(*keys)
+      end
+
+      # Replaces the hash without the given keys.
+      def except!(*keys)
+        keys.each{|key| delete(key) }
+        self
+      end
+
+      def only(*allowed)
+        dup.only!(*allowed)
+      end
+
+      # Create a hash with *only* key/value pairs in receiver and +allowed+
+      #
+      # @example Limit a set of parameters to everything but a few known toggles:
+      #   { :one => 1, :two => 2, :three => 3 }.only(:one)    #=> { :one => 1 }
+      #
+      # @param [Array[String, Symbol]] allowed The hash keys to include.
+      #
+      # @return [Hash] A new hash with only the selected keys.
+      #
+      # @api public
+      def only!(*allowed)
+        allowed = allowed.to_set
+        select!{|key, val| allowed.include?(key) }
+      end
+
     end
   end
 end

data/lib/gorillib/hashlike.rb

@@ -199,7 +199,7 @@ module Gorillib
       #     hsh.values_at(:c, :a, :c, :z, :a)
       #     # => [300, 100, 300, nil, 100]
       #
-      # @param  *allowed_keys [Object] the keys to retrieve.
+      # @param  allowed_keys [Object] the keys to retrieve.
       # @return [Array] the values, in order according to allowed_keys.
       #
       def values_at(*allowed_keys)
@@ -304,7 +304,7 @@ module Gorillib
     #     hsh.values_of(:c, :a, :c, :z, :a)
     #     # => [300, 100, 300, nil, 100]
     #
-    # @param  *allowed_keys [Object] the keys to retrieve.
+    # @param  allowed_keys [Object] the keys to retrieve.
     # @return [Array] the values, in order according to allowed_keys.
     #
     def values_of(*allowed_keys)
@@ -794,7 +794,9 @@ module Gorillib
     #     hsh.flatten(nil)
     #     # =>    [1, 2,  3, 4,      1,  2, 3,  4, 5, 6]
     #
-    # @param  level [Integer] the level of recursion to flatten, 0 by default.
+    # @overload flatten
+    # @overload flatten(level)
+    #   @param  level [Integer] the level of recursion to flatten, 0 by default.
     # @return [Array] the flattened key-value array.
     #
     def flatten(*args)

data/lib/gorillib/io/system_helpers.rb

@@ -0,0 +1,30 @@
+module Gorillib::CheckedPopen
+  module_function
+
+  def checked_popen(command, mode, fail_action, io_class=IO)
+    check_child_exit_status do
+      io_class.popen(command, mode) do |process|
+        yield(process)
+      end
+    end
+  rescue Errno::EPIPE
+    fail_action.call
+  end
+
+  # @private
+  NO_EXIT_STATUS = OpenStruct.new(:exitstatus => 0)
+
+  def check_child_exit_status
+    result = yield
+    status = $? || NO_EXIT_STATUS
+    unless [0, 172].include?(status.exitstatus)
+      raise ArgumentError, "Command exited with status '#{status.exitstatus}'"
+    end
+    result
+  end
+
+end
+
+::IO.class_eval do
+  include Gorillib::CheckedPopen
+end

data/lib/gorillib/logger/log.rb

@@ -7,6 +7,24 @@ require 'logger'
 #
 ::Log = Logger.new($stderr) unless defined?(::Log)
 
+# unless defined?(Log)
+#   require 'log4r'
+#   Log = Log4r::Logger.new('wukong')
+#   Log.outputters = Log4r::Outputter.stderr
+#   # require 'logger'
+#   # Log = Logger.new(STDERR)
+# end
+
+# require 'log_buddy'; LogBuddy.init :log_to_stdout => false, :logger => Log
+# LogBuddy::Utils.module_eval do
+#   def arg_and_blk_debug(arg, blk)
+#     result = eval(arg, blk.binding)
+#     result_str = obj_to_string(result, :quote_strings => true)
+#     LogBuddy.debug(%[#{arg} = #{result_str}])
+#   end
+# end
+
+
 def Log.dump *args
   self.debug([
       args.map(&:inspect),

data/lib/gorillib/metaprogramming/concern.rb

@@ -0,0 +1,124 @@
+module Gorillib
+  # A typical module looks like this:
+  #
+  #   module M
+  #     def self.included(base)
+  #       base.extend ClassMethods
+  #       scope :disabled, where(:disabled => true)
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # By using <tt>Gorillib::Concern</tt> the above module could instead be written as:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module M
+  #     extend Gorillib::Concern
+  #
+  #     included do
+  #       scope :disabled, where(:disabled => true)
+  #     end
+  #
+  #     module ClassMethods
+  #       ...
+  #     end
+  #   end
+  #
+  # Moreover, it gracefully handles module dependencies. Given a +Foo+ module and a +Bar+
+  # module which depends on the former, we would typically write the following:
+  #
+  #   module Foo
+  #     def self.included(base)
+  #       base.class_eval do
+  #         def self.method_injected_by_foo
+  #           ...
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Foo # We need to include this dependency for Bar
+  #     include Bar # Bar is the module that Host really needs
+  #   end
+  #
+  # But why should +Host+ care about +Bar+'s dependencies, namely +Foo+? We could try to hide
+  # these from +Host+ directly including +Foo+ in +Bar+:
+  #
+  #   module Bar
+  #     include Foo
+  #     def self.included(base)
+  #       base.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar
+  #   end
+  #
+  # Unfortunately this won't work, since when +Foo+ is included, its <tt>base</tt> is the +Bar+ module,
+  # not the +Host+ class. With <tt>Gorillib::Concern</tt>, module dependencies are properly resolved:
+  #
+  #   require 'active_support/concern'
+  #
+  #   module Foo
+  #     extend Gorillib::Concern
+  #     included do
+  #       class_eval do
+  #         def self.method_injected_by_foo
+  #           ...
+  #         end
+  #       end
+  #     end
+  #   end
+  #
+  #   module Bar
+  #     extend Gorillib::Concern
+  #     include Foo
+  #
+  #     included do
+  #       self.method_injected_by_foo
+  #     end
+  #   end
+  #
+  #   class Host
+  #     include Bar # works, Bar takes care now of its dependencies
+  #   end
+  #
+  module Concern
+    def self.extended(base)
+      base.instance_variable_set("@_dependencies", [])
+    end
+
+    def append_features(base)
+      if base.instance_variable_defined?("@_dependencies")
+        base.instance_variable_get("@_dependencies") << self
+        return false
+      else
+        return false if base < self
+        @_dependencies.each { |dep| base.send(:include, dep) }
+        super
+        base.extend const_get("ClassMethods") if const_defined?("ClassMethods")
+        base.class_eval(&@_included_block) if instance_variable_defined?("@_included_block")
+      end
+    end
+
+    def included(base = nil, &block)
+      if base.nil?
+        @_included_block = block
+      else
+        super
+      end
+    end
+  end
+end

data/lib/gorillib/model/active_model_conversion.rb

@@ -0,0 +1,68 @@
+module Gorillib::Model
+  # == Active Model Conversions
+  #
+  # Handles default conversions: to_model, to_key, to_param, and to_partial_path.
+  #
+  # Let's take for example this non-persisted object.
+  #
+  #   class ContactMessage
+  #     include ActiveModel::Conversion
+  #
+  #     # ContactMessage are never persisted in the DB
+  #     def persisted?
+  #       false
+  #     end
+  #   end
+  #
+  #   cm = ContactMessage.new
+  #   cm.to_model == self # => true
+  #   cm.to_key           # => nil
+  #   cm.to_param         # => nil
+  #   cm.to_path          # => "contact_messages/contact_message"
+  #
+  module Conversion
+    extend Gorillib::Concern
+
+    # If your object is already designed to implement all of the Active Model
+    # you can use the default <tt>:to_model</tt> implementation, which simply
+    # returns self.
+    #
+    # If your model does not act like an Active Model object, then you should
+    # define <tt>:to_model</tt> yourself returning a proxy object that wraps
+    # your object with Active Model compliant methods.
+    def to_model
+      self
+    end
+
+    # Returns an Enumerable of all key attributes if any is set, regardless
+    # if the object is persisted or not.
+    #
+    # Note the default implementation uses persisted? just because all objects
+    # in Ruby 1.8.x responds to <tt>:id</tt>.
+    def to_key
+      persisted? ? [id] : nil
+    end
+
+    # Returns a string representing the object's key suitable for use in URLs,
+    # or nil if <tt>persisted?</tt> is false.
+    def to_param
+      persisted? ? to_key.join('-') : nil
+    end
+
+    # Returns a string identifying the path associated with the object.
+    # ActionPack uses this to find a suitable partial to represent the object.
+    def to_partial_path
+      self.class._to_partial_path
+    end
+
+    module ClassMethods #:nodoc:
+      # Provide a class level cache for the to_path. This is an
+      # internal method and should not be accessed directly.
+      def _to_partial_path #:nodoc:
+        @_to_partial_path ||= begin
+          "#{model_name.collection}/#{model_name.element}".freeze
+        end
+      end
+    end
+  end
+end

data/lib/gorillib/model/active_model_naming.rb

@@ -0,0 +1,87 @@
+module Gorillib::Model
+  class Name < String
+    attr_accessor :namespace
+    attr_reader   :singular, :element, :collection, :partial_path, :param_key, :i18n_key
+
+    alias_method :cache_key, :collection
+
+    class_attribute :inflector
+    self.inflector ||= Gorillib::String::Inflector
+
+    def initialize(klass, namespace = nil, name = nil)
+      name ||= klass.name
+      raise ArgumentError, "Class name cannot be blank. You need to supply a name argument when anonymous class given" if name.blank?
+
+      super(name)
+
+      @klass          = klass
+      @singular       = _singularize(self).freeze
+      @element        = inflector.underscore(inflector.demodulize(self)).freeze
+      @human          = inflector.humanize(@element).freeze
+      @i18n_key       = inflector.underscore(self).to_sym
+      #
+      self.namespace  = namespace
+      self.plural     = inflector.pluralize(@singular)
+    end
+
+    def plural=(str)
+      @plural         = str.dup.freeze
+      @collection     = inflector.underscore(@plural).freeze
+      @partial_path   = "#{@collection}/#{@element}".freeze
+      str
+    end
+
+    def namespace=(ns)
+      if ns.present?
+        @unnamespaced = self.sub(/^#{ns.name}::/, '')
+        @param_key    = _singularize(@unnamespaced).freeze
+      else
+        @unnamespaced = nil
+        @param_key    = @singular.freeze
+      end
+    end
+
+    def singular_route_key
+      inflector.singularize(route_key).freeze
+    end
+
+    def route_key
+      rk = (namespace ? inflector.pluralize(param_key) : plural.dup)
+      rk << "_index" if plural == singular
+      rk.freeze
+    end
+
+  private
+
+    def _singularize(string, replacement='_')
+      inflector.underscore(string).tr('/', replacement)
+    end
+  end
+
+  # == Active Model Naming
+  #
+  # Creates a +model_name+ method on your object.
+  #
+  # To implement, just extend ActiveModel::Naming in your object:
+  #
+  #   class BookCover
+  #     extend ActiveModel::Naming
+  #   end
+  #
+  #   BookCover.model_name        # => "BookCover"
+  #   BookCover.model_name.human  # => "Book cover"
+  #
+  #   BookCover.model_name.i18n_key              # => :book_cover
+  #   BookModule::BookCover.model_name.i18n_key  # => :"book_module/book_cover"
+  #
+  # Providing the functionality that ActiveModel::Naming provides in your object
+  # is required to pass the Active Model Lint test. So either extending the provided
+  # method below, or rolling your own is required.
+  module Naming
+    # Returns a Name object for module, which can be used to retrieve all kinds
+    # of naming-related information.
+    def model_name
+      @_model_name ||= Gorillib::Model::Name.new(self, namespace)
+    end
+  end
+end

data/lib/gorillib/model/active_model_shim.rb

@@ -0,0 +1,33 @@
+require "active_model"
+
+module Gorillib
+  module Model
+
+    # Provides the minimum functionality to pass the ActiveModel lint tests
+    #
+    # @example Usage
+    #   class Person
+    #     include Gorillib::Model::ActiveModelShim
+    #   end
+    #
+    module ActiveModelShim
+      extend  Gorillib::Concern
+      extend  ActiveModel::Naming
+      include Gorillib::Model::Conversion
+      include ActiveModel::Validations
+
+      # @return [false]
+      def persisted?
+        false
+      end
+
+      def attribute_method?(attr_name)
+        self.class.has_field?(attr_name)
+      end
+
+      module ClassMethods
+      end # ActiveModelShim::ClassMethods
+    end # ActiveModelShim
+
+  end
+end