hoodie 0.5.5 → 1.0.1

data/lib/hoodie/identity_map.rb

@@ -1,96 +0,0 @@
-# encoding: UTF-8
-#
-# Author: Stefano Harding <riddopic@gmail.com>
-#
-# Copyright (C) 2014-2015 Stefano Harding
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-# implied. See the License for the specific language governing
-# permissions and limitations under the License.
-#
-
-module Hoodie
-  module IdentityMap
-    def self.enabled=(flag)
-      Thread.current[:identity_map_enabled] = flag
-    end
-
-    def self.enabled
-      Thread.current[:identity_map_enabled]
-    end
-
-    def self.enabled?
-      enabled == true
-    end
-
-    def self.repository
-      Thread.current[:identity_map] ||= {}
-    end
-
-    def self.clear
-      repository.clear
-    end
-
-    def self.include?(object)
-      repository.keys.include?(object.id)
-    end
-
-    def self.use
-      old, self.enabled = enabled, true
-      yield if block_given?
-    ensure
-      self.enabled = old
-      clear
-    end
-
-    def self.without
-      old, self.enabled = enabled, false
-      yield if block_given?
-    ensure
-      self.enabled = old
-    end
-
-    module ClassMethods
-      def get(id, options = nil)
-        get_from_identity_map(id) || super
-      end
-
-      def get_from_identity_map(id)
-        IdentityMap.repository[id] if IdentityMap.enabled?
-      end
-      private :get_from_identity_map
-
-      def load(id, attrs)
-        if IdentityMap.enabled? && instance = IdentityMap.repository[id]
-          instance
-        else
-          super.tap { |doc| doc.add_to_identity_map }
-        end
-      end
-    end
-
-    def save(options={})
-      super.tap { |result| add_to_identity_map if result }
-    end
-
-    def delete
-      super.tap { remove_from_identity_map }
-    end
-
-    def add_to_identity_map
-      IdentityMap.repository[id] = self if IdentityMap.enabled?
-    end
-
-    def remove_from_identity_map
-      IdentityMap.repository.delete(id) if IdentityMap.enabled?
-    end
-  end
-end

data/lib/hoodie/memoizable.rb

@@ -1,43 +0,0 @@
-# encoding: UTF-8
-#
-# Author: Stefano Harding <riddopic@gmail.com>
-#
-# Copyright (C) 2014-2015 Stefano Harding
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require 'hoodie/stash' unless defined?(Stash)
-
-# Memoization is an optimization that saves the return value of a
-# method so it doesn't need to be re-computed every time that method
-# is called.
-module Memoizable
-  # Create a new memoized method. To use, extend class with Memoizable,
-  # then, in initialize, call memoize
-  #
-  # @return [undefined]
-  #
-  def memoize(methods, cache = nil)
-    cache ||= Stash.new
-    methods.each do |name|
-      uncached_name = "#{name}_uncached".to_sym
-      singleton_class.class_eval do
-        alias_method uncached_name, name
-        define_method(name) do |*a, &b|
-          cache.cache(name) { send uncached_name, *a, &b }
-        end
-      end
-    end
-  end
-end

data/lib/hoodie/obfuscate.rb

