machinima_utils 0.0.1 → 0.0.2

data/lib/array.rb

@@ -0,0 +1,50 @@
+class Array
+  def to_h
+    inject({}) { |h, v| h[v] = 1; h }
+  end
+
+  def map_with_index!
+    each_with_index do |e, idx|
+      self[idx] = yield(e, idx);
+    end
+  end
+
+  def map_with_index(& block)
+    dup.map_with_index!(& block)
+  end
+
+  #performs a binary insert on the array (assumes the array is already sorted)
+  def binary_insert item
+    if item > last
+      push item
+    else
+      left_bound = 0
+      right_bound = size - 1
+      while left_bound < right_bound
+        middle_index = left_bound + (right_bound - left_bound) / 2
+        if item < self[middle_index]
+          right_bound = middle_index
+        elsif item > self[middle_index]
+          left_bound = middle_index+1
+        else
+          break
+        end
+      end
+      middle_index = left_bound if left_bound == right_bound
+      insert middle_index, item
+    end
+  end
+
+  def indices_for_value value
+    indices = []
+    each_with_index do |v, i|
+      indices.push i if v == value
+    end
+    indices
+  end
+
+  def index_for_first_non_blank_value
+    each_with_index { |v, i| return i if v.present? }
+    nil
+  end
+end

data/lib/class.rb

@@ -0,0 +1,5 @@
+class Class
+  def descendants
+    ObjectSpace.each_object(Class).select { |klass| klass < self }
+  end
+end

data/lib/falseclass.rb

@@ -0,0 +1,5 @@
+class FalseClass < Object
+  def to_bool
+    false
+  end
+end

data/lib/fixnum.rb

@@ -0,0 +1,22 @@
+class Fixnum
+  def to_english
+    case self
+      when 0 then "zero"
+      when 1 then "one"
+      when 2 then "two"
+      when 3 then "three"
+      when 4 then "four"
+      when 5 then "five"
+      when 6 then "six"
+      when 7 then "seven"
+      when 8 then "eight"
+      when 9 then "nine"
+      when 10 then "ten"
+      else raise "to_english has not been implemented to convert #{self}"      
+    end
+  end
+
+  def to_bool
+    0 != self && nil != self  ? true : false  
+  end
+end

data/lib/http_utils.rb

@@ -0,0 +1,29 @@
+module HttpUtils
+  def self.http_get url
+    #if url.starts_with? 'https'
+    Net::HTTP.get_response(URI.parse(URI.escape(url)))
+  end
+
+  def self.https_get url
+    uri = URI.parse(URI.escape(url))
+    logger.debug uri.inspect
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true
+    http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+    request = Net::HTTP::Get.new(uri.request_uri)
+
+    response = http.request(request)
+    response
+  end
+
+  def self.http_post url, params={}
+    Net::HTTP.post_form URI.parse(URI.escape(url)), params
+  end
+
+ 
+
+
+  
+  #Code here
+end

data/lib/memcache.rb

