browserio 0.0.1 → 0.0.2

data/lib/browserio/utilis/blank.rb

@@ -0,0 +1,133 @@
+# encoding: utf-8
+
+# https://github.com/rails/rails/blob/master/activesupport/lib/active_support/core_ext/object/blank.rb
+
+class Object
+  # An object is blank if it's false, empty, or a whitespace string.
+  # For example, '', '   ', +nil+, [], and {} are all blank.
+  #
+  # This simplifies
+  #
+  #   address.nil? || address.empty?
+  #
+  # to
+  #
+  #   address.blank?
+  #
+  # @return [true, false]
+  def blank?
+    respond_to?(:empty?) ? !!empty? : !self
+  end
+
+  # An object is present if it's not blank.
+  #
+  # @return [true, false]
+  def present?
+    !blank?
+  end
+
+  # Returns the receiver if it's present otherwise returns +nil+.
+  # <tt>object.presence</tt> is equivalent to
+  #
+  #    object.present? ? object : nil
+  #
+  # For example, something like
+  #
+  #   state   = params[:state]   if params[:state].present?
+  #   country = params[:country] if params[:country].present?
+  #   region  = state || country || 'US'
+  #
+  # becomes
+  #
+  #   region = params[:state].presence || params[:country].presence || 'US'
+  #
+  # @return [Object]
+  def presence
+    self if present?
+  end
+end
+
+class NilClass
+  # +nil+ is blank:
+  #
+  #   nil.blank? # => true
+  #
+  # @return [true]
+  def blank?
+    true
+  end
+end
+
+class FalseClass
+  # +false+ is blank:
+  #
+  #   false.blank? # => true
+  #
+  # @return [true]
+  def blank?
+    true
+  end
+end
+
+class TrueClass
+  # +true+ is not blank:
+  #
+  #   true.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end
+
+class Array
+  # An array is blank if it's empty:
+  #
+  #   [].blank?      # => true
+  #   [1,2,3].blank? # => false
+  #
+  # @return [true, false]
+  alias_method :blank?, :empty?
+end
+
+class Hash
+  # A hash is blank if it's empty:
+  #
+  #   {}.blank?                # => true
+  #   { key: 'value' }.blank?  # => false
+  #
+  # @return [true, false]
+  alias_method :blank?, :empty?
+end
+
+class String
+  BLANK_RE = /\A[[:space:]]*\z/
+
+  # A string is blank if it's empty or contains whitespaces only:
+  #
+  #   ''.blank?       # => true
+  #   '   '.blank?    # => true
+  #   "\t\n\r".blank? # => true
+  #   ' blah '.blank? # => false
+  #
+  # Unicode whitespace is supported:
+  #
+  #   "\u00a0".blank? # => true
+  #
+  # @return [true, false]
+  def blank?
+    BLANK_RE === self
+  end
+end
+
+class Numeric #:nodoc:
+  # No number is blank:
+  #
+  #   1.blank? # => false
+  #   0.blank? # => false
+  #
+  # @return [false]
+  def blank?
+    false
+  end
+end

data/lib/browserio/utilis/hash.rb

@@ -0,0 +1,77 @@
+class Hash
+  # add keys to hash
+  def to_obj
+    self.each do |k,v|
+      if v.kind_of? Hash
+        v.to_obj
+      end
+      k=k.to_s.gsub(/\.|\s|-|\/|\'/, '_').downcase.to_sym
+
+      ## create and initialize an instance variable for this key/value pair
+      self.instance_variable_set("@#{k}", v)
+
+      ## create the getter that returns the instance variable
+      self.class.send(:define_method, k, proc{self.instance_variable_get("@#{k}")})
+
+      ## create the setter that sets the instance variable
+      self.class.send(:define_method, "#{k}=", proc{|v| self.instance_variable_set("@#{k}", v)})
+    end
+    return self
+  end
+
+  def deep_merge(second)
+    merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : v2 }
+    self.merge(second, &merger)
+  end
+
+    # Slice a hash to include only the given keys. Returns a hash containing 
+  # the given keys.
+  # 
+  #   { a: 1, b: 2, c: 3, d: 4 }.slice(:a, :b)
+  #   # => {:a=>1, :b=>2}
+  # 
+  # This is useful for limiting an options hash to valid keys before 
+  # passing to a method:
+  #
+  #   def search(criteria = {})
+  #     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:
+  #
+  #   valid_keys = [:mass, :velocity, :time]
+  #   search(options.slice(*valid_keys))
+  def slice(*keys)
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    keys.each_with_object(self.class.new) { |k, hash| hash[k] = self[k] if has_key?(k) }
+  end
+
+  # Replaces the hash with only the given keys.
+  # Returns a hash containing the removed key/value pairs.
+  #
+  #   { a: 1, b: 2, c: 3, d: 4 }.slice!(:a, :b)
+  #   # => {:c=>3, :d=>4}
+  def slice!(*keys)
+    keys.map! { |key| convert_key(key) } if respond_to?(:convert_key, true)
+    omit = slice(*self.keys - keys)
+    hash = slice(*keys)
+    hash.default      = default
+    hash.default_proc = default_proc if default_proc
+    replace(hash)
+    omit
+  end
+
+  # Removes and returns the key/value pairs matching the given keys.
+  #
+  #   { a: 1, b: 2, c: 3, d: 4 }.extract!(:a, :b) # => {:a=>1, :b=>2}
+  #   { a: 1, b: 2 }.extract!(:a, :x)             # => {:a=>1}
+  def extract!(*keys)
+    keys.each_with_object(self.class.new) { |key, result| result[key] = delete(key) if has_key?(key) }
+  end
+
+  def indifferent
+    BrowserIO::IndifferentHash.new self
+  end
+end

