benhoskings-hammock 0.2.4

data/lib/hammock/monkey_patches/logger.rb

@@ -0,0 +1,28 @@
+module Hammock
+  module BufferedLoggerPatches
+    MixInto = ActiveSupport::BufferedLogger
+
+    def self.included base
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+
+      # base.class_eval {
+      #   alias_method_chain :fatal, :color
+      # }
+    end
+
+    module ClassMethods
+
+    end
+
+    module InstanceMethods
+
+      def fatal_with_color message = nil, progname = nil, &block
+        first_line, other_lines = message.strip.split("\n", 2)
+        fatal_without_color "\n" + first_line.colorize('on red'), progname, &block
+        fatal_without_color other_lines.colorize('red') + "\n\n", progname, &block
+      end
+
+    end
+  end
+end

data/lib/hammock/monkey_patches/module.rb

@@ -0,0 +1,27 @@
+module Hammock
+  module ModulePatches
+    MixInto = Module
+    LoadFirst = true
+
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+
+      def alias_method_chain_once target, feature
+        aliased_target, punctuation = target.to_s.sub(/([?!=])$/, ''), $1
+        without_method = "#{aliased_target}_without_#{feature}#{punctuation}"
+
+        unless [public_instance_methods, protected_instance_methods, private_instance_methods].flatten.include? without_method
+          alias_method_chain target, feature
+        end
+      end
+
+    end
+  end
+end

data/lib/hammock/monkey_patches/numeric.rb

@@ -0,0 +1,25 @@
+module Hammock
+  module NumericPatches
+    MixInto = Numeric
+
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods # TODO maybe include in the metaclass instead of extending the class?
+
+      base.class_eval {
+        alias kb kilobytes
+        alias mb megabytes
+        alias gb gigabytes
+        alias tb terabytes
+      }
+    end
+
+    module ClassMethods
+
+    end
+
+    module InstanceMethods
+
+    end
+  end
+end

data/lib/hammock/monkey_patches/object.rb

@@ -0,0 +1,61 @@
+module Hammock
+  module ObjectPatches
+    MixInto = Object
+
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+
+      base.class_eval {
+        alias is_an? is_a?
+      }
+    end
+
+    module ClassMethods
+    end
+
+    module InstanceMethods
+
+      # Return +self+ after yielding to the given block.
+      #
+      # Useful for inline logging and diagnostics. Consider the following:
+      #     @items.map {|i| process(i) }.join(", ")
+      # With +tap+, adding intermediate logging is simple:
+      #     @items.map {|i| process(i) }.tap {|obj| log obj.inspect }.join(", ")
+      #--
+      # TODO Remove for Ruby 1.9
+      def tap
+        yield self
+        self
+      end
+      
+      # The reverse of <tt>Enumerable#include?</tt> - returns +true+ if +self+ is
+      # equal to one of the elements of +args+.
+      def in? *args
+        args.include? self
+      end
+
+      # A symbolized, underscored (i.e. reverse-camelized) representation of +self+.
+      #
+      # Examples:
+      #
+      #     Hash.symbolize                     #=> :hash
+      #     ActiveRecord::Base.symbolize       #=> :"active_record/base"
+      #     "GetThisCamelOffMyCase".symbolize  #=> :get_this_camel_off_my_case
+      def symbolize
+        self.to_s.underscore.to_sym
+      end
+
+      # If +condition+ evaluates to true, return the result of sending +method_name+ to +self+; <tt>*args</tt> to +self+, otherwise, return +self+ as-is.
+      def send_if condition, method_name, *args
+        condition ? send(method_name, *args) : self
+      end
+
+      # If +condition+ evaluates to true, return the result of sending +method_name+ to +self+; <tt>*args</tt> to +self+, otherwise, return +self+ as-is.
+      def send_if_respond_to method_name, *args
+        send_if respond_to?(method_name), method_name, *args
+      end
+
+    end
+  end
+end

data/lib/hammock/monkey_patches/route_set.rb