@@ -0,0 +1,193 @@
+if MEMCACHE['use_dalli']
+  module Dalli
+    class Client
+      def initialize(servers=nil, options={})
+        @servers = env_servers || servers || 'localhost:11211'
+        @options = {:expires_in => 0}.merge(options)
+        self.extend(Dalli::Client::MemcacheClientCompatibility) if Dalli::Client.compatibility_mode
+      end
+
+      @locks = {}
+
+      def lock_and_set key, value, expiry = 0, raw = false
+        acquire_lock key
+        set key, value, expiry, raw
+        release_lock key
+      end
+
+      def acquire_lock key
+        @locks ||= {}
+        return true if has_lock? key
+
+        # Keep trying to add the key to memcache
+        # Add returns false if the key is already in memcache
+        # Add is our test-and-set operation
+        while !add lock_key(key), 1
+          # We didn't get the lock, keep trying till we do
+          Thread.pass
+        end
+        @locks[key] = 1
+      end
+
+      def release_lock key
+        if has_lock? key
+          delete lock_key(key)
+          @locks.delete key
+        end
+      end
+
+      def has_lock? key
+        @locks[key].present?
+      end
+
+      def lock_key name
+        "LOCK-#{@name}"
+      end
+
+      # Chokepoint method for instrumentation
+      def perform(op, key, * args)
+        retry_count = 0
+        key = key.to_s
+        validate_key(key)
+        key = key_with_namespace(key)
+        begin
+          server = ring.server_for_key(key)
+          server.request(op, key, * args)
+          # We rescue exception here, not NetworkError
+        rescue Exception => e
+          retry_count += 1
+          sleep(MEMCACHE['retry_sleep_interval'])
+          if retry_count < MEMCACHE['retry_count']
+            Dalli.logger.debug { e.message }
+            Dalli.logger.debug { "retrying request with new server" }
+            retry
+          else
+            raise "An Error occurred within Dalli and Memcached"
+          end
+        end
+      end
+    end
+  end
+
+
+else
+  class MemCache
+    def initialize(servers=nil, options={})
+      @servers = env_servers || servers || 'localhost:11211'
+      @options = {:expires_in => 0}.merge(options)
+      self.extend(Dalli::Client::MemcacheClientCompatibility) if Dalli::Client.compatibility_mode
+    end
+
+    @locks = {}
+
+    def lock_and_set key, value, expiry = 0, raw = false
+      acquire_lock key
+      set key, value, expiry, raw
+      release_lock key
+    end
+
+    def acquire_lock key
+      @locks ||= {}
+      return true if has_lock? key
+
+      # Keep trying to add the key to memcache
+      # Add returns false if the key is already in memcache
+      # Add is our test-and-set operation
+      while !add lock_key(key), 1
+        # We didn't get the lock, keep trying till we do
+        Thread.pass
+      end
+      @locks[key] = 1
+    end
+
+    def release_lock key
+      if has_lock? key
+        delete lock_key(key)
+        @locks.delete key
+      end
+    end
+
+    def has_lock? key
+      @locks[key].present?
+    end
+
+    def lock_key name
+      "LOCK-#{@name}"
+    end
+  end
+end
+
+
+=begin
+
+module Dalli
+  class Client
+    def initialize(servers=nil, options={})
+      @servers = env_servers || servers || 'localhost:11211'
+      @options = { :expires_in => 0 }.merge(options)
+      self.extend(Dalli::Client::MemcacheClientCompatibility) if Dalli::Client.compatibility_mode
+    end
+
+    @locks = {}
+
+    def lock_and_set key, value, expiry = 0, raw = false
+      acquire_lock key
+      set key, value, expiry, raw
+      release_lock key
+    end
+
+    def acquire_lock key
+      @locks ||= {}
+      return true if has_lock? key
+
+      # Keep trying to add the key to memcache
+      # Add returns false if the key is already in memcache
+      # Add is our test-and-set operation
+      while !add lock_key(key), 1
+        # We didn't get the lock, keep trying till we do
+        Thread.pass
+      end
+      @locks[key] = 1
+    end
+
+    def release_lock key
+      if has_lock? key
+        delete lock_key(key)
+        @locks.delete key
+      end
+    end
+
+    def has_lock? key
+      @locks[key].present?
+    end
+
+    def lock_key name
+      "LOCK-#{@name}"
+    end
+
+    # Chokepoint method for instrumentation
+    def perform(op, key, *args)
+      retry_count = 0
+      key = key.to_s
+      validate_key(key)
+      key = key_with_namespace(key)
+      begin
+        server = ring.server_for_key(key)
+        server.request(op, key, *args)
+      # We rescue exception here, not NetworkError
+      rescue Exception => e
+        retry_count += 1
+        sleep(MEMCACHE['retry_sleep_interval'])
+        if retry_count < MEMCACHE['retry_count']
+          Dalli.logger.debug { e.message }
+          Dalli.logger.debug { "retrying request with new server" }
+          retry
+        else
+          raise "An Error occurred within Dalli and Memcached"
+        end
+      end
+    end
+  end
+end
+
+=end

data/lib/model.rb