data/lib/browserio/utilis/indifferent_hash.rb

@@ -0,0 +1,209 @@
+module BrowserIO
+  class IndifferentHash < Hash
+
+    def initialize(constructor = {}, &block)
+      if block_given?
+        yield self
+      elsif constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+    end
+
+    alias_method :get_value, :[] unless method_defined?(:get_value)
+    alias_method :set_value, :[]= unless method_defined?(:set_value)
+
+    def ==(other_hash)
+      to_hash == self.class.new(other_hash).to_hash
+    end
+
+    # Assigns a new value to the hash:
+    #
+    #   hash = IndifferentHash.new
+    #   hash[:key] = "value"
+    #
+    def []=(key, value)
+      set_value convert_key(key), navigate(value)
+    end
+
+    alias :store :[]=
+
+    def [](key)
+      get_value convert_key(key)
+    end
+
+    # Removes a specified key from the hash.
+    def delete(key)
+      super(convert_key(key))
+    end
+
+    # Returns an exact copy of the hash.
+    def dup
+      self.class.new to_hash
+    end
+
+    # Same as <tt>Hash#fetch</tt> where the key passed as argument can be
+    # either a string or a symbol:
+    #
+    #   counters = IndifferentHash.new
+    #   counters[:foo] = 1
+    #
+    #   counters.fetch("foo")          # => 1
+    #   counters.fetch(:bar, 0)        # => 0
+    #   counters.fetch(:bar) {|key| 0} # => 0
+    #   counters.fetch(:zoo)           # => KeyError: key not found: "zoo"
+    #
+    def fetch(key, *extras)
+      super(convert_key(key), *extras)
+    end
+
+    # Checks the hash for a key matching the argument passed in:
+    #
+    #   hash = IndifferentHash.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?
+
+    # Merges the instantiated 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
+
+    def respond_to?(m, include_private = false)
+      has_key?(m) || super
+    end
+
+    def to_hash
+      reduce({}) do |hash, (key, value)|
+        hash.merge key.to_sym => convert_for_to_hash(value)
+      end
+    end
+    alias_method :to_h, :to_hash
+
+    # Updates the instantized hash with values from the second:
+    #
+    #   hash_1 = IndifferentHash.new
+    #   hash_1[:key] = "value"
+    #
+    #   hash_2 = IndifferentHash.new
+    #   hash_2[:key] = "New Value!"
+    #
+    #   hash_1.update(hash_2) # => {"key"=>"New Value!"}
+    #
+    def update(other_hash)
+      other_hash.reduce(self) { |hash, (k, v)| hash[k] = navigate(v) ; hash }
+    end
+
+    alias_method :merge!, :update
+
+    # Returns an array of the values at the specified indices:
+    #
+    #   hash = IndifferentHash.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
+
+    protected :get_value, :set_value
+
+    def convert_for_to_hash(value)
+      case value
+      when IndifferentHash
+        convert_indifferent_hash_for_to_hash value
+      when Array
+        convert_array_for_to_hash value
+      else
+        convert_value_for_to_hash value
+      end
+    end
+
+    def convert_key(key)
+      key.kind_of?(Symbol) ? key.to_s : key
+    end
+
+    def convert_indifferent_hash_for_to_hash(value)
+      value.to_hash
+    end
+
+    def convert_array_for_to_hash(value)
+      value.map { |item| convert_for_to_hash item }
+    end
+
+    def convert_value_for_to_hash(value)
+      value
+    end
+
+    def navigate value
+      case value
+      when self.class
+        value
+      when Hash
+        navigate_hash value
+      when Array
+        navigate_array value
+      else
+        navigate_value value
+      end
+    end
+
+    def navigate_hash(value)
+      self.class.new value
+    end
+
+    def navigate_array(value)
+      value.map { |item| navigate item }
+    end
+
+    def navigate_value(value)
+      value
+    end
+
+    def navigate_hash_from_block(key, &block)
+      self[key] = self.class.new &block
+    end
+
+    private
+
+    def set_and_cache_value(key, value)
+      cache_getter! key
+      self[key] = value
+    end
+
+    def get_and_cache_value(key)
+      cache_getter! key
+      self[key]
+    end
+
+    def cache_getter!(key)
+      define_singleton_method(key) { self[key] } unless respond_to? key
+    end
+
+    def method_missing(m, *args, &block)
+      m = m.to_s
+      if m.chomp!('=') && args.count == 1
+        set_and_cache_value(m, *args)
+      elsif args.empty? && block_given?
+        self.navigate_hash_from_block m, &block
+      elsif args.empty?
+        get_and_cache_value(m)
+      else
+        fail ArgumentError, "wrong number of arguments (#{args.count} for 0)"
+      end
+    end
+
+  end
+end