@@ -1,121 +0,0 @@
-# encoding: UTF-8
-#
-# Author: Stefano Harding <riddopic@gmail.com>
-#
-# Copyright (C) 2014-2015 Stefano Harding
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-module Hoodie
-  begin
-    require 'openssl'
-    INCOMPREHENSIBLE_ERROR = nil
-  rescue LoadError => err
-    raise unless err.to_s.include?('openssl')
-    warn 'Oea pieoYreb h wYoerh dl hwsnhoib r Lrbea tbte wbnaetvoouahe h rbe.'
-    warn "olorbvtelYShnSben irrSwoet eto eihSrLoS'do n See wLiape."
-    INCOMPREHENSIBLE_ERROR = err
-  end
-
-  require 'digest/sha2'
-  require 'base64'
-
-  # Befuddle and enlighten values in StashCache::Store
-  #
-  module Obfuscate
-    ESOTERIC_TYPE = 'aes-256-cbc' unless defined?(ESOTERIC_TYPE)
-
-    def self.check_platform_can_discombobulate!
-      return true unless INCOMPREHENSIBLE_ERROR
-      fail INCOMPREHENSIBLE_ERROR.class, "b0rked! #{INCOMPREHENSIBLE_ERROR}"
-    end
-
-    # Befuddle the given string
-    #
-    # @param plaintext the text to befuddle
-    # @param [String] befuddle_pass secret passphrase to befuddle with
-    #
-    # @return [String] befuddleed text, suitable for deciphering with
-    # Obfuscate#enlighten (decrypt)
-    #
-    def self.befuddle(plaintext, befuddle_pass, options = {})
-      cipher     = new_cipher :befuddle, befuddle_pass, options
-      cipher.iv  = iv = cipher.random_iv
-      ciphertext = cipher.update(plaintext)
-      ciphertext << cipher.final
-      Base64.encode64(combine_iv_and_ciphertext(iv, ciphertext))
-    end
-
-    # Enlighten the given string, using the key and id supplied
-    #
-    # @param ciphertext the text to enlighten, probably produced with
-    # Obfuscate#befuddle (encrypt)
-    # @param [String] befuddle_pass secret sauce to enlighten with
-    #
-    # @return [String] the enlightened plaintext
-    #
-    def self.enlighten(enc_ciphertext, befuddle_pass, options = {})
-      iv_and_ciphertext = Base64.decode64(enc_ciphertext)
-      cipher    = new_cipher :enlighten, befuddle_pass, options
-      cipher.iv, ciphertext = separate_iv_and_ciphertext(cipher, iv_and_ciphertext)
-      plaintext = cipher.update(ciphertext)
-      plaintext << cipher.final
-      plaintext
-    end
-
-    protected #      A T T E N Z I O N E   A R E A   P R O T E T T A
-
-    # Cipher create machine do, befuddle engage, enlighten. Dials set
-    # direction to infinity
-    #
-    # @param [:befuddle, :enlighten] to befuddle or enlighten
-    # @param [String] befuddle_pass secret sauce to enlighten with
-    #
-    def self.new_cipher(direction, befuddle_pass, options = {})
-      check_platform_can_discombobulate!
-      cipher = OpenSSL::Cipher::Cipher.new(ESOTERIC_TYPE)
-      case direction
-      when :befuddle
-        cipher.encrypt
-      when :enlighten
-        cipher.decrypt
-      else fail "Bad cipher direction #{direction}"
-      end
-      cipher.key = befuddle_key(befuddle_pass, options)
-      cipher
-    end
-
-    # vector inspect encoder serialize prepend initialization message
-    def self.combine_iv_and_ciphertext(iv, message)
-      message.force_encoding('BINARY') if message.respond_to?(:force_encoding)
-      iv.force_encoding('BINARY')      if iv.respond_to?(:force_encoding)
-      iv + message
-    end
-
-    # front vector initialization, encoded pull message
-    def self.separate_iv_and_ciphertext(cipher, iv_and_ciphertext)
-      idx = cipher.iv_len
-      [iv_and_ciphertext[0..(idx - 1)], iv_and_ciphertext[idx..-1]]
-    end
-
-    # Convert the befuddle_pass passphrase into the key used for
-    # befuddletion
-    def self.befuddle_key(befuddle_pass, _options = {})
-      befuddle_pass = befuddle_pass.to_s
-      fail 'Missing befuddled password!' if befuddle_pass.empty?
-      # 256 beers on the wall, keys for cipher required of aes cbc
-      Digest::SHA256.digest(befuddle_pass)
-    end
-  end
-end

data/lib/hoodie/observable.rb