@@ -0,0 +1,75 @@
+module Sequel
+
+
+  class ValidationException < RuntimeError
+    attr_reader :validation_errors
+    
+    def initialize(validation_errors)
+      @validation_errors = validation_errors
+    end
+  end
+
+
+
+  class Model
+    if MEMCACHE['session_enabled'] && MEMCACHE['model_caching_enabled'] == true
+      Sequel::Model.plugin :caching, CACHE, :ttl => MEMCACHE['model_cache_ttl']
+    end
+    Sequel::Model.plugin :json_serializer
+    Sequel::Model.plugin :association_dependencies
+    Sequel::Model.plugin :validation_helpers
+    Sequel::Model.plugin :timestamps, :update_on_create => true
+
+    def save!
+      success = save
+      if !success
+        raise ValidationException.new(errors), "Could not save model due to failing validation: #{errors.inspect}"
+      end
+    end
+
+    def self.create! attributes={}
+      instance = self.new attributes
+      instance.save!
+      instance
+    end
+
+    def memcached?
+      MEMCACHE['session_enabled'] && MEMCACHE['model_caching_enabled'] && CACHE.get(cache_key).present?
+    end
+
+    def self.reload model
+      model.class[model.id] rescue model.class.filter(:id => model.id).first
+    end
+
+
+    def cached_association_id_key association
+      "#{self.class.name}_#{id}_#{association}"
+    end
+
+    def update_cached_association association
+      if MEMCACHE['session_enabled'] == true
+        cached_association = send association.to_sym, false
+        cached_association_id = cached_association.present?? cached_association.id : -1
+        CACHE.set cached_association_id_key(association), cached_association_id
+        cached_association_id
+      end
+    end
+
+    def update_cached_associations *associations
+      associations.each{ |association | update_cached_association association }
+    end
+
+    def get_cached_association association
+      return send(association.to_sym, false) if MEMCACHE['session_enabled'] != true
+      cached_association_id = CACHE.get cached_association_id_key(association)
+      if cached_association_id.nil?
+        cached_association_id = update_cached_association association
+      end
+      if -1 == cached_association_id
+        nil
+      else
+        association.to_upper_camelcase.constantize[cached_association_id]
+      end
+    end
+  end
+end

data/lib/nil_class.rb

@@ -0,0 +1,9 @@
+class NilClass
+  def id
+    raise 'id on nil called!'
+  end
+
+  def to_bool
+    false
+  end
+end

data/lib/object.rb

@@ -0,0 +1,5 @@
+class Object
+  def nil_or_true?
+    nil? || true == self
+  end
+end

data/lib/remove_accents.rb

@@ -0,0 +1,85 @@
+# RemoveAccents version 1.0.3 (c) 2008-2009 Solutions Informatiques Techniconseils inc.
+# 
+# This module adds 2 methods to the string class. 
+# Up-to-date version and documentation available at:
+#
+# http://www.techniconseils.ca/en/scripts-remove-accents-ruby.php
+#
+# This script is available under the following license :
+# Creative Commons Attribution-Share Alike 2.5.
+#
+# See full license and details at :
+# http://creativecommons.org/licenses/by-sa/2.5/ca/
+#
+# Version history:
+#   * 1.0.3 : July 23 2009
+#               Corrected some incorrect character codes. Source is now wikipedia at:
+#                 http://en.wikipedia.org/wiki/ISO/IEC_8859-1#Related_character_maps
+#               Thanks to Raimon Fernandez for pointing out the incorrect codes.
+#   * 1.0.2 : October 29 2008
+#               Slightly optimized version of urlize - Jonathan Grenier (jgrenier@techniconseils.ca)
+#   * 1.0.1 : October 29 2008
+#               First public revision - Jonathan Grenier (jgrenier@techniconseils.ca)
+#
+
+class String
+  # The extended characters map used by removeaccents. The accented characters 
+  # are coded here using their numerical equivalent to sidestep encoding issues.
+  # These correspond to ISO-8859-1 encoding.
+  ACCENTS_MAPPING = {
+    'E' => [200,201,202,203],
+    'e' => [232,233,234,235],
+    'A' => [192,193,194,195,196,197],
+    'a' => [224,225,226,227,228,229,230],
+    'C' => [199],
+    'c' => [231],
+    'O' => [210,211,212,213,214,216],
+    'o' => [242,243,244,245,246,248],
+    'I' => [204,205,206,207],
+    'i' => [236,237,238,239],
+    'U' => [217,218,219,220],
+    'u' => [249,250,251,252],
+    'N' => [209],
+    'n' => [241],
+    'Y' => [221],
+    'y' => [253,255],
+    'AE' => [306],
+    'ae' => [346],
+    'OE' => [188],
+    'oe' => [189]
+  }
+  
+  
+  # Remove the accents from the string. Uses String::ACCENTS_MAPPING as the source map.
+  def removeaccents    
+    str = String.new(self)
+    String::ACCENTS_MAPPING.each {|letter,accents|
+      packed = accents.pack('U*')
+      rxp = Regexp.new("[#{packed}]", nil, 'U')
+      str.gsub!(rxp, letter)
+    }
+    
+    str
+  end
+  
+  
+  # Convert a string to a format suitable for a URL without ever using escaped characters.
+  # It calls strip, removeaccents, downcase (optional) then removes the spaces (optional)
+  # and finally removes any characters matching the default regexp (/[^-_A-Za-z0-9]/).
+  #
+  # Options
+  #
+  # * :downcase => call downcase on the string (defaults to true)
+  # * :convert_spaces => Convert space to underscore (defaults to false)
+  # * :regexp => The regexp matching characters that will be converting to an empty string (defaults to /[^-_A-Za-z0-9]/)
+  def urlize(options = {})
+    options[:downcase] ||= true
+    options[:convert_spaces] ||= false
+    options[:regexp] ||= /[^-_A-Za-z0-9]/
+    
+    str = self.strip.removeaccents
+    str.downcase! if options[:downcase]
+    str.gsub!(/\ /,'_') if options[:convert_spaces]
+    str.gsub(options[:regexp], '')
+  end
+end

