browserio 0.0.4 → 0.1.0

data/lib/browserio/utilis/blank.rb

@@ -1,133 +0,0 @@
-# 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/element.rb

@@ -1,23 +0,0 @@
-if RUBY_ENGINE == 'opal'
-  class Element
-    alias_native :val
-    alias_native :prepend
-    alias_native :serialize_array, :serializeArray
-    alias_native :has_class, :hasClass
-    alias_native :click
-
-    def get_script url, &block
-      %x{
-        $.getScript(url, function(){
-          #{block.call if block_given?}
-        });
-      }
-    end
-  end
-
-  class String
-    def is_i?
-      self.to_i.to_s == self
-    end
-  end
-end

data/lib/browserio/utilis/hash.rb

@@ -1,77 +0,0 @@
-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

@@ -1,209 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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