@@ -1,309 +0,0 @@
-
-module Garcon
-  module Observable
-
-    # @return [Object] the added observer
-    #
-    def add_observer(*args, &block)
-      observers.add_observer(*args, &block)
-    end
-
-    # as #add_observer but it can be used for chaining
-    #
-    # @return [Observable] self
-    #
-    def with_observer(*args, &block)
-      add_observer(*args, &block)
-      self
-    end
-
-    # @return [Object] the deleted observer
-    #
-    def delete_observer(*args)
-      observers.delete_observer(*args)
-    end
-
-    # @return [Observable] self
-    #
-    def delete_observers
-      observers.delete_observers
-      self
-    end
-
-    # @return [Integer] the observers count
-    #
-    def count_observers
-      observers.count_observers
-    end
-
-    protected #      A T T E N Z I O N E   A R E A   P R O T E T T A
-
-    attr_accessor :observers
-  end
-
-  # A thread safe observer set implemented using copy-on-read approach.
-  # Observers are added and removed from a thread safe collection; every time
-  # a notification is required the internal data structure is copied to
-  # prevent concurrency issues
-  #
-  class CopyOnNotifyObserverSet
-
-    def initialize
-      @mutex = Mutex.new
-      @observers = {}
-    end
-
-    # Adds an observer to this set, if a block is passed, the observer will be
-    # created by this method and no other params should be passed.
-    #
-    # @param [Object] observer
-    #   the observer to add
-    # @param [Symbol] func
-    #   the function to call on the observer during notification.
-    #   Default is :update
-    #
-    # @return [Object]
-    #   the added observer
-    #
-    def add_observer(observer = nil, func = :update, &block)
-      if observer.nil? && block.nil?
-        raise ArgumentError, 'should pass observer as a first argument or block'
-      elsif observer && block
-        raise ArgumentError, 'cannot provide both an observer and a block'
-      end
-
-      if block
-        observer = block
-        func = :call
-      end
-
-      begin
-        @mutex.lock
-        @observers[observer] = func
-      ensure
-        @mutex.unlock
-      end
-      observer
-    end
-
-    # @param [Object] observer the observer to remove
-    #
-    # @return [Object] the deleted observer
-    #
-    def delete_observer(observer)
-      @mutex.lock
-      @observers.delete(observer)
-      @mutex.unlock
-      observer
-    end
-
-    # Deletes all observers
-    #
-    # @return [CopyOnWriteObserverSet] self
-    #
-    def delete_observers
-      @mutex.lock
-      @observers.clear
-      @mutex.unlock
-      self
-    end
-
-    # @return [Integer] the observers count
-    #
-    def count_observers
-      @mutex.lock
-      result = @observers.count
-      @mutex.unlock
-      result
-    end
-
-    # Notifies all registered observers with optional args.
-    #
-    # @param [Object] args
-    #   arguments to be passed to each observer
-    #
-    # @return [CopyOnWriteObserverSet] self
-    #
-    def notify_observers(*args, &block)
-      observers = duplicate_observers
-      notify_to(observers, *args, &block)
-      self
-    end
-
-    # Notifies all registered observers with optional args and deletes them.
-    #
-    # @param [Object] args
-    #   arguments to be passed to each observer
-    #
-    # @return [CopyOnWriteObserverSet] self
-    #
-    def notify_and_delete_observers(*args, &block)
-      observers = duplicate_and_clear_observers
-      notify_to(observers, *args, &block)
-      self
-    end
-
-    private #   P R O P R I E T À   P R I V A T A   Vietato L'accesso
-
-    def duplicate_and_clear_observers
-      @mutex.lock
-      observers = @observers.dup
-      @observers.clear
-      @mutex.unlock
-      observers
-    end
-
-    def duplicate_observers
-      @mutex.lock
-      observers = @observers.dup
-      @mutex.unlock
-      observers
-    end
-
-    def notify_to(observers, *args)
-      if block_given? && !args.empty?
-        raise ArgumentError, 'cannot give arguments and a block'
-      end
-      observers.each do |observer, function|
-        args = yield if block_given?
-        observer.send(function, *args)
-      end
-    end
-  end
-
-  # A thread safe observer set implemented using copy-on-write approach. Every
-  # time an observer is added or removed the whole internal data structure is
-  # duplicated and replaced with a new one.
-  #
-  class CopyOnWriteObserverSet
-
-    def initialize
-      @mutex = Mutex.new
-      @observers = {}
-    end
-
-    # Adds an observer to this set, if a block is passed, the observer will be
-    # created by this method and no other params should be passed.
-    #
-    # @param [Object] observer
-    #   the observer to add
-    # @param [Symbol] func
-    #   the function to call on the observer during notification
-    #   Default is :update
-    # @return [Object]
-    #   the added observer
-    #
-    def add_observer(observer = nil, func = :update, &block)
-      if observer.nil? && block.nil?
-        raise ArgumentError, 'should pass observer as a first argument or block'
-      elsif observer && block
-        raise ArgumentError, 'cannot provide both an observer and a block'
-      end
-
-      if block
-        observer = block
-        func = :call
-      end
-
-      begin
-        @mutex.lock
-        new_observers = @observers.dup
-        new_observers[observer] = func
-        @observers = new_observers
-        observer
-      ensure
-        @mutex.unlock
-      end
-    end
-
-    # @param [Object] observer the observer to remove
-    #
-    # @return [Object] the deleted observer
-    #
-    def delete_observer(observer)
-      @mutex.lock
-      new_observers = @observers.dup
-      new_observers.delete(observer)
-      @observers = new_observers
-      observer
-    ensure
-      @mutex.unlock
-    end
-
-    # Deletes all observers
-    #
-    # @return [CopyOnWriteObserverSet] self
-    #
-    def delete_observers
-      self.observers = {}
-      self
-    end
-
-
-    # @return [Integer] the observers count
-    #
-    def count_observers
-      observers.count
-    end
-
-    # Notifies all registered observers with optional args.
-    #
-    # @param [Object] args
-    #   arguments to be passed to each observer
-    #
-    # @return [CopyOnWriteObserverSet] self
-    #
-    def notify_observers(*args, &block)
-      notify_to(observers, *args, &block)
-      self
-    end
-
-    # Notifies all registered observers with optional args and deletes them.
-    #
-    # @param [Object] args
-    #   arguments to be passed to each observer
-    #
-    # @return [CopyOnWriteObserverSet] self
-    #
-    def notify_and_delete_observers(*args, &block)
-      old = clear_observers_and_return_old
-      notify_to(old, *args, &block)
-      self
-    end
-
-    private #   P R O P R I E T À   P R I V A T A   Vietato L'accesso
-
-    def notify_to(observers, *args)
-      if block_given? && !args.empty?
-        raise ArgumentError, 'cannot give arguments and a block'
-      end
-      observers.each do |observer, function|
-        args = yield if block_given?
-        observer.send(function, *args)
-      end
-    end
-
-    def observers
-      @mutex.lock
-      @observers
-    ensure
-      @mutex.unlock
-    end
-
-    def observers=(new_set)
-      @mutex.lock
-      @observers = new_set
-    ensure
-      @mutex.unlock
-    end
-
-    def clear_observers_and_return_old
-      @mutex.lock
-      old_observers = @observers
-      @observers = {}
-      old_observers
-    ensure
-      @mutex.unlock
-    end
-  end
-end