data/lib/string.rb

@@ -0,0 +1,50 @@
+class String
+  def self.random_alphanumeric_string( length, options = {} )
+    valid_chars = []
+    valid_chars += ("A"[0].."Z"[0]).to_a if options[:include_upper_case].nil? || options[:include_upper_case]
+    valid_chars += ("a"[0].."z"[0]).to_a if options[:include_lower_case].nil? || options[:include_lower_case]
+    valid_chars += ("0"[0].."9"[0]).to_a if options[:include_numbers].nil? || options[:include_numbers]
+    str = ""
+    length.times{ str += valid_chars[rand(valid_chars.size)].chr }
+    str
+  end
+
+  def strip_javascript
+    gsub(/<script.*?>[\s\S]*<\/script>/i, "")
+  end
+
+  def strip_html
+    gsub %r{</?[^>]+?>}, ''   
+  end
+    
+  def to_bool
+    downcased_str = downcase
+    if [true, 'true', 1, '1', 'T', 't'].include?( downcased_str )
+      true
+    elsif [false, 'false', 0, '0', 'F', 'f'].include?( downcased_str )
+      false
+    else
+      raise "string with value #{self} is not convertible to boolean"
+    end
+  end
+
+  def html_escape
+    gsub(/&/, "&amp;").gsub(/\"/, "&quot;").gsub(/>/, "&gt;").gsub(/</, "&lt;")
+  end
+
+  def truncate options={}
+    options.reverse_merge!(:length => 30, :omission => "...")
+    len = options[:length] - options[:omission].length
+    chars = to_s
+    (chars.length > options[:length] ? chars[0...len] + options[:omission] : to_s).to_s
+  end
+
+     #converts a snake case string to upper camel case
+  def to_upper_camelcase
+      split_word_array = split '_'
+      for word in split_word_array
+        word[0] = word[0].chr.capitalize
+      end
+      split_word_array.join
+  end
+end

data/lib/trueclass.rb

@@ -0,0 +1,5 @@
+class TrueClass < Object
+  def to_bool
+    true
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: machinima_utils
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 27
   prerelease: 
   segments: 
   - 0
   - 0
-  - 1
-  version: 0.0.1
+  - 2
+  version: 0.0.2
 platform: ruby
 authors: 
 - Machinima
@@ -28,6 +28,8 @@ extensions: []
 extra_rdoc_files: []
 
 files: 
+- lib/array.rb
+- lib/class.rb
 - lib/extensions/array.rb
 - lib/extensions/class.rb
 - lib/extensions/falseclass.rb
@@ -39,7 +41,17 @@ files:
 - lib/extensions/remove_accents.rb
 - lib/extensions/string.rb
 - lib/extensions/trueclass.rb
+- lib/falseclass.rb
+- lib/fixnum.rb
+- lib/http_utils.rb
 - lib/HttpUtils/http_utils.rb
+- lib/memcache.rb
+- lib/model.rb
+- lib/nil_class.rb
+- lib/object.rb
+- lib/remove_accents.rb
+- lib/string.rb
+- lib/trueclass.rb
 has_rdoc: true
 homepage: 
 licenses: []