@@ -0,0 +1,200 @@
+module Hammock
+  module RouteSetPatches
+    MixInto = ActionController::Routing::RouteSet
+
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+
+      base.class_eval {
+        attr_accessor :route_map
+      }
+    end
+
+    module ClassMethods
+
+    end
+
+    module InstanceMethods
+
+      private
+
+      def initialize_hammock_route_map
+        self.route_map = HammockResource.new
+      end
+
+      class HammockResource < ActionController::Resources::Resource
+        class HammockRoutePiece
+          attr_reader :resource, :routeable_as, :verb, :entity, :parent
+
+          def initialize resource
+            @resource = resource
+          end
+
+          def for verb, entity
+            routeable_as = resource.routeable_as(verb, entity)
+
+            if !routeable_as
+              raise "The verb '#{verb}' can't be applied to " + (entity.record? ? "#{entity.resource} records" : "the #{entity.resource} resource") + "."
+            elsif (:record == routeable_as) && entity.new_record?
+              raise "The verb '#{verb}' requires a #{entity.resource} with an ID (i.e. not a new record)."
+            elsif (:build == routeable_as) && entity.record? && !entity.new_record?
+              raise "The verb '#{verb}' requires either the #{entity.resource} resource, or a #{entity.resource} without an ID (i.e. a new record)."
+            else
+              @verb, @entity, @routeable_as = verb, entity, routeable_as
+            end
+
+            self
+          end
+
+          def within parent
+            @parent = parent
+            self
+          end
+          
+          def setup?
+            !@entity.nil?
+          end
+          
+          def path params = nil
+            raise_unless_setup_while_trying_to 'render a path'
+
+            buf = '/'
+            buf << entity.resource_name
+            buf << '/' + entity.to_param if entity.record? && !entity.new_record?
+            buf << '/' + verb.to_s unless verb.nil? or implied_verb?(verb)
+
+            buf = parent.path + buf unless parent.nil?
+            buf << param_str(params)
+
+            buf
+          end
+          
+          def http_method
+            raise_unless_setup_while_trying_to 'extract the HTTP method'
+            resource.send("#{routeable_as}_routes")[verb]
+          end
+          
+          def fake_http_method
+            http_method.in?(:get, :post) ? http_method : :post
+          end
+
+          def get?;       :get == http_method end
+          def post?;     :post == http_method end
+          def put?;       :put == http_method end
+          def delete?; :delete == http_method end
+
+          def safe?
+            get? && !verb.in?(Hammock::Constants::ImpliedUnsafeActions)
+          end
+
+          private
+          
+          def implied_verb? verb
+            verb.in? :index, :create, :show, :update, :destroy
+          end
+          
+          def raise_unless_setup_while_trying_to task
+            raise "You have to call for(verb, entity) (and optionally within(parent)) on this HammockRoutePiece before you can #{task}." unless setup?
+          end
+          
+          def param_str params
+            link_params = entity.record? ? entity.unsaved_attributes.merge(params || {}) : params
+
+            if link_params.blank?
+              ''
+            else
+              '?' + {entity.base_model => link_params}.to_query
+            end
+          end
+
+        end
+        
+        DefaultRecordVerbs = {
+          :show => :get,
+          :edit => :get,
+          :update => :put,
+          :destroy => :delete
+        }.freeze
+        DefaultResourceVerbs = {
+          :index => :get
+        }.freeze
+        DefaultBuildVerbs = {
+          :new => :get,
+          :create => :post
+        }.freeze
+
+        attr_reader :mdl, :parent, :children, :record_routes, :resource_routes, :build_routes
+
+        def initialize entity = nil, options = {}
+          @mdl = entity if entity.is_a?(Symbol)
+          @parent = options[:parent]
+          @children = {}
+          define_routes options
+        end
+
+        def ancestry
+          parent.nil? ? [] : parent.ancestry.push(self)
+        end
+
+        def for verb, entities, options
+          raise "HammockResource#for requires an explicitly specified verb as its first argument." unless verb.is_a?(Symbol)
+          raise "You have to supply at least one record or resource." if entities.empty?
+
+          entity = entities.shift
+
+          if entities.empty?
+            piece_for verb, entity
+          else
+            children[entity.resource_sym].for(verb, entities, options).within piece_for(nil, entity)
+          end
+        end
+
+        def add entity, options, steps = nil
+          if steps.nil?
+            add entity, options, (options[:name_prefix] || '').chomp('_').split('_').map {|i| i.pluralize.underscore.to_sym }
+          elsif steps.empty?
+            add_child entity, options
+          else
+            children[steps.shift].add entity, options, steps
+          end
+        end
+
+        def routeable_as verb, entity
+          if entity.record? && record_routes[verb || :show]
+            :record
+          elsif entity.resource? && resource_routes[verb || :index]
+            :resource
+          elsif !verb.nil? && build_routes[verb]
+            :build
+          end
+        end
+
+        private
+
+        def define_routes options
+          @record_routes = DefaultRecordVerbs.dup.update(options[:member] || {})
+          @resource_routes = DefaultResourceVerbs.dup.update(options[:collection] || {})
+          @build_routes = DefaultBuildVerbs.dup.update(options[:build] || {})
+        end
+
+        def add_child entity, options
+          child = HammockResource.new entity, options.merge(:parent => self)
+          children[child.mdl] = child
+        end
+
+        def piece_for verb, entity
+          child = children[entity.resource_sym]
+
+          if child.nil?
+            raise "No routes are defined for #{entity.resource}#{' within ' + ancestry.map {|r| r.mdl.to_s }.join(', ') unless ancestry.empty?}."
+          else
+            HammockRoutePiece.new(child).for(verb, entity)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/hammock/monkey_patches/string.rb