data/lib/browserio/utilis/methods.rb

@@ -0,0 +1,25 @@
+module BrowserIO
+  module Methods
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def client?
+        RUBY_ENGINE == 'opal'
+      end
+
+      def server?
+        RUBY_ENGINE == 'ruby'
+      end
+    end
+
+    def server?
+      self.class.server?
+    end
+
+    def client?
+      self.class.client?
+    end
+  end
+end

data/lib/browserio/utilis/titleize.rb

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+# Adds String#titleize for creating properly capitalized titles.
+# It can be called as Titleize.titleize or "a string".titleize.
+#
+# titlecase is included as an alias for titleize.
+#
+# If loaded in a Rails environment, it modifies Inflector.titleize.
+module Titleize
+  SMALL_WORDS = %w{a an and as at but by en for if in of on or the to v v. via vs vs.}
+
+  extend self
+
+  # Capitalizes most words to create a nicer looking title string.
+  #
+  # The list of "small words" which are not capped comes from
+  # the New York Times Manual of Style, plus 'vs' and 'v'.
+  #
+  #   "notes on a scandal" # => "Notes on a Scandal"
+  #   "the good german"    # => "The Good German"
+  def titleize(title)
+    title = title.dup
+    title.downcase! unless title[/[[:lower:]]/]  # assume all-caps need fixing
+
+    phrases(title).map do |phrase|
+      words = phrase.split
+      words.map do |word|
+        def word.capitalize
+          # like String#capitalize, but it starts with the first letter
+          self.sub(/[[:alpha:]].*/) {|subword| subword.capitalize}
+        end
+
+        case word
+        when /[[:alpha:]]\.[[:alpha:]]/  # words with dots in, like "example.com"
+          word
+        when /[-‑]/  # hyphenated word (regular and non-breaking)
+          word.split(/([-‑])/).map do |part|
+            SMALL_WORDS.include?(part) ? part : part.capitalize
+          end.join
+        when /^[[:alpha:]].*[[:upper:]]/ # non-first letter capitalized already
+          word
+        when /^[[:digit:]]/  # first character is a number
+          word
+        when words.first, words.last
+          word.capitalize
+        when *(SMALL_WORDS + SMALL_WORDS.map {|small| small.capitalize })
+          word.downcase
+        else
+          word.capitalize
+        end
+      end.join(" ")
+    end.join(" ")
+  end
+
+  # Splits a title into an array based on punctuation.
+  #
+  #   "simple title"              # => ["simple title"]
+  #   "more complicated: titling" # => ["more complicated:", "titling"]
+  def phrases(title)
+    phrases = title.scan(/.+?(?:[:.;?!] |$)/).map {|phrase| phrase.strip }
+
+    # rejoin phrases that were split on the '.' from a small word
+    if phrases.size > 1
+      phrases[0..-2].each_with_index do |phrase, index|
+        if SMALL_WORDS.include?(phrase.split.last.downcase)
+          phrases[index] << " " + phrases.slice!(index + 1)
+        end
+      end
+    end
+
+    phrases
+  end
+end
+
+class String
+  # Capitalizes most words to create a nicer looking title string.
+  #
+  # The list of "small words" which are not capped comes from
+  # the New York Times Manual of Style, plus 'vs' and 'v'.
+  #
+  # titleize is also aliased as titlecase.
+  #
+  #   "notes on a scandal" # => "Notes on a Scandal"
+  #   "the good german"    # => "The Good German"
+  def titleize(opts={})
+    # if defined? ActiveSupport
+    #   ActiveSupport::Inflector.titleize(self, opts)
+    # else
+      Titleize.titleize(self)
+    # end
+  end
+  alias_method :titlecase, :titleize
+
+  def titleize!
+    replace(titleize)
+  end
+  alias_method :titlecase!, :titleize!
+end