@@ -0,0 +1,197 @@
+module Hammock
+  module StringPatches
+    MixInto = String
+    
+    def self.included base # :nodoc:
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module ClassMethods
+
+      # Generates a random string consisting of +length+ hexadecimal characters (i.e. matching [0-9a-f]{length}).
+      def af09 length = 1
+        (1..length).inject('') {|a, t|
+          a << rand(16).to_s(16)
+        }
+      end
+
+      # Generates a random string consisting of +length+ alphamuneric characters (i.e. matching [0-9a-zA-Z]{length}).
+      def azAZ09 length = 1
+        (1..length).inject('') {|a, t|
+          a << ((r = rand(62)) < 36 ? r.to_s(36) : (r - 26).to_s(36).upcase)
+        }
+      end
+
+    end
+
+    module InstanceMethods
+
+      # Returns true iff +str+ appears exactly at the start of +self+.
+      def starts_with? str
+        self[0, str.length] == str
+      end
+
+      # Returns true iff +str+ appears exactly at the end of +self+.
+      def ends_with? str
+        self[-str.length, str.length] == str
+      end
+
+      # Return a duplicate of +self+, with +str+ prepended to it if it doesn't already start with +str+.
+      def start_with str
+        starts_with?(str) ? self : str + self
+      end
+
+      # Return a duplicate of +self+, with +str+ appended to it if it doesn't already end with +str+.
+      def end_with str
+        ends_with?(str) ? self : self + str
+      end
+
+      def possessive
+        "#{self}'#{'s' unless ends_with?('s')}"
+      end
+
+      # TODO any more to add?
+      NamePrefixes = %w[de den la von].freeze
+
+      def capitalize_name
+        split(' ').map {|term|
+          term.split('-').map {|term|
+            if NamePrefixes.include?(term)
+              term.downcase
+            elsif (term != term.downcase)
+              term
+            else # only capitalize words that are entirely lower case
+              term.capitalize
+            end
+          }.join('-')
+        }.join(' ')
+      end
+
+      def capitalize_name!
+        self.replace self.capitalize_name
+      end
+
+      # Returns whether this IP should be considered a valid one for a client to be using.
+      def valid_ip?
+        if production?
+          describe_as_ip == :public
+        else
+          describe_as_ip.in? :public, :private, :loopback
+        end
+      end
+
+      # Returns a symbol describing the class of IP address +self+ represents, if any.
+      #
+      # Examples:
+      #
+      #     "Hello world!".valid_ip?   #=> false
+      #     "192.168.".valid_ip?       #=> false
+      #     "127.0.0.1".valid_ip?      #=> :loopback
+      #     "172.24.137.6".valid_ip?   #=> :private
+      #     "169.254.1.142".valid_ip?  #=> :self_assigned
+      #     "72.9.108.122".valid_ip?   #=> :public
+      def describe_as_ip
+        parts = strip.split('.')
+        bytes = parts.zip(parts.map(&:to_i)).map {|(str,val)|
+          val if ((1..255) === val) || (val == 0 && str == '0')
+        }.squash
+
+        if bytes.length != 4
+          false
+        elsif bytes.starts_with? 0 # Source hosts on "this" network
+          :reserved
+        elsif bytes.starts_with? 127 # Loopback network; RFC1700
+          :loopback
+        elsif bytes.starts_with? 10 # Class-A private; RFC1918
+          :private
+        elsif bytes.starts_with?(172) && ((16..31) === bytes[1]) # Class-B private; RFC1918
+          :private
+        elsif bytes.starts_with? 169, 254 # Link-local range; RFC3330/3927
+          bytes[2].in?(0, 255) ? :reserved : :self_assigned
+        elsif bytes.starts_with? 192, 0, 2 # TEST-NET - used as example.com IP
+          :reserved
+        elsif bytes.starts_with? 192, 88, 99 # 6-to-4 relay anycast; RFC3068
+          :reserved
+        elsif bytes.starts_with? 192, 168 # Class-C private; RFC1918
+          :private
+        elsif bytes.starts_with? 198, 18 # Benchmarking; RFC2544
+          :reserved
+        else
+          :public
+        end
+      end
+
+      # Returns true if the string represents a valid email address.
+      def valid_email?
+        /^([a-z0-9\-\+\_\.]{2,})\@([a-z0-9\-]+\.)*([a-z0-9\-]{2,}\.)([a-z0-9\-]{2,})$/ =~ self
+      end
+
+      def colorize description = '', start_at = nil
+        if start_at.nil? || (cut_point = index(start_at)).nil?
+          Colorizer.colorize self, description
+        else
+          self[0...cut_point] + Colorizer.colorize(self[cut_point..-1], description)
+        end
+      end
+
+      def colorize! description = '', start_at = nil
+        replace colorize(description, start_at)
+      end
+
+      private
+
+      class Colorizer
+        HomeOffset = 29
+        LightOffset = 60
+        BGOffset = 10
+        LightRegex = /^light_/
+        ColorRegex = /^(light_)?none|gr[ae]y|red|green|yellow|blue|pink|cyan|white$/
+        CtrlRegex = /^bold|underlined?|blink(ing)?|reversed?$/
+        ColorOffsets = {
+          'none' => 0,
+          'gray' => 1, 'grey' => 1,
+          'red' => 2,
+          'green' => 3,
+          'yellow' => 4,
+          'blue' => 5,
+          'pink' => 6,
+          'cyan' => 7,
+          'white' => 8
+        }
+        CtrlOffsets = {
+          'bold' => 1,
+          'underline' => 4, 'underlined' => 4,
+          'blink' => 5, 'blinking' => 5,
+          'reverse' => 7, 'reversed' => 7
+        }
+        class << self
+          def colorize text, description
+            terms = " #{description} ".gsub(' light ', ' light_').gsub(' on ', ' on_').strip.split(/\s+/)
+            bg = terms.detect {|i| /on_#{ColorRegex}/ =~ i }
+            fg = terms.detect {|i| ColorRegex =~ i }
+            ctrl = terms.detect {|i| CtrlRegex =~ i }
+
+            "\e[#{"0;#{fg_for(fg)};#{bg_for(bg) || ctrl_for(ctrl)}"}m#{text}\e[0m"
+          end
+
+          def fg_for name
+            light = name.gsub!(LightRegex, '') unless name.nil?
+            (ColorOffsets[name] || 0) + HomeOffset + (light ? LightOffset : 0)
+          end
+
+          def bg_for name
+            # There's a hole in the table on bg=none, so we use BGOffset to the left
+            offset = fg_for((name || '').sub(/^on_/, ''))
+            offset + BGOffset unless offset == HomeOffset
+          end
+
+          def ctrl_for name
+            CtrlOffsets[name] || HomeOffset
+          end
+        end
+      end
+
+    end
+  end
+end